uint16_t AnimationReader::readUnsignedInt16(void) { uint16_t result = readUnsignedByte(); result |= readUnsignedByte() << 8; return result; }
int extractCommandStatus(storage *s, unsigned char commandId, char * description) { int success=0; if(s == NULL) { //LOG_E(OMG, " client_traci_OMG::extractCommandStatus(): Tracker is NULL \n"); //printf(" client_traci_OMG::extractCommandStatus(): Tracker is NULL \n"); return success=0; } // validate the the message response from SUMO int storageLength_ = storageLength(s); // tracker currently points to the begining of the recieved data in the linked list tracker = s; // storage *freeTracker = tracker; // save it for calling free int commandLength = readUnsignedByte(); // CommandID needs to fit int rcvdCommandId = readUnsignedByte(); if (rcvdCommandId == (int)commandId) { //printf("%d",rcvdCommandId); //LOG_E(OMG, " Server answered to command\n"); //printf(" Server answered to command\n"); } // Get result and description unsigned char result = readUnsignedByte(); if (result != RTYPE_OK) { printf(" Server returned error\n"); return success=0; } if (result == RTYPE_OK) { // printf(" Server returned success\n"); success=1; } description = readString(); // print description if needed //free actual message content //depends on the message which is handled /* if (commandId != CMD_GET_VEHICLE_VARIABLE) freeStorage(freeTracker);*/ UNUSED_VARIABLE(commandLength); UNUSED_VARIABLE(storageLength_); return success; }
uint32_t AnimationReader::readUnsignedInt32(void) { uint32_t result = readUnsignedByte(); result |= readUnsignedByte() << 8; result |= readUnsignedByte() << 16; result |= readUnsignedByte() << 24; return result; }
bool WinHelpPhrIndexFile::getNextBitIntAlligned(QFile &file, IntAllignedCursor &cur) { if (cur.currentBitIndex == 0) { cur.currentDwordByte0 = readUnsignedByte(file); cur.currentDwordByte1 = readUnsignedByte(file); cur.currentDwordByte2 = readUnsignedByte(file); cur.currentDwordByte3 = readUnsignedByte(file); } bool result = false; quint8 mask = 0x01 << (cur.currentBitIndex % 8); switch (cur.currentBitIndex / 8) { case 0: if ((cur.currentDwordByte0 & mask) != 0) { result = true; } break; case 1: if ((cur.currentDwordByte1 & mask) != 0) { result = true; } break; case 2: if ((cur.currentDwordByte2 & mask) != 0) { result = true; } break; case 3: if ((cur.currentDwordByte3 & mask) != 0) { result = true; } break; default: throw std::runtime_error( "Unable to unpack bitcompressed phrases offset"); } cur.currentBitIndex++; if (cur.currentBitIndex > 31) { cur.currentBitIndex = 0; } return result; }
void commandGetVehicleVariable(char *vehID, int varID)// malloc for vehID and varID depends on speed or position { reset(); int domID = CMD_GET_VEHICLE_VARIABLE;//0xa4 specific for get vehicle variable command // command length writeUnsignedByte(1 + 1 + 1 + 4 + (int)strlen(vehID)); // command id writeUnsignedByte(CMD_GET_VEHICLE_VARIABLE); // variable id writeUnsignedByte(varID); // object id writeString(vehID); // send request message sendExact(storageLength(storageStart)); // receive answer message //receiveExact(); if (extractCommandStatus(receiveExact(), CMD_GET_VEHICLE_VARIABLE, description)){//<---RESPONSE_GET_VEHICLE_VARIABLE // validate result state if(tracker == NULL) { // LOG_E(OMG, " client_traci_OMG::commandGetVehicleVariable(): Tracker is NULL \n"); //printf(" client_traci_OMG::commandGetVehicleVariable(): Tracker is NULL \n"); return; } int length = readUnsignedByte(); if(length ==0) length = readInt(); int cmdId =readUnsignedByte(); if (cmdId != (CMD_GET_VEHICLE_VARIABLE+0x10)) { //LOG_E(OMG, " Wrong response recieved\n"); //printf(" Wrong response recieved\n"); return; } int VariableID = readUnsignedByte(); char* rs = readString(); int valueDataType = readUnsignedByte(); UNUSED_VARIABLE(VariableID); UNUSED_VARIABLE(rs); UNUSED_VARIABLE(valueDataType); UNUSED_VARIABLE(domID); } }
quint16 readCompressedUnsignedWord(QIODevice &device) { qint64 pos = device.pos(); quint8 lowByte = readUnsignedByte(device); if((lowByte & 1) != 0) { seekFile(device, pos); return readUnsignedWord(device) / 2; } else { return static_cast<quint16>(lowByte) / 2; } }
MetaCreatepatternbrushRecord::MetaCreatepatternbrushRecord(QIODevice &device) : MetafileRecord(device), patternBits() { this->type = readUnsignedWord(device); this->width = readUnsignedWord(device); this->height = readUnsignedWord(device); this->widthBytes = readUnsignedWord(device); this->planes = readUnsignedByte(device); if(this->planes != 1) { throw std::runtime_error("Invalid patternBitsLength value"); } this->bitsPerPixel = readUnsignedByte(device); seekDevice(device, Q_INT64_C(22)); quint16 wb = (this->width * static_cast<quint16>(this->bitsPerPixel) + 15)/16; quint16 realWidthBytes = wb * 2; if(realWidthBytes != this->widthBytes) { throw std::runtime_error("Invalid widthBytes value"); } this->patternBitsLength = this->widthBytes * this->height; QScopedArrayPointer<quint8>(new quint8[this->patternBitsLength]).swap(this->patternBits); fillBuffer(device, static_cast<qint64>(this->patternBitsLength), reinterpret_cast<void *>(this->patternBits.data()), static_cast<size_t>(this->patternBitsLength)); }
qint32 readCompressedSignedDWord(QIODevice &device) { qint64 pos = device.pos(); quint8 lowByte = readUnsignedByte(device); if((lowByte & 1) != 0) { seekFile(device, pos); return static_cast<qint32>((static_cast<qint64>(readUnsignedDWord( device)) - Q_INT64_C(0x80000000)) / Q_INT64_C(2)); } else { seekFile(device, pos); return static_cast<qint32>((static_cast<qint64>(readUnsignedWord(device)) - Q_INT64_C(0x8000)) / Q_INT64_C(2)); } }
bool WinHelpPhrIndexFile::getNextBitByteAlligned(QFile &file, ByteAllignedCursor &cur) { if (cur.currentBitIndex == 0) { cur.currentByte = readUnsignedByte(file); } bool result = false; quint8 mask = 0x01 << cur.currentBitIndex; if ((cur.currentByte & mask) != 0) { result = true; } cur.currentBitIndex++; if (cur.currentBitIndex > 7) { cur.currentBitIndex = 0; } return result; }
void processSubscriptions() { int noSubscriptions = readInt(); string_list* tmp_departed = departed; string_list* tmp_arrived = arrived; int s; for (s = 0; s<noSubscriptions; ++s) { int respStart = readInt(); int respLength = readUnsignedByte(); if (respLength == 0) respLength = readInt(); int cmdId = readUnsignedByte(); if (cmdId<0xe0||cmdId>0xef) { // only responses to subscription to supported types (vehicles, TLC, polygones...) are accepted //LOG_W(OMG, " Invalide Subscription response: %d\n",cmdId); //printf(" Invalide Subscription response: %d\n",cmdId); return; } char *objID = readString(); int varNo = readUnsignedByte(); UNUSED_VARIABLE(objID); UNUSED_VARIABLE(respStart); int i; for (i=0; i<varNo; ++i) { int varID = readUnsignedByte(); bool ok = readUnsignedByte()==RTYPE_OK; int valueDataType = readUnsignedByte(); UNUSED_VARIABLE(valueDataType); if (ok&&cmdId==CMD_SUBSCRIBE_SIM_VARIABLE+0x10&&varID==VAR_DEPARTED_VEHICLES_IDS) { tmp_departed = readStringList(tmp_departed); //printf(" OMG Got departed cars\n"); continue; } if (ok&&cmdId==CMD_SUBSCRIBE_SIM_VARIABLE+0x10&&varID==VAR_ARRIVED_VEHICLES_IDS) { tmp_arrived = readStringList(tmp_arrived); //printf(" OMG Got arrived cars\n"); continue; } } } }
NewFontDescriptor::NewFontDescriptor(QFile &file, qint64 off) : FontDescriptor(NEW_FONT_DESCRIPTOR) { PRINT_DBG("Reading New font descriptor at %lld", off); seekFile(file, off); quint8 unknownByte1 = readUnsignedByte(file); PRINT_DBG(" Unknown byte 1: %d", unknownByte1); this->facenameIndex = readUnsignedWord(file); PRINT_DBG(" Facename index: %d", this->facenameIndex); this->fgColor = readRGBBytes(file); PRINT_DBG(" Fg Red: %d", qRed(this->fgColor)); PRINT_DBG(" Fg Green: %d", qGreen(this->fgColor)); PRINT_DBG(" Fg Blue: %d", qBlue(this->fgColor)); this->bgColor = readRGBBytes(file); PRINT_DBG(" Bg Red: %d", qRed(this->bgColor)); PRINT_DBG(" Bg Green: %d", qGreen(this->bgColor)); PRINT_DBG(" Bg Blue: %d", qBlue(this->bgColor)); quint8 unknownBytes2[5] = { 0, 0, 0, 0, 0 }; fillBuffer(file, Q_INT64_C( 5), reinterpret_cast<void *>(&unknownBytes2), static_cast<size_t>(5)); PRINT_DBG(" Unknown byte 2-1: %d", unknownBytes2[0]); PRINT_DBG(" Unknown byte 2-2: %d", unknownBytes2[1]); PRINT_DBG(" Unknown byte 2-3: %d", unknownBytes2[2]); PRINT_DBG(" Unknown byte 2-4: %d", unknownBytes2[3]); PRINT_DBG(" Unknown byte 2-5: %d", unknownBytes2[4]); this->height = readSignedDWord(file); PRINT_DBG(" Height: %d", this->height); this->width = readSignedDWord(file); PRINT_DBG(" Width: %d", this->width); this->escapement = readSignedDWord(file); PRINT_DBG(" Escapement: %d", this->escapement); this->orientation = readSignedDWord(file); PRINT_DBG(" Orientation: %d", this->orientation); this->weight = readSignedDWord(file); PRINT_DBG(" Weight: %d", this->weight); quint8 italicByte = readUnsignedByte(file); this->italic = false; if(italicByte != 0) { this->italic = true; PRINT_DBG(" Italic font"); } quint8 underlineByte = readUnsignedByte(file); this->underline = false; if(underlineByte != 0) { this->underline = true; PRINT_DBG(" Underline font"); } quint8 strikeoutByte = readUnsignedByte(file); this->strikeOut = false; if(strikeoutByte != 0) { this->strikeOut = true; PRINT_DBG(" Strike out font"); } this->charset = readUnsignedByte(file); PRINT_DBG(" Charset: %d", this->charset); this->outPrecision = readUnsignedByte(file); PRINT_DBG(" Out precision: %d", this->outPrecision); this->clipPrecision = readUnsignedByte(file); PRINT_DBG(" Clip precision: %d", this->clipPrecision); this->quality = readUnsignedByte(file); PRINT_DBG(" Quality: %d", this->quality); quint8 pitchAndFamily = readUnsignedByte(file); this->pitch = pitchAndFamily & 0x03; PRINT_DBG(" Pitch: %d", this->pitch); this->family = (((pitchAndFamily & 0xF0) >> 4) & 0x0F); PRINT_DBG(" Family: %d", this->family); PRINT_DBG("New font descriptor loaded successfully"); }
WindowHpjRecord::WindowHpjRecord(QFile &file, qint64 off, QTextCodec *codec) { PRINT_DBG("Reading WindowHpj record at %lld", off); seekFile(file, off); SystemRecordHeader hdr(file, off); if (hdr.getRecordSize() < Q_INT64_C(90)) { qDebug() << "WindowHpj record size is too small: " << hdr.getRecordSize(); } quint8 flagsLIn = readUnsignedByte(file); PRINT_DBG(" Flags low byte: %d", flagsLIn); this->typeIsValid = false; if ((flagsLIn & 0x1) != 0) { this->typeIsValid = true; PRINT_DBG(" Window type field is valid"); } ; this->nameIsValid = false; if ((flagsLIn & 0x2) != 0) { this->nameIsValid = true; PRINT_DBG(" Window name field is valid"); } ; this->captionIsValid = false; if ((flagsLIn & 0x4) != 0) { this->captionIsValid = true; PRINT_DBG(" Window caption field is valid"); } ; this->xIsValid = false; if ((flagsLIn & 0x8) != 0) { this->xIsValid = true; PRINT_DBG(" X field is valid"); } ; this->yIsValid = false; if ((flagsLIn & 0x10) != 0) { this->yIsValid = true; PRINT_DBG(" Y field is valid"); } ; this->widthIsValid = false; if ((flagsLIn & 0x20) != 0) { this->widthIsValid = true; PRINT_DBG(" Width field is valid"); } ; this->heightIsValid = false; if ((flagsLIn & 0x40) != 0) { this->heightIsValid = true; PRINT_DBG(" Height type field is valid"); } ; this->maximizeWindow = false; if ((flagsLIn & 0x80) != 0) { this->maximizeWindow = true; PRINT_DBG(" Maximize field is valid"); } ; quint8 flagsHIn = readUnsignedByte(file); PRINT_DBG(" Flags high byte: %d", flagsHIn); this->rgbIsValid = false; if ((flagsHIn & 0x1) != 0) { this->rgbIsValid = true; PRINT_DBG(" RGB field is valid"); } ; this->rgbNsrIsValid = false; if ((flagsHIn & 0x2) != 0) { this->rgbNsrIsValid = true; PRINT_DBG(" RGB nsr field is valid"); } ; this->windowsAlwaysOnTop = false; if ((flagsHIn & 0x4) != 0) { this->windowsAlwaysOnTop = true; PRINT_DBG(" Window always on top flag is set"); } ; this->autoSizeHeight = false; if ((flagsHIn & 0x8) != 0) { this->autoSizeHeight = true; PRINT_DBG(" Auto size height flag is set"); } ; this->windowType = readFixedLengthString(file, 10, codec); PRINT_DBG(" Window type: %s", this->windowType.toLocal8Bit().data()); this->windowName = readFixedLengthString(file, 9, codec); PRINT_DBG(" Window name: %s", this->windowName.toLocal8Bit().data()); this->windowCaption = readFixedLengthString(file, 51, codec); PRINT_DBG(" Window caption: %s", this->windowCaption.toLocal8Bit().data()); this->x = readUnsignedWord(file); PRINT_DBG(" X: %d", this->x); this->y = readUnsignedWord(file); PRINT_DBG(" Y: %d", this->y); this->width = readUnsignedWord(file); PRINT_DBG(" Width: %d", this->width); this->height = readUnsignedWord(file); PRINT_DBG(" Height: %d", this->height); this->maximize = readUnsignedWord(file); PRINT_DBG(" Maximize: %d", this->maximize); this->rgbColor = readRGBDword(file); PRINT_DBG(" Red: %d", qRed(this->rgbColor)); PRINT_DBG(" Green: %d", qGreen(this->rgbColor)); PRINT_DBG(" Blue: %d", qBlue(this->rgbColor)); this->rgbNsrColor = readRGBDword(file); PRINT_DBG(" Red nsr: %d", qRed(this->rgbNsrColor)); PRINT_DBG(" Green nsr: %d", qGreen(this->rgbNsrColor)); PRINT_DBG(" Blue nsr: %d", qBlue(this->rgbNsrColor)); PRINT_DBG("WindowHpj record loaded successfully"); }
WinHelpPhraseFile::WinHelpPhraseFile(QFile &file, qint64 off, QTextCodec *codec, bool compressed, bool mvbHint) : phrases(), phrasesRaw() { PRINT_DBG("Loading WinHelp phrase file at %lld", off); if (codec == NULL) { throw std::runtime_error("Codec is NULL"); } seekFile(file, off); InternalDirectoryFileHeader hdr(file, off); if (compressed) { if (mvbHint) { seekFile(file, off + InternalDirectoryFileHeader::size); quint16 eightHundr = readUnsignedWord(file); quint16 nPhr = readUnsignedWord(file); quint16 oneHundr = readUnsignedWord(file); if ((eightHundr == 0x0800) && (oneHundr == 0x0100) && (nPhr != 0)) { PRINT_DBG( "Loading compressed WinHelp phrase file, MVB alternative"); seekFile(file, off + InternalDirectoryFileHeader::size); quint16 eightHundred = readUnsignedWord(file); PRINT_DBG(" Eight hundred: %d", eightHundred); quint16 numPhrases = readUnsignedWord(file); PRINT_DBG(" Num phrases: %d", numPhrases); quint16 oneHundred = readUnsignedWord(file); PRINT_DBG(" One hundred: %d", oneHundred); if (oneHundred != 0x0100) { throw std::runtime_error("Not a WinHelp phrase file"); } quint32 uncompressedSize = readUnsignedDWord(file); PRINT_DBG(" Uncompressed size: %d", uncompressedSize); for (int i = 0; i < 30; i++) { quint8 unused = readUnsignedByte(file); PRINT_DBG(" Unused: %d", unused); } QScopedArrayPointer<uint> phraseOffset( new uint[static_cast<size_t> (numPhrases + 1)]); PRINT_DBG("Reading phrase offsets at %lld", file.pos()); for (quint16 index = 0; index < numPhrases + 1; index++) { phraseOffset[index] = static_cast<uint> (readUnsignedWord( file)); PRINT_DBG(" Phrase offset: %d", phraseOffset[index]); } qint64 inputLength = off + hdr.getReservedSpace() - file.pos(); PRINT_DBG("Reading compressed phrases at %lld", file.pos()); QScopedArrayPointer<quint8> uncompressedPhrases( new quint8[static_cast<size_t> (uncompressedSize)]); unpackLZ77(file, file.pos(), inputLength, uncompressedPhrases.data(), static_cast<size_t> (uncompressedSize)); size_t pointer = static_cast<size_t> (0); for (quint16 index = 0; index < numPhrases; index++) { uint size = phraseOffset[index + 1] - phraseOffset[index]; QString phrase = readFixedLengthStringFromBuffer( uncompressedPhrases.data(), static_cast<size_t> (uncompressedSize), pointer, size, codec); this->phrases.append(phrase); QScopedArrayPointer<quint8> phraseRaw( new quint8[static_cast<size_t> (size)]); copyBytesFromBuffer( reinterpret_cast<const void *> (uncompressedPhrases. data()), static_cast<size_t> (uncompressedSize), pointer, static_cast<size_t> (size), reinterpret_cast<void *> (phraseRaw.data()), static_cast<size_t> (size)); this->phrasesRaw.append(QByteArray( reinterpret_cast<const char *> (phraseRaw.data()), static_cast<int> (size))); pointer += static_cast<size_t> (size); PRINT_DBG(" Phrase: %s", phrase.toLocal8Bit().data()); } } else { PRINT_DBG("Loading compressed WinHelp phrase file"); seekFile(file, off + InternalDirectoryFileHeader::size); quint16 numPhrases = readUnsignedWord(file); PRINT_DBG(" Num phrases: %d", numPhrases); quint16 oneHundred = readUnsignedWord(file); PRINT_DBG(" One hundred: %d", oneHundred); if (oneHundred != 0x0100) { throw std::runtime_error("Not a WinHelp phrase file"); } quint32 uncompressedSize = readUnsignedDWord(file); PRINT_DBG(" Uncompressed size: %d", uncompressedSize); QScopedArrayPointer<uint> phraseOffset( new uint[static_cast<size_t> (numPhrases + 1)]); PRINT_DBG("Reading phrase offsets at %lld", file.pos()); for (quint16 index = 0; index < numPhrases + 1; index++) { phraseOffset[index] = static_cast<uint> (readUnsignedWord( file)); PRINT_DBG(" Phrase offset: %d", phraseOffset[index]); } PRINT_DBG("Reading compressed phrases at %lld", file.pos()); qint64 inputLength = off + hdr.getReservedSpace() - file.pos(); QScopedArrayPointer<quint8> uncompressedPhrases( new quint8[static_cast<size_t> (uncompressedSize)]); unpackLZ77(file, file.pos(), inputLength, uncompressedPhrases.data(), static_cast<size_t> (uncompressedSize)); size_t pointer = static_cast<size_t> (0); for (quint16 index = 0; index < numPhrases; index++) { uint size = phraseOffset[index + 1] - phraseOffset[index]; QString phrase = readFixedLengthStringFromBuffer( uncompressedPhrases.data(), static_cast<size_t> (uncompressedSize), pointer, size, codec); this->phrases.append(phrase); QScopedArrayPointer<quint8> phraseRaw( new quint8[static_cast<size_t> (size)]); copyBytesFromBuffer( reinterpret_cast<const void *> (uncompressedPhrases. data()), static_cast<size_t> (uncompressedSize), pointer, static_cast<size_t> (size), reinterpret_cast<void *> (phraseRaw.data()), static_cast<size_t> (size)); this->phrasesRaw.append(QByteArray( reinterpret_cast<const char *> (phraseRaw.data()), static_cast<int> (size))); pointer += static_cast<size_t> (size); PRINT_DBG(" Phrase: %s", phrase.toLocal8Bit().data()); } } } else { PRINT_DBG("Loading compressed WinHelp phrase file"); seekFile(file, off + InternalDirectoryFileHeader::size); quint16 numPhrases = readUnsignedWord(file); PRINT_DBG(" Num phrases: %d", numPhrases); quint16 oneHundred = readUnsignedWord(file); PRINT_DBG(" One hundred: %d", oneHundred); if (oneHundred != 0x0100) { throw std::runtime_error("Not a WinHelp phrase file"); } quint32 uncompressedSize = readUnsignedDWord(file); PRINT_DBG(" Uncompressed size: %d", uncompressedSize); QScopedArrayPointer<uint> phraseOffset( new uint[static_cast<size_t> (numPhrases + 1)]); PRINT_DBG("Reading phrase offsets at %lld", file.pos()); for (quint16 index = 0; index < numPhrases + 1; index++) { phraseOffset[index] = static_cast<uint> (readUnsignedWord(file)); PRINT_DBG(" Phrase offset: %d", phraseOffset[index]); } PRINT_DBG("Reading compressed phrases at %lld", file.pos()); qint64 inputLength = off + hdr.getReservedSpace() - file.pos(); QScopedArrayPointer<quint8> uncompressedPhrases( new quint8[static_cast<size_t> (uncompressedSize)]); unpackLZ77(file, file.pos(), inputLength, uncompressedPhrases.data(), static_cast<size_t> (uncompressedSize)); size_t pointer = static_cast<size_t> (0); for (quint16 index = 0; index < numPhrases; index++) { uint size = phraseOffset[index + 1] - phraseOffset[index]; QString phrase = readFixedLengthStringFromBuffer( uncompressedPhrases.data(), static_cast<size_t> (uncompressedSize), pointer, size, codec); this->phrases.append(phrase); QScopedArrayPointer<quint8> phraseRaw( new quint8[static_cast<size_t> (size)]); copyBytesFromBuffer( reinterpret_cast<const void *> (uncompressedPhrases.data()), static_cast<size_t> (uncompressedSize), pointer, static_cast<size_t> (size), reinterpret_cast<void *> (phraseRaw.data()), static_cast<size_t> (size)); this->phrasesRaw.append(QByteArray( reinterpret_cast<const char *> (phraseRaw.data()), static_cast<int> (size))); pointer += static_cast<size_t> (size); PRINT_DBG(" Phrase: %s", phrase.toLocal8Bit().data()); } } } else { PRINT_DBG("Loading uncompressed WinHelp phrase file"); seekFile(file, off + InternalDirectoryFileHeader::size); quint16 numPhrases = readUnsignedWord(file); PRINT_DBG(" Num phrases: %d", numPhrases); quint16 oneHundred = readUnsignedWord(file); PRINT_DBG(" One hundred: %d", oneHundred); if (oneHundred != 0x0100) { throw std::runtime_error("Not a WinHelp phrase file"); } QScopedArrayPointer<uint> phraseOffset( new uint[static_cast<size_t> (numPhrases + 1)]); PRINT_DBG("Reading phrase offsets at %lld", file.pos()); for (quint16 index = 0; index < numPhrases + 1; index++) { phraseOffset[index] = static_cast<uint> (readUnsignedWord(file)); PRINT_DBG(" Phrase offset: %d", phraseOffset[index]); } PRINT_DBG("Reading phrases at %lld", file.pos()); for (quint16 index = 0; index < numPhrases; index++) { uint size = phraseOffset[index + 1] - phraseOffset[index]; qint64 posMem = file.pos(); QString phrase = readFixedLengthString(file, size, codec); this->phrases.append(phrase); QScopedArrayPointer<quint8> phraseRaw( new quint8[static_cast<size_t> (size)]); seekFile(file, posMem); fillBuffer(file, static_cast<qint64> (size), reinterpret_cast<void *> (phraseRaw.data()), static_cast<size_t> (size)); this->phrasesRaw.append(QByteArray( reinterpret_cast<const char *> (phraseRaw.data()), static_cast<int> (size))); PRINT_DBG(" Phrase: %s", phrase.toLocal8Bit().data()); } } PRINT_DBG("WinHelp phrase file loaded successfully"); }
// TODO not working for now..need to find a way to get the same info without using CMD_SCENARIO (as not implemented by SUMO) int commandGetMaxSUMONodesVariable() { reset(); int max_car = 0; // command length writeUnsignedByte(1 + 1 + 1 + 1 + 4 + 1 + 1 + 4); // command id writeUnsignedByte(CMD_SCENARIO); // flag writeUnsignedByte(0x00); // GET command for the generic environment-related values // command id //writeUnsignedByte(CMD_SCENARIO); // domain id writeUnsignedByte(0x01); // vehicle writeInt(0); // first vehicular domain // variable id writeUnsignedByte(DOMVAR_MAXCOUNT); // get maximum number of vehicles writeUnsignedByte(TYPE_INTEGER); // get maximum number of vehicles writeInt(max_car); // get maximum number of vehicles // send request message sendExact(storageLength(storageStart)); // receive answer message if (extractCommandStatus(receiveExact(), CMD_SCENARIO, description)){//<---RESPONSE_GET_VEHICLE_VARIABLE // validate result state if(tracker == NULL) { //LOG_E(OMG, " client_traci_OMG::commandGetMaxSUMONodesVariable(): Tracker is NULL \n"); return -1; } int res = readUnsignedByte(); int Length = readUnsignedByte(); // to check with Int int cmdId =readUnsignedByte(); if (cmdId != (CMD_SCENARIO)) { //LOG_E(OMG, " Wrong response recieved \n"); return -1; } int flag = readUnsignedByte(); int dom = readUnsignedByte(); // domain int domID = readInt(); // domain ID int VariableID = readUnsignedByte(); int valueDataType = readUnsignedByte(); if (valueDataType == TYPE_INTEGER) { max_car = readInt(); //LOG_N(OMG, " max Number SUMO nodes is: %f \n", max_car); } else { //LOG_W(OMG, " No Matching Data Type Value \n"); } UNUSED_VARIABLE(res); UNUSED_VARIABLE(Length); UNUSED_VARIABLE(flag); UNUSED_VARIABLE(dom); UNUSED_VARIABLE(domID); UNUSED_VARIABLE(VariableID); } return max_car; }
WinHelpIcon::WinHelpIcon(QFile &file, qint64 off) : images() { PRINT_DBG("Loading icon"); seekFile(file, off); quint16 magicIn = readUnsignedWord(file); if (magicIn != 0) { throw std::runtime_error("Not an icon resource header"); } PRINT_DBG(" Icon resource header magic: %d", magicIn); quint16 resourceTypeIn = readUnsignedWord(file); if (resourceTypeIn != 1) { throw std::runtime_error("Resource is not an icon"); } PRINT_DBG(" Icon resource header resource type: %d", resourceTypeIn); quint16 imagesCountIn = readUnsignedWord(file); PRINT_DBG(" Icon resource header images count: %d", imagesCountIn); QScopedArrayPointer<quint8> widths(new quint8[imagesCountIn]); QScopedArrayPointer<quint8> heights(new quint8[imagesCountIn]); QScopedArrayPointer<quint32> colorCounts(new quint32[imagesCountIn]); QScopedArrayPointer<quint16> colorPlanes(new quint16[imagesCountIn]); QScopedArrayPointer<quint16> bitsPerPixelCount(new quint16[imagesCountIn]); QScopedArrayPointer<qint64> bitmapSizes(new qint64[imagesCountIn]); QScopedArrayPointer<qint64> bitmapOffsets(new qint64[imagesCountIn]); for (int index = 0; index < imagesCountIn; index++) { widths[index] = readUnsignedByte(file); PRINT_DBG(" Icon image directory image header width: %d", widths[index]); heights[index] = readUnsignedByte(file); PRINT_DBG(" Icon image directory image header height: %d", heights[index]); colorCounts[index] = static_cast<quint32> (readUnsignedByte(file)); PRINT_DBG(" Icon image directory image header color count: %d", colorCounts[index]); quint8 reservedIn = readUnsignedByte(file); if (reservedIn != 0) { qDebug() << "Icon image directory image header reserved value is non-zero"; } PRINT_DBG(" Icon image directory image header reserved: %d", reservedIn); colorPlanes[index] = readUnsignedWord(file); PRINT_DBG(" Icon image directory image header color planes: %d", colorPlanes[index]); bitsPerPixelCount[index] = readUnsignedWord(file); PRINT_DBG( " Icon image directory image header bits per pixel count: %d", bitsPerPixelCount[index]); bitmapSizes[index] = static_cast<qint64> (readUnsignedDWord(file)); PRINT_DBG(" Icon image directory image header bitmap size: %lld", bitmapSizes[index]); bitmapOffsets[index] = static_cast<qint64> (readUnsignedDWord(file)); PRINT_DBG( " Icon image directory image header bitmap offset: %lld", bitmapOffsets[index]); } for (int index = 0; index < imagesCountIn; index++) { seekFile(file, off + bitmapOffsets[index]); quint32 headerSizeIn = readUnsignedDWord(file); PRINT_DBG(" Icon image header size: %d", headerSizeIn); if (headerSizeIn == 40) { qint32 widthIn = readSignedDWord(file); PRINT_DBG(" Icon image width: %d", widthIn); qint64 realWidth = static_cast<qint64> (widths[index]); if (realWidth == 0) { realWidth = static_cast<qint64> (widthIn); } qint32 heightIn = readSignedDWord(file); PRINT_DBG(" Icon image height: %d", heightIn); qint64 realHeight = static_cast<qint64> (heights[index]); if (realHeight == 0) { realHeight = (static_cast<qint64> (heightIn)) / (Q_INT64_C(2)); } quint16 colorPlanesIn = readUnsignedWord(file); PRINT_DBG(" Icon image color planes: %d", colorPlanesIn); quint16 bitsPerPixelCountIn = readUnsignedWord(file); PRINT_DBG(" Icon image bits per pixel count: %d", bitsPerPixelCountIn); if (colorCounts[index] == 0) { if (colorPlanesIn == 1) { if (bitsPerPixelCountIn == 1) { colorCounts[index] = 2; } else { if (bitsPerPixelCountIn == 4) { colorCounts[index] = 16; } else { if (bitsPerPixelCountIn == 8) { colorCounts[index] = 256; } else { if (bitsPerPixelCountIn != 32) { colorCounts[index] = 1 << bitsPerPixelCountIn; } } } } } else { colorCounts[index] = 1 << (bitsPerPixelCountIn * colorPlanesIn); } } quint32 compressionMethodIn = readUnsignedDWord(file); PRINT_DBG(" Icon image compression method: %d", compressionMethodIn); quint32 imageSizeIn = readUnsignedDWord(file); PRINT_DBG(" Icon image size: %d", imageSizeIn); qint32 horizontalResolutionIn = readSignedDWord(file); PRINT_DBG(" Icon image horizontal resolution: %d", horizontalResolutionIn); qint32 verticalResolutionIn = readSignedDWord(file); PRINT_DBG(" Icon image vertical resolution: %d", verticalResolutionIn); quint32 colorsInPaletteIn = readUnsignedDWord(file); PRINT_DBG(" Icon image colors in palette: %d", colorsInPaletteIn); quint32 importantColorsUsedIn = readUnsignedDWord(file); PRINT_DBG(" Icon image imporatnt colors used: %d", importantColorsUsedIn); if ((realWidth != 0) && (realHeight != 0) && ((colorCounts[index] == 0) || (colorCounts[index] == 2) || (colorCounts[index] == 16) || (colorCounts[index] == 256))) { QImage image(static_cast<int> (realWidth), static_cast<int> (realHeight), QImage::Format_ARGB32); if (colorCounts[index] == 2) { QScopedArrayPointer<QRgb> palette(new QRgb[2]); for (int i = 0; i < 2; i++) { palette[i] = readBGRDword(file); } qint64 scanlineBytes = ((realWidth + Q_INT64_C(31)) / (Q_INT64_C(32))) * Q_INT64_C(4); QScopedArrayPointer<quint8> xorImage( new quint8[scanlineBytes * realHeight]); QScopedArrayPointer<quint8> andImage( new quint8[scanlineBytes * realHeight]); if (file.read(reinterpret_cast<char *> (xorImage.data()), (scanlineBytes * realHeight)) != (scanlineBytes * realHeight)) { throw std::runtime_error("Unable to read icon image"); } if (file.read(reinterpret_cast<char *> (andImage.data()), (scanlineBytes * realHeight)) != (scanlineBytes * realHeight)) { throw std::runtime_error("Unable to read icon image"); } quint8 masks[] = { 128, 64, 32, 16, 8, 4, 2, 1 }; for (qint64 row = 0; row < realHeight; row++) { for (qint64 col = 0; col < realWidth; col++) { int colorIndex = 0; if ((xorImage[row * scanlineBytes + col / (Q_INT64_C(8))] & masks[col % (Q_INT64_C(8))]) != 0) { colorIndex = 1; } else { colorIndex = 0; } if ((andImage[row * scanlineBytes + col / (Q_INT64_C(8))] & masks[col % (Q_INT64_C(8))]) != 0) { image.setPixel(col, realHeight - Q_INT64_C(1) - row, qRgba(qRed(palette[colorIndex]), qGreen(palette[colorIndex]), qBlue( palette[colorIndex]), 0)); } else { image.setPixel(col, realHeight - Q_INT64_C(1) - row, qRgba(qRed(palette[colorIndex]), qGreen(palette[colorIndex]), qBlue( palette[colorIndex]), 0xFF)); } } } } else { if (colorCounts[index] == 16) { QScopedArrayPointer<QRgb> palette(new QRgb[16]); for (int i = 0; i < 16; i++) { palette[i] = readBGRDword(file); } qint64 scanlineBytesXor = ((realWidth * Q_INT64_C(4) + Q_INT64_C(31)) / (Q_INT64_C(32))) * Q_INT64_C(4); qint64 scanlineBytesAnd = ((realWidth + Q_INT64_C(31)) / (Q_INT64_C(32))) * Q_INT64_C(4); QScopedArrayPointer<quint8> xorImage( new quint8[scanlineBytesXor * realHeight]); QScopedArrayPointer<quint8> andImage( new quint8[scanlineBytesAnd * realHeight]); if (file.read( reinterpret_cast<char *> (xorImage.data()), (scanlineBytesXor * realHeight)) != (scanlineBytesXor * realHeight)) { throw std::runtime_error( "Unable to read icon image"); } if (file.read( reinterpret_cast<char *> (andImage.data()), (scanlineBytesAnd * realHeight)) != (scanlineBytesAnd * realHeight)) { throw std::runtime_error( "Unable to read icon image"); } quint8 masks[] = { 128, 64, 32, 16, 8, 4, 2, 1 }; for (qint64 row = 0; row < realHeight; row++) { for (qint64 col = 0; col < realWidth; col++) { quint8 colorIndex = 0; if ((col & Q_INT64_C(1)) == Q_INT64_C(0)) { colorIndex = xorImage[row * scanlineBytesXor + col / Q_INT64_C(2)]; colorIndex = colorIndex >> 4; } else { colorIndex = xorImage[row * scanlineBytesXor + col / Q_INT64_C(2)] & 15; } if ((andImage[row * scanlineBytesAnd + col / (Q_INT64_C(8))] & masks[col % (Q_INT64_C(8))]) != 0) { image.setPixel( col, realHeight - Q_INT64_C(1) - row, qRgba( qRed( palette[static_cast<int> ( colorIndex)]), qGreen( palette[static_cast<int> ( colorIndex)]), qBlue( palette[static_cast<int> ( colorIndex)]), 0)); } else { image.setPixel( col, realHeight - Q_INT64_C(1) - row, qRgba( qRed( palette[static_cast<int> ( colorIndex)]), qGreen( static_cast<int> (palette[ colorIndex])), qBlue( palette[static_cast<int> ( colorIndex)]), 0xFF)); } } } }
WinHelpPhrIndexFile::WinHelpPhrIndexFile(QFile &file, qint64 off) : phrasesOffset(), phrasesBits() { PRINT_DBG("Loading WinHelp PhrIndex file at %lld", off); seekFile(file, off); InternalDirectoryFileHeader hdr(file, off); seekFile(file, off + InternalDirectoryFileHeader::size); quint32 magic = readUnsignedDWord(file); PRINT_DBG(" Magic: %d", magic); if (magic != 1) { throw std::runtime_error("Not a PhrIndex file"); } quint32 nEntries = readUnsignedDWord(file); PRINT_DBG(" nEntries: %d", nEntries); quint32 compressedSize = readUnsignedDWord(file); PRINT_DBG(" Compressed size: %d", compressedSize); this->phrImageSize = static_cast<qint64> (readUnsignedDWord(file)); PRINT_DBG(" phrImage size: %lld", this->phrImageSize); this->phrImageCompressedSize = static_cast<qint64> (readUnsignedDWord(file)); PRINT_DBG(" phrImage compressed size: %lld", this->phrImageCompressedSize); quint32 alwaysZero = readUnsignedDWord(file); PRINT_DBG(" Always zero: %d", alwaysZero); if (alwaysZero != 0) { qDebug() << "Always zero phrIndex file field is non zero"; } quint8 bitfieldL = readUnsignedByte(file); PRINT_DBG(" Bitfield low byte: %d", bitfieldL); quint8 bitfieldH = readUnsignedByte(file); PRINT_DBG(" Bitfield high byte: %d", bitfieldH); quint8 bitCount = bitfieldL & 0x0F; PRINT_DBG(" Bitcount: %d", bitCount); quint16 unknownValue = readUnsignedWord(file); PRINT_DBG(" Unknown value: %d", unknownValue); this->phrasesOffset.resize(nEntries + 1); this->phrasesOffset[0] = 0; PRINT_DBG(" Phrase offset: %d", this->phrasesOffset[0]); IntAllignedCursor cur; cur.currentBitIndex = 0; cur.currentDwordByte0 = 0; cur.currentDwordByte1 = 0; cur.currentDwordByte2 = 0; cur.currentDwordByte3 = 0; for (quint32 i = 0; i < nEntries; i++) { uint n = 1; while (this->getNextBitIntAlligned(file, cur)) { n += static_cast<uint> (0x0001 << bitCount); } if (this->getNextBitIntAlligned(file, cur)) { n += 1; } if (bitCount > 1) { if (this->getNextBitIntAlligned(file, cur)) { n += 2; } } if (bitCount > 2) { if (this->getNextBitIntAlligned(file, cur)) { n += 4; } } if (bitCount > 3) { if (this->getNextBitIntAlligned(file, cur)) { n += 8; } } if (bitCount > 4) { if (this->getNextBitIntAlligned(file, cur)) { n += 16; } } this->phrasesOffset[i + 1] = this->phrasesOffset[i] + n; PRINT_DBG(" Phrase offset: %d", this->phrasesOffset[i + 1]); } this->phrasesBits.resize(nEntries); ByteAllignedCursor bCur; bCur.currentBitIndex = 0; bCur.currentByte = 0; for (quint32 index = 0; index < nEntries; index++) { if (this->getNextBitByteAlligned(file, bCur)) { this->phrasesBits[index] = true; PRINT_DBG(" Phrase bit is true"); } else { this->phrasesBits[index] = false; PRINT_DBG(" Phrase bit is false"); } } PRINT_DBG("WinHelp PhrIndex file loaded successfully"); }