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();
}
