Common::SeekableReadStream *GFF4Struct::getData(const Field &field) const { const uint32 offset = getDataOffset(field); if (offset == 0xFFFFFFFF) return 0; return &_parent->getStream(offset); }
void GFF4Struct::load(GFF4File &parent, const Field &genericParent) { static const uint32 kGenericSize = 8; Common::SeekableReadStream &data = parent.getStream(genericParent.offset); const uint32 genericCount = genericParent.isList ? data.readUint32LE() : 1; const uint32 genericStart = data.pos(); for (uint32 i = 0; i < genericCount; i++) { data.seek(genericStart + i * kGenericSize); const uint16 fieldType = data.readUint16LE(); const uint16 fieldFlags = data.readUint16LE(); const uint32 fieldOffset = getDataOffset(genericParent.isReference, data.pos()); if (fieldOffset == 0xFFFFFFFF) continue; // Load the field and its struct(s), if any Field &f = _fields[i] = Field(i, fieldType, fieldFlags, fieldOffset, true); if (f.type == kIFieldTypeStruct) loadStructs(parent, f); } _fieldCount = genericCount; }
void GFF4Struct::loadStructs(GFF4File &parent, Field &field) { if (field.offset == 0xFFFFFFFF) return; const GFF4File::StructTemplate &tmplt = parent.getStructTemplate(field.structIndex); Common::SeekableReadStream &data = parent.getStream(field.offset); const uint32 structCount = getListCount(data, field); const uint32 structSize = field.isReference ? 4 : tmplt.size; const uint32 structStart = data.pos(); field.structs.resize(structCount, 0); for (uint32 i = 0; i < structCount; i++) { const uint32 offset = getDataOffset(field.isReference, structStart + i * structSize); if (offset == 0xFFFFFFFF) continue; GFF4Struct *strct = parent.findStruct(generateID(offset, &tmplt)); if (!strct) strct = new GFF4Struct(parent, offset, tmplt); strct->_refCount++; field.structs[i] = strct; } }
std::shared_ptr< DataMatrix > SamplesInputProg::bin1_prog::readProgressiveData(unsigned int step) { char* buffer; if ( data.get() != NULL ) { input_mutex.lock(); for ( unsigned long cur_trace = NumTraces - step; cur_trace < NumTraces; cur_trace++ ) { buffer = ( char* ) fileoffset + getDataOffset ( cur_trace ); BufferToBitset<DATA_SIZE_BYTE> ( buffer, ( *data ) [cur_trace - NumTraces + step] ); } input_mutex.unlock(); return shared_ptr<DataMatrix> ( data ); } input_mutex.lock(); data.reset ( new DataMatrix ( step ) ); for ( unsigned long cur_trace = 0; cur_trace < step; cur_trace++ ) { buffer = ( char* ) fileoffset + getDataOffset ( cur_trace ); BufferToBitset<DATA_SIZE_BYTE> ( buffer, ( *data ) [cur_trace] ); } input_mutex.unlock(); return shared_ptr<DataMatrix> ( data ); }
void GFF4Struct::loadGeneric(GFF4File &parent, Field &field) { field.offset = getDataOffset(field.isList, field.offset); if (field.offset == 0xFFFFFFFF) return; GFF4Struct *strct = parent.findStruct(generateID(field.offset)); if (!strct) strct = new GFF4Struct(parent, field); strct->_refCount++; field.structs.push_back(strct); }
std::shared_ptr< DataMatrix > SamplesInput::bin1::readData() { char* buffer; if ( data.get() != NULL ) { return shared_ptr<DataMatrix> ( data ); } input_mutex.lock(); data.reset ( new DataMatrix ( NumTraces ) ); for ( unsigned long cur_trace = 0; cur_trace < NumTraces; cur_trace++ ) { buffer = ( char* ) fileoffset + getDataOffset ( cur_trace ); BufferToBitset<DATA_SIZE_BYTE> ( buffer, ( *data ) [cur_trace] ); } input_mutex.unlock(); return shared_ptr<DataMatrix> ( data ); }
int main(int argc, char *argv[]) { WINDOW *window = initscr(); start_color(); if (argc <= 1) { return pixedError("No image file specified!"); } if (!has_colors()) { return pixedError("Colors not supported!"); } Pixel *dataArray; /* Array of original image */ Pixel *averagedArray; /* Array after averaging */ FILE *file; file = fopen(argv[1], "rb"); if (file == NULL) { return pixedError("File not found!"); } unsigned int dataOffset = getDataOffset(file); unsigned int width = getWidth(file); unsigned int height = getHeight(file); unsigned int size = width * height; dataArray = malloc(sizeof(Pixel) * size); dataArray = getDataArray(file, dataOffset, size); averagedArray = getAveragedArray(dataArray, size, width, height); displayImage(averagedArray, ceil(ceil(size/BLOCK_WIDTH)/BLOCK_HEIGHT), ceil(width/BLOCK_WIDTH), ceil(height/BLOCK_HEIGHT)); free(dataArray); free(averagedArray); refresh(); getch(); /* Preserve ncurses window */ return EXIT_SUCCESS; }
ValueData::ValueDataPtr VKRecord::getValue() const { uint32_t length = getRawDataLength(); uint32_t offset = getDataOffset(); if (length > LARGE_DATA_SIZE + DB_DATA_SIZE) { throw RegistryParseException("Value size too large."); } RegistryByteBuffer * data = NULL; switch (getValueType()) { case ValueData::VALTYPE_BIN: case ValueData::VALTYPE_NONE: case ValueData::VALTYPE_SZ: case ValueData::VALTYPE_EXPAND_SZ: case ValueData::VALTYPE_MULTI_SZ: case ValueData::VALTYPE_LINK: case ValueData::VALTYPE_RESOURCE_LIST: case ValueData::VALTYPE_FULL_RESOURCE_DESCRIPTOR: case ValueData::VALTYPE_RESOURCE_REQUIREMENTS_LIST: if (length >= LARGE_DATA_SIZE) { uint32_t bufSize = length - LARGE_DATA_SIZE; data = new RegistryByteBuffer(new ByteBuffer(getData(DATA_OFFSET_OFFSET, bufSize), bufSize)); } else if (DB_DATA_SIZE < length && length < LARGE_DATA_SIZE) { std::auto_ptr< Cell > c(new Cell(_buf, offset)); if (c.get() == NULL) { throw RegistryParseException("Failed to create Cell for Value data."); } try { std::auto_ptr< DBRecord > db(c->getDBRecord()); if (db.get() == NULL) { throw RegistryParseException("Failed to create Cell for DBRecord."); } data = new RegistryByteBuffer(new ByteBuffer(db->getData(length), length)); } catch (RegistryParseException& ) { data = new RegistryByteBuffer(new ByteBuffer(c->getData(), length)); } } else { std::auto_ptr< Cell > c(new Cell(_buf, offset)); if (c.get() == NULL) { throw RegistryParseException("Failed to create Cell for Value data."); } ByteBuffer * byteBuffer = new ByteBuffer(c->getData(), length); data = new RegistryByteBuffer(byteBuffer); } break; case ValueData::VALTYPE_DWORD: case ValueData::VALTYPE_BIG_ENDIAN: data = new RegistryByteBuffer(new ByteBuffer(getData(DATA_OFFSET_OFFSET, 0x4), 0x4)); break; case ValueData::VALTYPE_QWORD: { std::auto_ptr< Cell > c(new Cell(_buf, offset)); if (c.get() == NULL) { throw RegistryParseException("Failed to create Cell for Value data."); } ByteBuffer * byteBuffer = new ByteBuffer(c->getData(), length); data = new RegistryByteBuffer(byteBuffer); } break; default: // Unknown registry type. Create an empty buffer. data = new RegistryByteBuffer(new ByteBuffer(0)); } return new ValueData(data, getValueType()); }
uint8_t ZBRxResponse::getDataLength() { return getPacketLength() - getDataOffset() - 1; }
int32_t ClientMessage::getDataSize() const { return this->getFrameLength() - getDataOffset(); }
uint32 GFF4Struct::getDataOffset(const Field &field) const { if (field.type == kIFieldTypeStruct) return 0xFFFFFFFF; return getDataOffset(field.isReference, field.offset); }
int main(int argc, char** argv){ /* no image entered into stdin */ if(argc < 1){ printw("Image file must be entered as standard input!\n"); endwin(); exit(-1); } WINDOW* win = initscr(); start_color(); if(!has_colors()){ printf("No color available!"); endwin(); exit(-1); } /* original array of original image */ struct pixel* dataArray; /* array after being averaged */ struct pixel* averagedArray; /* file not found */ FILE* fp; if(!(fp = fopen(argv[1],"rb"))){ printw("File not found\n"); exit(-1); } unsigned int dataOffset = getDataOffset(fp); unsigned int height = getHeight(fp); unsigned int width = getWidth(fp); unsigned int size = height*width; printw("%d",dataOffset); dataArray = malloc(sizeof(struct pixel) * size); dataArray = getDataArray(fp, dataOffset, size); averagedArray = getAveragedArray(dataArray, size, height, width); /*printArray(dataArray, size, height, width); printArray(averagedArray, ceil(ceil(size/8)/14), height/14, width/8);*/ /*printColor(averagedArray, ceil(ceil(size/8)/14));*/ if(!can_change_color || hasParameter(argc, argv, "-8")){ displayImageColor(averagedArray,ceil(ceil(size/8)/17),ceil(width/8),ceil(height/17)); } else if(can_change_color() && hasParameter(argc, argv, "-bw")){ displayImageGreyScale(averagedArray,ceil(ceil(size/8)/17), ceil(width/8), ceil(height/17)); } else if(can_change_color()){ displayImage16Color(averagedArray,ceil(ceil(size/8)/17),ceil(width/8),ceil(height/17)); } free(dataArray); free(averagedArray); refresh(); getch(); endwin(); }
NativeNaturalType getPadding() const { return getDataOffset()-(getSizeOffset()+getSizeBits()*getMaxCount()); }
NativeNaturalType offsetOfIndex(NativeNaturalType index) const { return getDataOffset()+index*getDataBits(); }
NativeNaturalType indexOfOffset(NativeNaturalType bitOffset) const { return (bitOffset-getDataOffset())/getDataBits(); }