int APIENTRY pngLoadF(FILE *fp, int mipmap, int trans, pngInfo *pinfo) {
GLint pack, unpack;
unsigned char header[8];
png_structp png;
png_infop info;
png_infop endinfo;
png_bytep data, data2;
png_bytep *row_p;
double fileGamma;
png_uint_32 width, height, rw, rh;
int depth, color;
png_uint_32 i;
fread(header, 1, 8, fp);
if (!png_check_sig(header, 8)) return 0;
png = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
info = png_create_info_struct(png);
endinfo = png_create_info_struct(png);
// DH: added following lines
if (setjmp(png->jmpbuf))
{
png_destroy_read_struct(&png, &info, &endinfo);
return 0;
}
// ~DH
png_init_io(png, fp);
png_set_sig_bytes(png, 8);
png_read_info(png, info);
png_get_IHDR(png, info, &width, &height, &depth, &color, NULL, NULL, NULL);
if (pinfo != NULL) {
pinfo->Width = width;
pinfo->Height = height;
pinfo->Depth = depth;
}
if (MaxTextureSize == 0)
glGetIntegerv(GL_MAX_TEXTURE_SIZE, &MaxTextureSize);
#ifdef SUPPORTS_PALETTE_EXT
#ifdef _WIN32
if (PalettedTextures == -1)
PalettedTextures = ExtSupported("GL_EXT_paletted_texture") && (strstr((const char *) glGetString(GL_VERSION), "1.1.0 3Dfx Beta") == NULL);
if (PalettedTextures) {
if (glColorTableEXT == NULL) {
glColorTableEXT = (PFNGLCOLORTABLEEXTPROC) wglGetProcAddress("glColorTableEXT");
if (glColorTableEXT == NULL)
PalettedTextures = 0;
}
}
#endif
#endif
if (PalettedTextures == -1)
PalettedTextures = 0;
if (color == PNG_COLOR_TYPE_GRAY || color == PNG_COLOR_TYPE_GRAY_ALPHA)
png_set_gray_to_rgb(png);
if (color&PNG_COLOR_MASK_ALPHA && trans != PNG_ALPHA) {
png_set_strip_alpha(png);
color &= ~PNG_COLOR_MASK_ALPHA;
}
if (!(PalettedTextures && mipmap >= 0 && trans == PNG_SOLID))
if (color == PNG_COLOR_TYPE_PALETTE)
png_set_expand(png);
/*--GAMMA--*/
checkForGammaEnv();
if (png_get_gAMA(png, info, &fileGamma))
png_set_gamma(png, screenGamma, fileGamma);
else
png_set_gamma(png, screenGamma, 1.0/2.2);
png_read_update_info(png, info);
data = (png_bytep) malloc(png_get_rowbytes(png, info)*height);
row_p = (png_bytep *) malloc(sizeof(png_bytep)*height);
for (i = 0; i < height; i++) {
if (StandardOrientation)
row_p[height - 1 - i] = &data[png_get_rowbytes(png, info)*i];
else
row_p[i] = &data[png_get_rowbytes(png, info)*i];
}
png_read_image(png, row_p);
free(row_p);
rw = SafeSize(width), rh = SafeSize(height);
if (rw != width || rh != height) {
const int channels = png_get_rowbytes(png, info)/width;
data2 = (png_bytep) malloc(rw*rh*channels);
/* Doesn't work on certain sizes */
/* if (gluScaleImage(glformat, width, height, GL_UNSIGNED_BYTE, data, rw, rh, GL_UNSIGNED_BYTE, data2) != 0)
return 0;
*/
Resize(channels, data, width, height, data2, rw, rh);
width = rw, height = rh;
free(data);
data = data2;
}
{ /* OpenGL stuff */
glGetIntegerv(GL_PACK_ALIGNMENT, &pack);
glGetIntegerv(GL_UNPACK_ALIGNMENT, &unpack);
glPixelStorei(GL_PACK_ALIGNMENT, 1);
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
#ifdef SUPPORTS_PALETTE_EXT
if (PalettedTextures && mipmap >= 0 && trans == PNG_SOLID && color == PNG_COLOR_TYPE_PALETTE) {
png_colorp pal;
int cols;
GLint intf;
if (pinfo != NULL) pinfo->Alpha = 0;
png_get_PLTE(png, info, &pal, &cols);
switch (cols) {
case 1<<1: intf = GL_COLOR_INDEX1_EXT; break;
case 1<<2: intf = GL_COLOR_INDEX2_EXT; break;
case 1<<4: intf = GL_COLOR_INDEX4_EXT; break;
case 1<<8: intf = GL_COLOR_INDEX8_EXT; break;
case 1<<12: intf = GL_COLOR_INDEX12_EXT; break;
case 1<<16: intf = GL_COLOR_INDEX16_EXT; break;
default:
/*printf("Warning: Colour depth %i not recognised\n", cols);*/
return 0;
}
glColorTableEXT(GL_TEXTURE_2D, GL_RGB8, cols, GL_RGB, GL_UNSIGNED_BYTE, pal);
glTexImage2D(GL_TEXTURE_2D, mipmap, intf, width, height, 0, GL_COLOR_INDEX, GL_UNSIGNED_BYTE, data);
}
else
#endif
if (trans == PNG_SOLID || trans == PNG_ALPHA || trans == PNG_LUMINANCEALPHA || color == PNG_COLOR_TYPE_RGB_ALPHA || color == PNG_COLOR_TYPE_GRAY_ALPHA) {
GLenum glformat;
GLint glcomponent;
switch (color) {
case PNG_COLOR_TYPE_GRAY:
case PNG_COLOR_TYPE_RGB:
case PNG_COLOR_TYPE_PALETTE:
glformat = GL_RGB;
glcomponent = 3;
if (pinfo != NULL) pinfo->Alpha = 0;
break;
case PNG_COLOR_TYPE_GRAY_ALPHA:
case PNG_COLOR_TYPE_RGB_ALPHA:
glformat = GL_RGBA;
glcomponent = 4;
if (pinfo != NULL) pinfo->Alpha = 8;
break;
default:
/*puts("glformat not set");*/
return 0;
}
if (trans == PNG_LUMINANCEALPHA)
glformat = GL_LUMINANCE_ALPHA;
if (mipmap == PNG_BUILDMIPMAPS)
Build2DMipmaps(glcomponent, width, height, glformat, data, 1);
else if (mipmap == PNG_SIMPLEMIPMAPS)
Build2DMipmaps(glcomponent, width, height, glformat, data, 0);
else
glTexImage2D(GL_TEXTURE_2D, mipmap, glcomponent, width, height, 0, glformat, GL_UNSIGNED_BYTE, data);
}
else {
png_bytep p, endp, q;
int r, g, b, a;
p = data, endp = p+width*height*3;
q = data2 = (png_bytep) malloc(sizeof(png_byte)*width*height*4);
if (pinfo != NULL) pinfo->Alpha = 8;
#define FORSTART \
do { \
r = *p++; /*red */ \
g = *p++; /*green*/ \
b = *p++; /*blue */ \
*q++ = r; \
*q++ = g; \
*q++ = b;
#define FOREND \
q++; \
} while (p != endp);
#define ALPHA *q
switch (trans) {
case PNG_CALLBACK:
FORSTART
ALPHA = AlphaCallback((unsigned char) r, (unsigned char) g, (unsigned char) b);
FOREND
break;
case PNG_STENCIL:
FORSTART
if (r == StencilRed && g == StencilGreen && b == StencilBlue)
ALPHA = 0;
else
ALPHA = 255;
FOREND
break;
case PNG_BLEND1:
FORSTART
a = r+g+b;
if (a > 255) ALPHA = 255; else ALPHA = a;
FOREND
break;
case PNG_BLEND2:
FORSTART
a = r+g+b;
if (a > 255*2) ALPHA = 255; else ALPHA = a/2;
FOREND
break;
case PNG_BLEND3:
FORSTART
ALPHA = (r+g+b)/3;
FOREND
break;
case PNG_BLEND4:
FORSTART
a = r*r+g*g+b*b;
if (a > 255) ALPHA = 255; else ALPHA = a;
FOREND
break;
case PNG_BLEND5:
FORSTART
a = r*r+g*g+b*b;
if (a > 255*2) ALPHA = 255; else ALPHA = a/2;
FOREND
break;
case PNG_BLEND6:
FORSTART
a = r*r+g*g+b*b;
if (a > 255*3) ALPHA = 255; else ALPHA = a/3;
FOREND
break;
//HACK: disabling this for now
/*
case PNG_BLEND7:
FORSTART
a = r*r+g*g+b*b;
if (a > 255*255) ALPHA = 255; else ALPHA = (int) (sqrt(float(a)));
FOREND
*/
break;
}
#undef FORSTART
#undef FOREND
#undef ALPHA
if (mipmap == PNG_BUILDMIPMAPS)
Build2DMipmaps(4, width, height, GL_RGBA, data2, 1);
else if (mipmap == PNG_SIMPLEMIPMAPS)
Build2DMipmaps(4, width, height, GL_RGBA, data2, 0);
else
glTexImage2D(GL_TEXTURE_2D, mipmap, 4, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, data2);
free(data2);
}
glPixelStorei(GL_PACK_ALIGNMENT, pack);
glPixelStorei(GL_UNPACK_ALIGNMENT, unpack);
} /* OpenGL end */
png_read_end(png, endinfo);
png_destroy_read_struct(&png, &info, &endinfo);
free(data);
return 1;
}
// Load a rBMF font file (raylib BitMap Font)
static SpriteFont LoadRBMF(const char *fileName)
{
// rBMF Info Header (16 bytes)
typedef struct {
char id[4]; // rBMF file identifier
char version; // rBMF file version
// 4 MSB --> main version
// 4 LSB --> subversion
char firstChar; // First character in the font
// NOTE: Depending on charDataType, it could be useless
short imgWidth; // Image width - always POT (power-of-two)
short imgHeight; // Image height - always POT (power-of-two)
short numChars; // Number of characters contained
short charHeight; // Characters height - the same for all characters
char compType; // Compression type:
// 4 MSB --> image data compression
// 4 LSB --> chars data compression
char charsDataType; // Char data type provided
} rbmfInfoHeader;
SpriteFont spriteFont = { 0 };
rbmfInfoHeader rbmfHeader;
unsigned int *rbmfFileData = NULL;
unsigned char *rbmfCharWidthData = NULL;
int charsDivisor = 1; // Every char is separated from the consecutive by a 1 pixel divisor, horizontally and vertically
FILE *rbmfFile = fopen(fileName, "rb"); // Define a pointer to bitmap file and open it in read-binary mode
if (rbmfFile == NULL)
{
TraceLog(WARNING, "[%s] rBMF font file could not be opened, using default font", fileName);
spriteFont = GetDefaultFont();
}
else
{
fread(&rbmfHeader, sizeof(rbmfInfoHeader), 1, rbmfFile);
TraceLog(DEBUG, "[%s] Loading rBMF file, size: %ix%i, numChars: %i, charHeight: %i", fileName, rbmfHeader.imgWidth, rbmfHeader.imgHeight, rbmfHeader.numChars, rbmfHeader.charHeight);
spriteFont.numChars = (int)rbmfHeader.numChars;
int numPixelBits = rbmfHeader.imgWidth*rbmfHeader.imgHeight/32;
rbmfFileData = (unsigned int *)malloc(numPixelBits*sizeof(unsigned int));
for (int i = 0; i < numPixelBits; i++) fread(&rbmfFileData[i], sizeof(unsigned int), 1, rbmfFile);
rbmfCharWidthData = (unsigned char *)malloc(spriteFont.numChars*sizeof(unsigned char));
for (int i = 0; i < spriteFont.numChars; i++) fread(&rbmfCharWidthData[i], sizeof(unsigned char), 1, rbmfFile);
// Re-construct image from rbmfFileData
//-----------------------------------------
Color *imagePixels = (Color *)malloc(rbmfHeader.imgWidth*rbmfHeader.imgHeight*sizeof(Color));
for (int i = 0; i < rbmfHeader.imgWidth*rbmfHeader.imgHeight; i++) imagePixels[i] = BLANK; // Initialize array
int counter = 0; // Font data elements counter
// Fill image data (convert from bit to pixel!)
for (int i = 0; i < rbmfHeader.imgWidth*rbmfHeader.imgHeight; i += 32)
{
for (int j = 31; j >= 0; j--)
{
if (BIT_CHECK(rbmfFileData[counter], j)) imagePixels[i+j] = WHITE;
}
counter++;
}
Image image = LoadImageEx(imagePixels, rbmfHeader.imgWidth, rbmfHeader.imgHeight);
ImageFormat(&image, UNCOMPRESSED_GRAY_ALPHA);
free(imagePixels);
TraceLog(DEBUG, "[%s] Image reconstructed correctly, now converting it to texture", fileName);
// Create spritefont with all data read from rbmf file
spriteFont.texture = LoadTextureFromImage(image);
UnloadImage(image); // Unload image data
//TraceLog(INFO, "[%s] Starting chars set reconstruction", fileName);
// Get characters data using rbmfCharWidthData, rbmfHeader.charHeight, charsDivisor, rbmfHeader.numChars
spriteFont.charValues = (int *)malloc(spriteFont.numChars*sizeof(int));
spriteFont.charRecs = (Rectangle *)malloc(spriteFont.numChars*sizeof(Rectangle));
spriteFont.charOffsets = (Vector2 *)malloc(spriteFont.numChars*sizeof(Vector2));
spriteFont.charAdvanceX = (int *)malloc(spriteFont.numChars*sizeof(int));
int currentLine = 0;
int currentPosX = charsDivisor;
int testPosX = charsDivisor;
for (int i = 0; i < spriteFont.numChars; i++)
{
spriteFont.charValues[i] = (int)rbmfHeader.firstChar + i;
spriteFont.charRecs[i].x = currentPosX;
spriteFont.charRecs[i].y = charsDivisor + currentLine*((int)rbmfHeader.charHeight + charsDivisor);
spriteFont.charRecs[i].width = (int)rbmfCharWidthData[i];
spriteFont.charRecs[i].height = (int)rbmfHeader.charHeight;
// NOTE: On image based fonts (XNA style), character offsets and xAdvance are not required (set to 0)
spriteFont.charOffsets[i] = (Vector2){ 0.0f, 0.0f };
spriteFont.charAdvanceX[i] = 0;
testPosX += (spriteFont.charRecs[i].width + charsDivisor);
if (testPosX > spriteFont.texture.width)
{
currentLine++;
currentPosX = 2*charsDivisor + (int)rbmfCharWidthData[i];
testPosX = currentPosX;
spriteFont.charRecs[i].x = charsDivisor;
spriteFont.charRecs[i].y = charsDivisor + currentLine*(rbmfHeader.charHeight + charsDivisor);
}
else currentPosX = testPosX;
}
spriteFont.size = spriteFont.charRecs[0].height;
TraceLog(INFO, "[%s] rBMF file loaded correctly as SpriteFont", fileName);
}
fclose(rbmfFile);
free(rbmfFileData); // Now we can free loaded data from RAM memory
free(rbmfCharWidthData);
return spriteFont;
}
/* this function open a file in the given archive and caches the block offset information. */
int32_t libmpq__block_open_offset(mpq_archive_s *mpq_archive, uint32_t file_number) {
/* some common variables. */
uint32_t i;
uint32_t packed_size;
int32_t rb = 0;
int32_t result = 0;
/* check if given file number is not out of range. */
CHECK_FILE_NUM(file_number, mpq_archive)
if (mpq_archive->mpq_file[file_number]) {
/* file already opened, so increment counter */
mpq_archive->mpq_file[file_number]->open_count++;
return LIBMPQ_SUCCESS;
}
/* check if file is not stored in a single sector. */
if ((mpq_archive->mpq_block[mpq_archive->mpq_map[file_number].block_table_indices].flags & LIBMPQ_FLAG_SINGLE) == 0) {
/* get packed size based on block size and block count. */
packed_size = sizeof(uint32_t) * (((mpq_archive->mpq_block[mpq_archive->mpq_map[file_number].block_table_indices].unpacked_size + mpq_archive->block_size - 1) / mpq_archive->block_size) + 1);
} else {
/* file is stored in single sector and we need only two entries for the packed block offset table. */
packed_size = sizeof(uint32_t) * 2;
}
/* check if data has one extra entry. */
if ((mpq_archive->mpq_block[mpq_archive->mpq_map[file_number].block_table_indices].flags & LIBMPQ_FLAG_CRC) != 0) {
/* add one uint32_t. */
packed_size += sizeof(uint32_t);
}
/* allocate memory for the file. */
if ((mpq_archive->mpq_file[file_number] = calloc(1, sizeof(mpq_file_s))) == NULL) {
/* memory allocation problem. */
result = LIBMPQ_ERROR_MALLOC;
goto error;
}
/* allocate memory for the packed block offset table. */
if ((mpq_archive->mpq_file[file_number]->packed_offset = calloc(1, packed_size)) == NULL) {
/* memory allocation problem. */
result = LIBMPQ_ERROR_MALLOC;
goto error;
}
/* initialize counter to one opening */
mpq_archive->mpq_file[file_number]->open_count = 1;
/* check if we need to load the packed block offset table, we will maintain this table for unpacked files too. */
if ((mpq_archive->mpq_block[mpq_archive->mpq_map[file_number].block_table_indices].flags & LIBMPQ_FLAG_COMPRESSED) != 0 &&
(mpq_archive->mpq_block[mpq_archive->mpq_map[file_number].block_table_indices].flags & LIBMPQ_FLAG_SINGLE) == 0) {
/* seek to block position. */
if (fseeko(mpq_archive->fp, mpq_archive->mpq_block[mpq_archive->mpq_map[file_number].block_table_indices].offset + (((long long)mpq_archive->mpq_block_ex[mpq_archive->mpq_map[file_number].block_table_indices].offset_high) << 32) + mpq_archive->archive_offset, SEEK_SET) < 0) {
/* seek in file failed. */
result = LIBMPQ_ERROR_SEEK;
goto error;
}
/* read block positions from begin of file. */
if (fread(mpq_archive->mpq_file[file_number]->packed_offset, 1, packed_size, mpq_archive->fp) != packed_size) {
/* something on read from archive failed. */
result = LIBMPQ_ERROR_READ;
goto error;
}
/* check if the archive is protected some way, sometimes the file appears not to be encrypted, but it is.
* a special case are files with an additional sector but LIBMPQ_FLAG_CRC not set. we don't want to handle
* them as encrypted. */
if (mpq_archive->mpq_file[file_number]->packed_offset[0] != packed_size &&
mpq_archive->mpq_file[file_number]->packed_offset[0] != packed_size + 4) {
/* file is encrypted. */
mpq_archive->mpq_block[mpq_archive->mpq_map[file_number].block_table_indices].flags |= LIBMPQ_FLAG_ENCRYPTED;
}
/* check if packed offset block is encrypted, we have to decrypt it. */
if (mpq_archive->mpq_block[mpq_archive->mpq_map[file_number].block_table_indices].flags & LIBMPQ_FLAG_ENCRYPTED) {
/* check if we don't know the file seed, try to find it. */
if (libmpq__decrypt_key((uint8_t *)mpq_archive->mpq_file[file_number]->packed_offset, packed_size, mpq_archive->block_size, &mpq_archive->mpq_file[file_number]->seed) < 0) {
/* sorry without seed, we cannot extract file. */
result = LIBMPQ_ERROR_DECRYPT;
goto error;
}
/* decrypt block in input buffer. */
if (libmpq__decrypt_block(mpq_archive->mpq_file[file_number]->packed_offset, packed_size, mpq_archive->mpq_file[file_number]->seed - 1) < 0 ) {
/* something on decrypt failed. */
result = LIBMPQ_ERROR_DECRYPT;
goto error;
}
/* check if the block positions are correctly decrypted. */
if (mpq_archive->mpq_file[file_number]->packed_offset[0] != packed_size) {
/* sorry without seed, we cannot extract file. */
result = LIBMPQ_ERROR_DECRYPT;
goto error;
}
}
} else {
/* check if file is not stored in a single sector. */
if ((mpq_archive->mpq_block[mpq_archive->mpq_map[file_number].block_table_indices].flags & LIBMPQ_FLAG_SINGLE) == 0) {
/* loop through all blocks and create packed block offset table based on block size. */
for (i = 0; i < ((mpq_archive->mpq_block[mpq_archive->mpq_map[file_number].block_table_indices].unpacked_size + mpq_archive->block_size - 1) / mpq_archive->block_size + 1); i++) {
/* check if we process the last block. */
if (i == ((mpq_archive->mpq_block[mpq_archive->mpq_map[file_number].block_table_indices].unpacked_size + mpq_archive->block_size - 1) / mpq_archive->block_size)) {
/* store size of last block. */
mpq_archive->mpq_file[file_number]->packed_offset[i] = mpq_archive->mpq_block[mpq_archive->mpq_map[file_number].block_table_indices].unpacked_size;
} else {
/* store default block size. */
mpq_archive->mpq_file[file_number]->packed_offset[i] = i * mpq_archive->block_size;
}
}
} else {
/* store offsets. */
mpq_archive->mpq_file[file_number]->packed_offset[0] = 0;
mpq_archive->mpq_file[file_number]->packed_offset[1] = mpq_archive->mpq_block[mpq_archive->mpq_map[file_number].block_table_indices].packed_size;
}
}
/* if no error was found, return zero. */
return LIBMPQ_SUCCESS;
error:
/* free packed block offset table and file pointer. */
free(mpq_archive->mpq_file[file_number]->packed_offset);
free(mpq_archive->mpq_file[file_number]);
/* return error constant. */
return result;
}
int reheader_file(const char *header, const char *file, int meta)
{
char *buffer;
int skip_until = 0;
FILE *fh;
int page_size;
char *buf;
BGZF *bgzf_out;
ssize_t nread;
BGZF *fp = bgzf_open(file,"r");
if (bgzf_read_block(fp) != 0 || !fp->block_length)
return -1;
buffer = fp->uncompressed_block;
if ( buffer[0]==meta )
{
skip_until = 1;
// Skip the header
while (1)
{
if ( buffer[skip_until]=='\n' )
{
skip_until++;
if ( skip_until>=fp->block_length )
{
if (bgzf_read_block(fp) != 0 || !fp->block_length)
error("no body?\n");
skip_until = 0;
}
// The header has finished
if ( buffer[skip_until]!=meta ) break;
}
skip_until++;
if ( skip_until>=fp->block_length )
{
if (bgzf_read_block(fp) != 0 || !fp->block_length)
error("no body?\n");
skip_until = 0;
}
}
}
fh = fopen(header,"r");
if ( !fh )
error("%s: %s", header,strerror(errno));
page_size = getpagesize();
buf = malloc(page_size); //Dong Code
bgzf_out = bgzf_dopen(fileno(stdout), "w");
while ( (nread=fread(buf,1,page_size-1,fh))>0 )
{
if ( nread<page_size-1 && buf[nread-1]!='\n' )
buf[nread++] = '\n';
if (bgzf_write(bgzf_out, buf, nread) < 0) error("Error: %d\n",bgzf_out->errcode);
}
fclose(fh);
if ( fp->block_length - skip_until > 0 )
{
if (bgzf_write(bgzf_out, buffer+skip_until, fp->block_length-skip_until) < 0)
error("Error: %d\n",fp->errcode);
}
if (bgzf_flush(bgzf_out) < 0)
error("Error: %d\n",bgzf_out->errcode);
while (1)
{
int count;
#ifdef _USE_KNETFILE
nread = knet_read(fp->fp, buf, page_size);
#else
nread = fread(buf, 1, page_size, fp->fp);
#endif
if ( nread<=0 )
break;
count = fwrite(buf, 1, nread, bgzf_out->fp);
if (count != nread)
error("Write failed, wrote %d instead of %d bytes.\n", count,(int)nread);
}
if (bgzf_close(bgzf_out) < 0)
error("Error: %d\n",bgzf_out->errcode);
return 0;
}
ECode CDebug::DoDumpHeap(
/* [in] */ FILE* fp)
{
uint8_t* info = NULL;
size_t overallSize, infoSize, totalMemory, backtraceSize;
get_malloc_leak_info(&info, &overallSize, &infoSize, &totalMemory,
&backtraceSize);
if (info == NULL) {
fprintf(fp, "Native heap dump not available. To enable, run these"
" commands (requires root):\n");
fprintf(fp, "$ adb shell setprop libc.debug.malloc 1\n");
fprintf(fp, "$ adb shell stop\n");
fprintf(fp, "$ adb shell start\n");
return NOERROR;
}
ASSERT_TRUE(infoSize != 0);
ASSERT_TRUE(overallSize % infoSize == 0);
fprintf(fp, "Android Native Heap Dump v1.0\n\n");
size_t recordCount = overallSize / infoSize;
fprintf(fp, "Total memory: %zu\n", totalMemory);
fprintf(fp, "Allocation records: %zd\n", recordCount);
if (backtraceSize != BACKTRACE_SIZE) {
fprintf(fp, "WARNING: mismatched backtrace sizes (%d vs. %d)\n",
backtraceSize, BACKTRACE_SIZE);
}
fprintf(fp, "\n");
/* re-sort the entries */
qsort(info, recordCount, infoSize, CompareHeapRecords);
/* dump the entries to the file */
const uint8_t* ptr = info;
for (size_t idx = 0; idx < recordCount; idx++) {
size_t size = *(size_t*) ptr;
size_t allocations = *(size_t*) (ptr + sizeof(size_t));
intptr_t* backtrace = (intptr_t*) (ptr + sizeof(size_t) * 2);
fprintf(fp, "z %d sz %8zu, num %4zu",
(size & SIZE_FLAG_ZYGOTE_CHILD) != 0,
size & ~SIZE_FLAG_ZYGOTE_CHILD,
allocations);
for (size_t bt = 0; bt < backtraceSize; bt++) {
if (backtrace[bt] == 0) {
break;
} else {
fprintf(fp, ", 0x%08x", backtrace[bt]);
}
}
fprintf(fp, "\n");
ptr += infoSize;
}
free_malloc_leak_info(info);
fprintf(fp, "MAPS\n");
const char* maps = "/proc/self/maps";
FILE* in = fopen(maps, "r");
if (in == NULL) {
fprintf(fp, "Could not open %s\n", maps);
return NOERROR;
}
char buf[BUFSIZ];
while (size_t n = fread(buf, sizeof(char), BUFSIZ, in)) {
fwrite(buf, sizeof(char), n, fp);
}
fclose(in);
fprintf(fp, "END\n");
return NOERROR;
}
/*!
* Initialization for the continuos Fourier transform operator.
*
* \param[out] mat (purify_sparsemat_row*) Sparse matrix containing
* the interpolation kernels for each visibility. The matrix is
* stored in compressed row storage format.
* \param[out] deconv (double*) Deconvolution kernel in real space
* \param[in] u (double*) u coodinates between -pi and pi
* \param[in] v (double*) v coodinates between -pi and pi
* \param[in] param structure storing information for the operator
*
* \authors Rafael Carrillo
*/
void purify_measurement_init_cft(purify_sparsemat_row *mat,
double *deconv, double *u, double *v,
purify_measurement_cparam *param) {
int D = 20;
int nmask = 9;
int i, j;
int nx2, ny2;
int row, numel;
double uinc, vinc;
// initialize wavelet kernel
int dummy, q, len;
double qq, *phi;
char buf[128];
sprintf(buf, "D%d.phi", D);
FILE *fwav = fopen(buf, "rb");
fread(&dummy, sizeof(int), 1, fwav);
if(dummy != D){
printf("%s: wrong wavelet number (%d)!\n", __FUNCTION__, dummy);
exit(-1);
}
fread(&q, sizeof(int), 1, fwav);
len = (1 << q) * (D - 1);
qq = 1 << q;
phi = (double *)malloc(sizeof(double) * len);
fread(phi, sizeof(double), len, fwav);
fclose(fwav);
//Sparse matrix initialization
nx2 = param->ofx*param->nx1;
ny2 = param->ofy*param->ny1;
mat->nrows = param->nmeas;
mat->ncols = nx2*ny2;
// mat->nvals = param->kx*param->ky*param->nmeas;
mat->nvals = param->nmeas * (nmask + 1) * (nmask + 1);
mat->real = 1;
mat->cvals = NULL;
// numel = param->kx*param->ky;
numel = (nmask + 1) * (nmask + 1);
mat->vals = (double*)malloc(mat->nvals * sizeof(double));
PURIFY_ERROR_MEM_ALLOC_CHECK(mat->vals);
mat->colind = (int*)malloc(mat->nvals * sizeof(int));
PURIFY_ERROR_MEM_ALLOC_CHECK(mat->colind);
mat->rowptr = (int*)malloc((mat->nrows + 1) * sizeof(int));
PURIFY_ERROR_MEM_ALLOC_CHECK(mat->rowptr);
uinc = param->umax / (nx2 / 2);
vinc = param->vmax / (ny2 / 2);
// sigmax = 1.0 / (double)param->nx1;
// sigmay = 1.0 / (double)param->ny1;
// uinc = 4.0 * M_PI / nx2;
// vinc = 4.0 * M_PI / ny2;
// Row pointer vector
for (j = 0; j < mat->nrows + 1; j++){
mat->rowptr[j] = j*numel;
}
int idu, idv, iv, iu, iv2, iu2, counter;
double ufrc, vfrc;
double fv, fu;
//Main loop
for (i=0; i < param->nmeas; i++){
// always the smaller pixel:
idu = floor(u[i] / uinc);
idv = floor(v[i] / vinc);
vfrc = v[i] / vinc;
ufrc = u[i] / uinc;
row = i * numel;
counter = 0;
for(iv = idv - nmask; iv <= idv; ++iv){
fv = phi[(int) (qq * fabs(iv - vfrc) + 0.5)];
for(iu = idu - nmask; iu <= idu; ++iu){
fu = phi[(int) (qq * fabs(iu - ufrc) + 0.5)];
iu2 = iu; iv2 = iv;
if(iu2 < 0) iu2 += nx2;
if(iu2 >= nx2) iu2 -= nx2;
if(iv2 < 0) iv2 += ny2;
if(iv2 >= ny2) iv2 -= ny2;
mat->vals[row + counter] = fv * fu;
// mat->vals[row + counter] = 1.0;
mat->colind[row + counter] = iv2 * nx2 + iu2;
counter++;
} // for iu
} // for iv
} // for nmeas
for(i = 0; i < param->nx1 * param->ny1; ++i){
deconv[i] = 1.0;
}
free(phi);
}
/**
* @brief 读取一个BIN文件
* @param file 文件名
* @param magic 文件标识字
* @param buffer 缓存区指针
* @param len 缓存区长度
* @return 成功返回实际读取长度,失败返回-1
*/
int ReadBinFile(const char *file, unsigned long magic, unsigned char *buffer, int len)
{
bin_filehead_t head;
FILE *pf;
unsigned short crc;
unsigned char *memcache = NULL;
int memlen, filelen;
if((len <= 0) || (len > MAX_FILELEN)) {
ErrorLog("invalid len(%d)\n", len);
return -1;
}
AssertLogReturn(NULL==file, -1, "null file\n");
pf = fopen(file, "rb");
if(NULL == pf) return -1;
if(fread(&head, sizeof(head), 1, pf) <= 0) {
ErrorLog("%s file head too short\n", file);
goto mark_fail;
}
if(head.magic != magic) {
ErrorLog("%s magic invalid(0x%08X)\n", file, head.magic);
goto mark_fail;
}
if(head.len <= 0 || head.len > MAX_FILELEN) {
ErrorLog("%s len invalid(%d)\n", file, head.len);
goto mark_fail;
}
crc = CalculateCRC((unsigned char *)&(head.datacrc), sizeof(head)-2);
if(head.headcrc != crc) {
ErrorLog("%s head crc erorr(0x%04X, should be 0x%04X)\n", file, head.headcrc, crc);
goto mark_fail;
}
if(head.len > MAX_MEMLEN) memlen = MAX_MEMLEN;
else memlen = head.len;
memcache = malloc(memlen);
if(NULL == memcache) {
ErrorLog("malloc %d bytes fail\n", head.len);
goto mark_fail;
}
crc = 0;
filelen = head.len;
while(filelen > 0) {
if(fread(memcache, memlen, 1, pf) <= 0) {
ErrorLog("%s len too long(%d)\n", file, head.len);
goto mark_fail;
}
CalculateCRCStep(memcache, memlen, &crc);
filelen -= memlen;
if(filelen > 0 && filelen < memlen) memlen = filelen;
}
if(head.datacrc != crc) {
ErrorLog("%s data crc erorr(0x%04X, should be 0x%04X)\n", file, head.datacrc, crc);
goto mark_fail;
}
if(len > head.len) len = head.len;
if(head.len > MAX_MEMLEN) {
fseek(pf, sizeof(head), SEEK_SET);
if(fread(buffer, len, 1, pf) <= 0) {
ErrorLog("read file error\n");
goto mark_fail;
}
}
else {
memcpy(buffer, memcache, len);
}
free(memcache);
fclose(pf);
return len;
mark_fail:
if(NULL != memcache) free(memcache);
fclose(pf);
return -1;
}
/*Function to perform registration*/
MI_Result Register(
_In_ RegistrationManager* self,
_In_ RegistrationRequest* request,
_Outptr_result_maybenull_ MI_Instance **cimErrorDetails)
{
MI_Result result = MI_RESULT_OK;
MI_Instance* registrationPayload = NULL;
MI_Uint32 getActionStatusCode;
MI_Char* resultStatus = NULL;
MI_Char* thumbprint = NULL;
MI_Value value;
MI_Uint32 flags;
int systemResult = 0;
if (cimErrorDetails)
{
*cimErrorDetails = NULL;
}
// Check if RegistrationKey is specified. If not specified, do not attempt to register.
result = MI_Instance_GetElement(request->registrationData, MSFT_RegistrationKey_Name, &value, NULL, &flags, NULL);
if (result != MI_RESULT_OK || flags & MI_FLAG_NULL || value.string == NULL || value.string[0] == '\0')
{
return MI_RESULT_OK;
}
if ( (access(OAAS_KEYPATH, F_OK) == -1) || (access(OAAS_CERTPATH, F_OK) == -1) )
{
system("touch " OAAS_KEYPATH "; chmod 0600 " OAAS_KEYPATH);
DSC_LOG_INFO("Executed '%T'\n", "touch " OAAS_KEYPATH "; chmod 0600 " OAAS_KEYPATH);
system("touch " OAAS_KEYPATH "_old; chmod 0600 " OAAS_KEYPATH "_old");
DSC_LOG_INFO("Executed '%T'\n", "touch " OAAS_KEYPATH "_old; chmod 0600 " OAAS_KEYPATH "_old");
systemResult = system("openssl req -subj '/CN=DSC-OaaS' -new -newkey rsa:2048 -days 365 -nodes -x509 -keyout " OAAS_KEYPATH "_old -out " OAAS_CERTPATH " && openssl rsa -in " OAAS_KEYPATH "_old -out " OAAS_KEYPATH " && rm -f " OAAS_KEYPATH "_old");
DSC_LOG_INFO("Executed '%T', returned %d\n", "openssl req -subj '/CN=DSC-OaaS' -new -newkey rsa:2048 -days 365 -nodes -x509 -keyout " OAAS_KEYPATH "_old -out " OAAS_CERTPATH " && openssl rsa -in " OAAS_KEYPATH "_old -out " OAAS_KEYPATH " && rm -f " OAAS_KEYPATH "_old", systemResult);
if (systemResult != 0 && errno != 10)
{
DSC_EventWriteLCMServerRegCertGenFailed(g_ConfigurationDetails.jobGuidString, self->agentId);
return GetCimMIError(MI_RESULT_FAILED, cimErrorDetails, ID_PULL_FAILEDTOGENERATECERT);
}
systemResult = system("openssl x509 -noout -in " OAAS_CERTPATH " -fingerprint | sed 's/^.*=//' > " OAAS_THUMBPRINTPATH);
DSC_LOG_INFO("Executed '%T', returned %d\n", "openssl x509 -noout -in " OAAS_CERTPATH " -fingerprint | sed 's/^.*=//' > " OAAS_THUMBPRINTPATH, systemResult);
if (systemResult != 0 && errno != 10)
{
DSC_EventWriteLCMServerRegCertGenFailed(g_ConfigurationDetails.jobGuidString, self->agentId);
return GetCimMIError(MI_RESULT_FAILED, cimErrorDetails, ID_PULL_FAILEDTOGENERATECERT);
}
{
long length;
FILE * fingerprint_file = fopen (OAAS_THUMBPRINTPATH, "r");
if (fingerprint_file)
{
fseek (fingerprint_file, 0, SEEK_END);
length = ftell (fingerprint_file);
fseek (fingerprint_file, 0, SEEK_SET);
thumbprint = DSC_malloc (length * sizeof(MI_Char), NitsHere());
fread (thumbprint, 1, length, fingerprint_file);
// There's a newline at the end, so null terminate overwriting it.
thumbprint[length-1] = '\0';
fclose (fingerprint_file);
}
else
{
DSC_EventWriteLCMServerRegCertGenFailed(g_ConfigurationDetails.jobGuidString, self->agentId);
return MI_RESULT_FAILED;
}
}
// Cache this URL.
// result = CacheServerURL(self, request->registrationData, thumbprint, cimErrorDetails);
//EH_CheckResult(result);
// Write this cache to DSC Cache
//result = UpdateServerURLsToDSCCache(self, cimErrorDetails);
//EH_CheckResult(result);
}
result = GetAgentInformation(®istrationPayload);
EH_CheckResult(result);
result = LCM_Do_Register((MI_Instance *)g_metaConfig, request->registrationData, self->agentId, thumbprint,
registrationPayload, &request->configurationNames, request->typeOfManagerInstance, &resultStatus, &getActionStatusCode, cimErrorDetails);
EH_CheckResult(result);
EH_UNWIND;
if (registrationPayload != NULL)
{
MI_Instance_Delete(registrationPayload);
}
if (thumbprint != NULL)
{
DSC_free(thumbprint);
}
DSC_free(resultStatus);
return result;
}
/*
* Recurse up from $PWD to find a .git/ directory with a valid HEAD file,
* read this file, copy the branch name in dst, up to a maximum of 'size'
* and return the amount of bytes copied.
*
* Input: /home/bjanin/prwd
* Output: prwd-1.3:/home/bjanin/prwd
*/
size_t
get_git_branch(wchar_t *dst, size_t size)
{
FILE *fp;
char *c;
char pwd[MAX_OUTPUT_LEN];
char candidate[MAXPATHLEN];
char buf[MAX_BRANCH_LEN];
size_t s;
struct stat bufstat;
int found_repo = -1;
/* start from the working dir */
strlcpy(pwd, getcwd(NULL, MAX_OUTPUT_LEN), MAX_OUTPUT_LEN);
do {
snprintf(candidate, MAXPATHLEN, "%s/.git/HEAD", pwd);
found_repo = stat(candidate, &bufstat);
if ((c = strrchr(pwd, '/')) == NULL)
break;
*c = '\0';
} while (found_repo != 0 && candidate[1] != '\0');
if (found_repo == -1)
return 0;
fp = fopen(candidate, "r");
if (fp == NULL) {
strlcpy(buf, "###", 4);
return mbstowcs(dst, buf, MAX_BRANCH_LEN);
}
s = fread(buf, 1, size, fp);
fclose(fp);
buf[MAX_BRANCH_LEN - 1] = '\0';
/* This is a branch head, just print the branch. */
if (strncmp(buf, "ref: refs/heads/", 16) == 0) {
char *nl = strchr(buf, '\n');
if (nl)
*(nl) = '\0';
c = buf + 16;
return mbstowcs(dst, c, MAX_BRANCH_LEN);
}
/* Show all other kinds of ref as-is (does it even exist?) */
if (strncmp(buf, "ref:", 4) == 0) {
char *nl = strchr(buf, '\n');
if (nl)
*(nl) = '\0';
c = buf + 5;
return mbstowcs(dst, c, MAX_BRANCH_LEN);
}
/* That's probably just a changeset, just show the first 6 chars. */
if (s > 6) {
strlcpy(buf + 6, "...", 4);
return mbstowcs(dst, buf, MAX_BRANCH_LEN);
}
/* We shouldn't get there, but we mind as well no crash. */
strlcpy(buf, "???", 4);
return mbstowcs(dst, buf, MAX_BRANCH_LEN);
}
int commandExtract(programOptions po)
{
// Open archive file
char* archiveFilename = programOptionsGetArchiveName(po);
FILE* archiveFile = fopen(archiveFilename, "r+");
// Check file existence
if (archiveFile == NULL)
{
fprintf(stderr, "No such file or directory : %s\n", archiveFilename);
return 1;
}
// Get file counts
char** extractFiles = programOptionsGetFilesName(po);
unsigned int extractFilesCount = programOptionsGetFilesCount(po);
if (extractFilesCount == 0)
{
// Read file count
unsigned int fileCount = 0;
if (fread(&fileCount, sizeof(unsigned int), 1, archiveFile) <= 0)
{
perror("Error reading.\n");
return 1;
}
// Read headers
fileHeader header;
for (int i = 0; i < fileCount; ++i)
{
size_t readSize = fread(&header, sizeof(fileHeader), 1, archiveFile);
if (readSize > 0)
{
// Verbose Log
if (programOptionsGetVerbose(po))
printf("Extracting file %s from archive %s\n", header.name, archiveFilename);
if (extractFile(archiveFile, header.name, header.name) != 0)
{
fprintf(stderr, "Error extracting %s.\n", header.name);
return 1;
}
}
else
{
// Close archive file
fclose(archiveFile);
return 1;
}
}
}
for (int i = 0; i < extractFilesCount; i++)
{
// Verbose Log
if (programOptionsGetVerbose(po))
printf("Extracting file %s from archive %s\n", extractFiles[i], archiveFilename);
if (extractFile(archiveFile, extractFiles[i], extractFiles[i]) != 0)
{
fprintf(stderr, "Error extracting %s.\n", extractFiles[i]);
return 1;
}
}
// Close archive file
fflush(archiveFile);
fclose(archiveFile);
return 0;
}
int commandUpdate(programOptions po)
{
// Open archive file
char* archiveFilename = programOptionsGetArchiveName(po);
FILE* archiveFile = fopen(archiveFilename, "r+");
// Check file existence
if (archiveFile == NULL)
{
fprintf(stderr, "No such file or directory : %s\n", archiveFilename);
return 1;
}
// Verbose Log
if (programOptionsGetVerbose(po))
printf("Searching files to update in %s\n", archiveFilename);
// Read file count
unsigned int fileCount = 0;
if (fread(&fileCount, sizeof(unsigned int), 1, archiveFile) <= 0)
{
printf("Error reading.\n");
return 1;
}
char** changedFiles;
changedFiles = (char**) malloc(sizeof(char*) * fileCount);
for (int i = 0; i < fileCount; i++)
changedFiles[i] = (char*) malloc(sizeof(char) * 100);
int cpt = 0;
// Read headers
fileHeader header;
for (int i = 0; i < fileCount; ++i)
{
size_t readSize = fread(&header, sizeof(fileHeader), 1, archiveFile);
if (readSize > 0)
{
struct stat buf;
stat(header.name, &buf);
if (header.mtime != buf.st_mtime)
{
if (programOptionsGetVerbose(po))
printf("Updating %s.\n", header.name);
strcpy(changedFiles[cpt], header.name);
cpt++;
}
}
else
{
// Close archive file
fflush(archiveFile);
fclose(archiveFile);
return 1;
}
}
for (int i = 0; i < cpt; i++)
{
if ((deleteFile(programOptionsGetVerbose(po), changedFiles[i], archiveFilename, archiveFile) != 0) || (addFile(archiveFile, changedFiles[i], programOptionsGetVerbose(po), archiveFilename) != 0))
{
fprintf(stderr, "Error updating %s", changedFiles[i]);
return 1;
}
}
for (int i = 0; i < fileCount; i++)
free(changedFiles[i]);
free(changedFiles);
// Close archive file
fflush(archiveFile);
fclose(archiveFile);
return 0;
}
int main(int argc, char** argv){
int CALL_CHKSUM=0;
int CHUNK_SIZE=1024;
int fileCount=0;
int isFinished=1;
unsigned int fileChecksum = 0;
char* fileName;
int opt;
while((opt = getopt(argc, argv,"-hx:b:"))!=-1){
switch (opt) {
case 1:
fileName = optarg;
break;
case 'h':
printf("OPTIONS\n\t-h\t\tprint a summary of options and exit\n\t-b SIZE\t\tput at most SIZE bytes per output file\n\t-x\t\tprint the checksum as a hexadecimal rather than decimal number.\n");
exit(0);
case 'x':
CALL_CHKSUM=1;
fileName = argv[argc-1];
break;
case 'b':
if(optarg!=0) CHUNK_SIZE = atoi(optarg);
fileName = argv[argc-1];
break;
default:
fprintf(stderr,"Usage: %s [-h] [-x] [-b SIZE] FILE\n",argv[0]);
exit(1);
}
}
FILE *fp = fopen(fileName, "r");
if(fp==0){
printf("The filename argument you provided is not valid\n");
return 0;
}
unsigned char chunk[CHUNK_SIZE];
memset(chunk,0,CHUNK_SIZE);
unsigned char checksum = 0;
int fileSize = 0;
struct stat st = {0};
if (stat("parts", &st) == -1) {
mkdir("parts", 0700);
}
//part A
//we should write a function which gets (location in a file, max size of bytes, name of target)
//it will do the body of the while, one and replace it
//ftell(tell me where in the file we are)
//fseek(takes us to the place we want)
//use only before the loop,jump to the end (0 from the end)
//then use ftell to know the filesize
//now get chank file: int numchank=(filesize+chanksize-1)/chanksize;
//part B
//make the function works on difreent proccesses
//use folk()
//this part should work in deffirent procceses
while (isFinished){
if ((fileSize = fread(&chunk, 1, CHUNK_SIZE, fp))==0) break;
unsigned int chunksum=0;
char newFileName[strlen(fileName)+15]; //create new file name
fileCount++;
newFile(newFileName,fileName,fileCount);
FILE* file = fopen(newFileName,"w+"); //new file
fwrite(&chunksum,sizeof(chunksum),1,file); //write 0000 at the beginning
fwrite(&chunk,fileSize,1,file);
chunksum = chksum(file);//do chksum
fileChecksum^=chunksum;//overall chanksum
rewind(file);//look at first byte and write the new chanksum instand of 0000
fwrite(&chunksum,sizeof(chunksum),1,file);//write
memset(chunk,0,CHUNK_SIZE);//write 0 to chanksum (clean)
if (fileSize<CHUNK_SIZE){//is theis dfinal chank
isFinished=0;
fclose(file);
}
}
if (CALL_CHKSUM==1){//return as hex
if (fileChecksum !=0){
printf("Checksum: %u\n",fileChecksum);
}
}
return 0;
}
int loadWorld(char * filename, EntityManager * eManager, Entity * player, u8 * map, u8 * mapData) {
FILE * file;
int i,j;
if ((file = fopen(filename, "rb"))) {
fread(&player->p.score, sizeof(int), 1, file);
fread(&player->p.hasWonSaved, sizeof(bool), 1, file);
fread(&player->p.health, sizeof(s16), 1, file);
fread(&player->x, sizeof(s16), 1, file);
fread(&player->y, sizeof(s16), 1, file);
fread(¤tLevel, sizeof(s8), 1, file);
fread(&eManager->nextInv, sizeof(s16), 1, file);
for(i = 0; i < eManager->nextInv; ++i) {
fread(&eManager->invs[i].lastSlot, sizeof(s16), 1, file); // read amount of items in inventory;
for(j = 0; j < eManager->invs[i].lastSlot; ++j) {
fread(&eManager->invs[i].items[j].id, sizeof(s16), 1, file); // write ID of item
fread(&eManager->invs[i].items[j].countLevel, sizeof(s16), 1, file); // write count/level of item
fread(&eManager->invs[i].items[j].onlyOne, sizeof(bool), 1, file);
eManager->invs[i].items[j].invPtr = (int*)&eManager->invs[i]; // setup Inventory pointer
eManager->invs[i].items[j].slotNum = j; // setup slot number
if(eManager->invs[i].items[j].id == ITEM_CHEST) { // for chest item specifically.
int invIndex;
fread(&invIndex, sizeof(int), 1, file);
eManager->invs[i].items[j].chestPtr = (Inventory*)&eManager->invs[invIndex]; // setup chest inventory pointer.
}
}
}
for(i = 0; i < 5; ++i) {
fread(&eManager->lastSlot[i], sizeof(s16), 1, file); // read amount of entities in level.
for(j = 0; j < eManager->lastSlot[i]; ++j) {
fread(&eManager->entities[i][j].type, sizeof(s16), 1, file); // read entity's type ID
fread(&eManager->entities[i][j].x, sizeof(s16), 1, file); // read entity's x coordinate
fread(&eManager->entities[i][j].y, sizeof(s16), 1, file); // read entity's y coordinate
eManager->entities[i][j].slotNum = j;
switch(eManager->entities[i][j].type) {
case ENTITY_SMASHPARTICLE:
eManager->entities[i][j].level = i;
eManager->entities[i][j].smashParticle.age = 300;
eManager->entities[i][j].canPass = true;
break;
case ENTITY_TEXTPARTICLE:
eManager->entities[i][j].level = i;
eManager->entities[i][j].canPass = true;
eManager->entities[i][j].textParticle.age = 59;
eManager->entities[i][j].textParticle.text = NULL;
eManager->entities[i][j].textParticle.xx = eManager->entities[i][j].x;
eManager->entities[i][j].textParticle.yy = eManager->entities[i][j].y;
eManager->entities[i][j].textParticle.zz = 2;
eManager->entities[i][j].textParticle.xa = 0;
eManager->entities[i][j].textParticle.ya = 0;
eManager->entities[i][j].textParticle.za = 0;
break;
case ENTITY_SPARK:
eManager->entities[i][j].level = i;
eManager->entities[i][j].spark.age = 300;
break;
case ENTITY_AIRWIZARD:
fread(&eManager->entities[i][j].wizard.health, sizeof(s16), 1, file);
eManager->entities[i][j].level = i;
eManager->entities[i][j].hurtTime = 0;
eManager->entities[i][j].xKnockback = 0;
eManager->entities[i][j].yKnockback = 0;
eManager->entities[i][j].wizard.dir = 0;
eManager->entities[i][j].wizard.attackDelay = 0;
eManager->entities[i][j].wizard.attackTime = 0;
eManager->entities[i][j].wizard.attackType = 0;
eManager->entities[i][j].wizard.xa = 0;
eManager->entities[i][j].wizard.ya = 0;
eManager->entities[i][j].xr = 4;
eManager->entities[i][j].yr = 3;
eManager->entities[i][j].canPass = true;
break;
case ENTITY_SLIME:
fread(&eManager->entities[i][j].slime.health, sizeof(s16), 1, file);
fread(&eManager->entities[i][j].slime.lvl, sizeof(s8), 1, file);
eManager->entities[i][j].level = i;
eManager->entities[i][j].hurtTime = 0;
eManager->entities[i][j].xKnockback = 0;
eManager->entities[i][j].yKnockback = 0;
eManager->entities[i][j].slime.xa = 0;
eManager->entities[i][j].slime.ya = 0;
eManager->entities[i][j].slime.dir = 0;
eManager->entities[i][j].xr = 4;
eManager->entities[i][j].yr = 3;
eManager->entities[i][j].canPass = false;
switch(eManager->entities[i][j].slime.lvl) {
case 2:
eManager->entities[i][j].slime.color = 0xCC8282FF;
break;
case 3:
eManager->entities[i][j].slime.color = 0xEFEFEFFF;
break;
case 4:
eManager->entities[i][j].slime.color = 0x6262AAFF;
break;
default:
eManager->entities[i][j].slime.color = 0x95DB95FF;
break;
}
break;
case ENTITY_ZOMBIE:
fread(&eManager->entities[i][j].zombie.health, sizeof(s16), 1, file);
fread(&eManager->entities[i][j].zombie.lvl, sizeof(s8), 1, file);
eManager->entities[i][j].level = i;
eManager->entities[i][j].hurtTime = 0;
eManager->entities[i][j].xKnockback = 0;
eManager->entities[i][j].yKnockback = 0;
eManager->entities[i][j].zombie.dir = 0;
eManager->entities[i][j].xr = 4;
eManager->entities[i][j].yr = 3;
eManager->entities[i][j].canPass = false;
switch(eManager->entities[i][j].zombie.lvl) {
case 2:
eManager->entities[i][j].zombie.color = 0xCC8282FF;
break;
case 3:
eManager->entities[i][j].zombie.color = 0xEFEFEFFF;
break;
case 4:
eManager->entities[i][j].zombie.color = 0x6262AAFF;
break;
default:
eManager->entities[i][j].zombie.color = 0x95DB95FF;
break;
}
break;
case ENTITY_ITEM:
//eManager->entities[i][j].entityItem.item = newItem(0,0);
fread(&eManager->entities[i][j].entityItem.item.id, sizeof(s16), 1, file);
fread(&eManager->entities[i][j].entityItem.item.countLevel, sizeof(s16), 1, file);
fread(&eManager->entities[i][j].entityItem.age, sizeof(s16), 1, file);
eManager->entities[i][j].level = i;
eManager->entities[i][j].entityItem.age = 0;
eManager->entities[i][j].xr = 3;
eManager->entities[i][j].yr = 3;
eManager->entities[i][j].canPass = false;
eManager->entities[i][j].entityItem.xx = eManager->entities[i][j].x;
eManager->entities[i][j].entityItem.yy = eManager->entities[i][j].y;
eManager->entities[i][j].entityItem.zz = 2;
eManager->entities[i][j].entityItem.xa = 0;
eManager->entities[i][j].entityItem.ya = 0;
eManager->entities[i][j].entityItem.za = 0;
break;
case ENTITY_FURNITURE:
fread(&eManager->entities[i][j].entityFurniture.itemID, sizeof(s16), 1, file);
int invIndex;
fread(&invIndex, sizeof(int), 1, file);
eManager->entities[i][j].entityFurniture.inv = &eManager->invs[invIndex];
eManager->entities[i][j].xr = 3;
eManager->entities[i][j].yr = 3;
eManager->entities[i][j].canPass = false;
if(eManager->entities[i][j].entityFurniture.itemID == ITEM_LANTERN) eManager->entities[i][j].entityFurniture.r = 8;
break;
}
}
}
fread(map, sizeof(u8), 128*128*5, file);
fread(mapData, sizeof(u8), 128*128*5, file);
fclose(file);
return 0;
}
return 1;
}
CXMLArchive::CXMLArchive(const CString& fileName, UINT nMode,
IStream* streamPtr /* = NULL*/,
CDocument* docPtr /*= NULL*/) :
CArchive(&m_dummyFile, nMode, 0, NULL),
m_fileName(fileName),
m_streamPtr(streamPtr)
{
m_pDocument = docPtr;
m_bForceFlat = FALSE;
ASSERT(!fileName.IsEmpty() || streamPtr != NULL);
//// Get reference of XML document
//try
//{
// m_xmlDocPtr = MSXML::IXMLDOMDocumentPtr(__uuidof(MSXML::DOMDocument));
//}
//catch (_com_error e)
//{
//}
//if (m_xmlDocPtr == NULL)
//{
// ::AfxMessageBox(_T("Can't get reference to XML parser, Ensure that msxml.dll is installed"));
// return;
//}
// Don't want async
//m_xmlDocPtr->put_async(VARIANT_FALSE);
if (IsLoading())
{
VARIANT_BOOL varResult = VARIANT_FALSE;
try
{
if (m_streamPtr == NULL)
{
//varResult = m_xmlDocPtr->load(_variant_t(fileName));
FILE *f = fopen(m_fileName, "rb");
// reading data - zlib will detect if zipped or not...
TCHAR tInString[4096];
int nReadChar = 1;
std::_tstring sLoaded;
// reading chunk of data and adding to sLoaded
while (nReadChar != 0 && nReadChar != -1)
{
// read zip file
nReadChar = fread(tInString, 1, 4096 * sizeof(TCHAR), f);
// testing if load succesful
if (nReadChar == -1)
{
// something went wrong, closing zip file and stopping
fclose(f);
m_bOpened = false;
return;
}
// tInString OK, adding
if (nReadChar != 0)
{
sLoaded.append(tInString, nReadChar);
TRACE(_T("nReadChar = %d, sLoaded size = %d\n"), nReadChar, sLoaded.size());
}
}
// closing zipfile
fclose(f);
m_xmlDocPtr = new CMarkup();
m_bOpened = m_xmlDocPtr->SetDoc(sLoaded.c_str());
}
else
{
//LARGE_INTEGER largeZero;
//largeZero.QuadPart = 0;
//m_streamPtr->Seek(largeZero, 0, NULL);
//varResult = m_xmlDocPtr->load(_variant_t(m_streamPtr));
}
//// reading data - zlib will detect if zipped or not...
//TCHAR tInString[4096];
//int nReadChar = 1;
//std::_tstring sLoaded;
//// reading chunk of data and adding to sLoaded
//while (nReadChar != 0 && nReadChar != -1)
//{
// // read zip file
// nReadChar = gzread(gzf, tInString, 4096 * sizeof(TCHAR));
// // testing if load succesful
// if (nReadChar == -1)
// {
// // something went wrong, closing zip file and stopping
// gzclose(gzf);
// return m_bOpened = false;
// }
// // tInString OK, adding
// if (nReadChar != 0)
// {
// sLoaded.append(tInString, nReadChar);
// TRACE(_T("nReadChar = %d, sLoaded size = %d\n"), nReadChar, sLoaded.size());
// }
//}
//// closing zipfile
//gzclose(gzf);
//m_bOpened = SetDoc(sLoaded.c_str());
}
catch (CException* e)
{
varResult = VARIANT_FALSE;
}
}
}
/**
* \brief Loads a file from a pak/zip file into memory.
* \param[in] hFile Pointer to a valid filehandle_t structure.
* \param[in] pakfiles Pointer to a valid packfile_t structure.
* \return true on success, otherwise false.
*/
PRIVATE _boolean LoadCompressedFile( filehandle_t *hFile, packfile_t *pakfiles )
{
int err;
W32 read;
W8 *uncompr;
W8 *buf;
z_stream d_stream; /* decompression stream */
buf = Z_Malloc( pakfiles->filelength + 2 );
// Zlib expects the 2 byte head that the inflate method adds.
buf[ 0 ] = 120;
buf[ 1 ] = 156;
read = fread( buf+2, 1, pakfiles->filelength, hFile->hFile );
if( read != pakfiles->filelength )
{
fclose( hFile->hFile );
Z_Free( buf );
return false;
}
fclose( hFile->hFile );
hFile->hFile = NULL;
uncompr = Z_Malloc( pakfiles->uncompressed_length );
d_stream.zalloc = (alloc_func)0;
d_stream.zfree = (free_func)0;
d_stream.opaque = (voidpf)0;
d_stream.next_in = buf;
d_stream.avail_in = (uInt)pakfiles->filelength+2;
d_stream.next_out = uncompr;
d_stream.avail_out = (uInt)pakfiles->uncompressed_length;
err = inflateInit( &d_stream );
if( err != Z_OK )
{
MM_FREE( uncompr );
Z_Free( buf );
FS_CloseFile( hFile );
return false;
}
err = inflate( &d_stream, Z_NO_FLUSH );
if( err != Z_OK )
{
Z_Free( uncompr );
Z_Free( buf );
FS_CloseFile( hFile );
return false;
}
err = inflateEnd( &d_stream );
if( err != Z_OK )
{
Z_Free( uncompr );
Z_Free( buf );
FS_CloseFile( hFile );
return false;
}
Z_Free( buf );
hFile->filedata = uncompr;
hFile->filesize = d_stream.total_out;
// align our file data pointers
hFile->ptrStart = hFile->ptrCurrent = (PW8)hFile->filedata;
hFile->ptrEnd = (PW8)hFile->filedata + hFile->filesize;
hFile->bLoaded = true;
return true;
}
//// ini_parse() ////
void ini_parse(const ini_cfg_t* cfg)
{
char line[INI_LINE_SIZE] = {0};
int section = INI_SECTION_INVALID_ID;
int line_status;
// open ini file
#ifdef INI_PARSER_TEST
if ((ini_fp = fopen(cfg->filename, "rb")) == NULL) {
#else
if (!RAOpen(&ini_file, cfg->filename)) {
#endif
ini_parser_debugf("Can't open file %s !", cfg->filename);
return;
}
#ifdef INI_PARSER_TEST
// save size
fseek(ini_fp, 0L, SEEK_END);
ini_size = ftell(ini_fp);
fseek(ini_fp, 0L, SEEK_SET);
#endif
#ifdef INI_PARSER_TEST
ini_parser_debugf("Opened file %s with size %d bytes.", cfg->filename, ini_size);
#else
ini_parser_debugf("Opened file %s with size %d bytes.", cfg->filename, ini_file.file.size);
#endif
// preload buffer
#ifdef INI_PARSER_TEST
fread(sector_buffer, sizeof(char), INI_BUF_SIZE, ini_fp);
#else
RARead(&ini_file, sector_buffer, INI_BUF_SIZE);
#endif
// parse ini
while (1) {
// get line
line_status = ini_getline(line);
// if valid line
if (line_status != 1) {
if (line[0] == INI_SECTION_START) {
// if first char in line is INI_SECTION_START, get section
section = ini_get_section(cfg, line);
} else {
// otherwise this is a variable, get it
ini_get_var(cfg, section, line);
}
}
// if end of file, stop
if (line_status == INI_EOT) break;
}
#ifdef INI_PARSER_TEST
// close file
fclose(ini_fp);
#endif
}
//// ini_save() ////
void ini_save(const ini_cfg_t* cfg)
{
int section, var, ini_pt;
char line[INI_LINE_SIZE] = {0};
// open ini file
#ifdef INI_PARSER_TEST
if ((ini_fp = fopen(cfg->filename, "wb")) == NULL) {
#else
{ //#error
#endif
ini_parser_debugf("Can't open file %s !", cfg->filename);
return;
}
// loop over sections
for (section=0; section<cfg->nsections; section++) {
ini_parser_debugf("writing section %s ...", cfg->sections[section].name);
siprintf(line, "[%s]\n", cfg->sections[section].name);
ini_pt = ini_putline(line);
// loop over vars
for (var=0; var<cfg->nvars; var++) {
if (cfg->vars[var].section_id == cfg->sections[section].id) {
ini_parser_debugf("writing var %s", cfg->vars[var].name);
switch (cfg->vars[var].type) {
case UINT8:
case UINT16:
case UINT32:
siprintf(line, "%s=%u\n", cfg->vars[var].name, *(uint32_t*)(cfg->vars[var].var));
break;
case INT8:
case INT16:
case INT32:
siprintf(line, "%s=%d\n", cfg->vars[var].name, *(int32_t*)(cfg->vars[var].var));
break;
#ifdef INI_ENABLE_FLOAT
case FLOAT:
siprintf(line, "%s=%f\n", cfg->vars[var].name, *(float*)(cfg->vars[var].var));
break;
#endif
case STRING:
siprintf(line, "%s=\"%s\"\n", cfg->vars[var].name, (char*)(cfg->vars[var].var));
break;
}
ini_pt = ini_putline(line);
}
}
}
// in case the buffer is not written yet, write it now
if (ini_pt) {
#ifdef INI_PARSER_TEST
fwrite(sector_buffer, sizeof(char), ini_pt, ini_fp);
#else
//#error
#endif
}
}
int main() {
//用于丢包率的随机数种子
srand(time(NULL));
//连接到SIP进程并获得TCP套接字描述符
int sip_conn = connectToSIP();
if(sip_conn<0) {
printf("fail to connect to the local SIP process\n");
exit(1);
}
//初始化stcp客户端
stcp_client_init(sip_conn);
sleep(STARTDELAY);
char hostname[50];
printf("Enter server name to connect:");
scanf("%s",hostname);
int server_nodeID = topology_getNodeIDfromname(hostname);
if(server_nodeID == -1) {
printf("host name error!\n");
exit(1);
} else {
printf("connecting to node %d\n",server_nodeID);
}
//在端口87上创建STCP客户端套接字, 并连接到STCP服务器端口88.
int sockfd = stcp_client_sock(CLIENTPORT1);
if(sockfd<0) {
printf("fail to create stcp client sock");
exit(1);
}
if(stcp_client_connect(sockfd,server_nodeID,SERVERPORT1)<0) {
printf("fail to connect to stcp server\n");
exit(1);
}
printf("client connected to server, client port:%d, server port %d\n",CLIENTPORT1,SERVERPORT1);
//获取sendthis.txt文件长度, 创建缓冲区并读取文件中的数据
FILE *f;
f = fopen("sendthis.txt","r");
assert(f!=NULL);
fseek(f,0,SEEK_END);
int fileLen = ftell(f);
fseek(f,0,SEEK_SET);
char *buffer = (char*)malloc(fileLen);
fread(buffer,fileLen,1,f);
fclose(f);
//首先发送文件长度, 然后发送整个文件.
stcp_client_send(sockfd,&fileLen,sizeof(int));
stcp_client_send(sockfd, buffer, fileLen);
free(buffer);
//等待一段时间, 然后关闭连接.
sleep(WAITTIME);
if(stcp_client_disconnect(sockfd)<0) {
printf("fail to disconnect from stcp server\n");
exit(1);
}
if(stcp_client_close(sockfd)<0) {
printf("fail to close stcp client\n");
exit(1);
}
//断开与SIP进程之间的连接
disconnectToSIP(sip_conn);
}
/*
* function for sending files.
*/
void send_file(FILE *f, char *filename, char *subdir, time_t modifiedheader, uint32_t etagheader, char *extraheader)
{
int8_t filen = 0;
int32_t size = 0;
char *mimetype = "", *result = " ", *allocated = NULL;
time_t moddate;
char path[255];
char *CSS = NULL;
char *JSCRIPT = NULL;
char *JQUERY = NULL;
char *TOUCH_CSS = NULL;
char *TOUCH_JSCRIPT = NULL;
if(!strcmp(filename, "CSS"))
{
filename = cfg.http_css ? cfg.http_css : "";
if(subdir && strlen(subdir) > 0)
{
filename = tpl_getFilePathInSubdir(cfg.http_tpl ? cfg.http_tpl : "", subdir, "site", ".css", path, 255);
}
mimetype = "text/css";
filen = 1;
}
else if(!strcmp(filename, "JS"))
{
filename = cfg.http_jscript ? cfg.http_jscript : "";
if(subdir && strlen(subdir) > 0)
{
filename = tpl_getFilePathInSubdir(cfg.http_tpl ? cfg.http_tpl : "", subdir, "oscam", ".js", path, 255);
}
mimetype = "text/javascript";
filen = 2;
}
else if(!strcmp(filename, "JQ"))
{
if(subdir && strlen(subdir) > 0)
{
filename = tpl_getFilePathInSubdir(cfg.http_tpl ? cfg.http_tpl : "", subdir, "jquery", ".js", path, 255);
}
mimetype = "text/javascript";
filen = 3;
}
if(strlen(filename) > 0 && file_exists(filename))
{
struct stat st;
stat(filename, &st);
moddate = st.st_mtime;
// We need at least size 1 or keepalive gets problems on some browsers...
if(st.st_size > 0)
{
FILE *fp;
int32_t readen;
if((fp = fopen(filename, "r")) == NULL) { return; }
if(!cs_malloc(&allocated, st.st_size + 1))
{
send_error500(f);
fclose(fp);
return;
}
if((readen = fread(allocated, 1, st.st_size, fp)) == st.st_size)
{
allocated[readen] = '\0';
}
fclose(fp);
}
if(filen == 1 && cfg.http_prepend_embedded_css) // Prepend Embedded CSS
{
char separator [255];
snprintf(separator, 255, "\n/* Beginn embedded CSS File: %s */\n", cfg.http_css);
char *oldallocated = allocated;
CSS = tpl_getUnparsedTpl("CSS", 1, "");
int32_t newsize = strlen(CSS) + strlen(separator) + 2;
if(oldallocated) { newsize += strlen(oldallocated) + 1; }
if(!cs_malloc(&allocated, newsize))
{
if(oldallocated) { NULLFREE(oldallocated); }
NULLFREE(CSS);
send_error500(f);
return;
}
if (CSS){
snprintf(allocated, newsize, "%s\n%s\n%s", CSS, separator, (oldallocated != NULL ? oldallocated : ""));
}
if(oldallocated) { NULLFREE(oldallocated); }
}
if(allocated) { result = allocated; }
}
else
{
CSS = tpl_getUnparsedTpl("CSS", 1, "");
JSCRIPT = tpl_getUnparsedTpl("JSCRIPT", 1, "");
JQUERY = tpl_getUnparsedTpl("JQUERY", 1, "");
#ifdef TOUCH
TOUCH_CSS = tpl_getUnparsedTpl("TOUCH_CSS", 1, "");
TOUCH_JSCRIPT = tpl_getUnparsedTpl("TOUCH_JSCRIPT", 1, "");
if(!subdir || strcmp(subdir, TOUCH_SUBDIR)) {
if( filen == 1 && strlen(CSS)){ result = CSS; }
else if ( filen == 2 && strlen(JSCRIPT)){ result = JSCRIPT; }
else if ( filen == 3 && strlen(JQUERY)){ result = JQUERY; }
} else {
if( filen == 1 && strlen(TOUCH_CSS)){ result = TOUCH_CSS; }
else if ( filen == 2 && strlen(TOUCH_JSCRIPT)){ result = TOUCH_JSCRIPT; }
else if ( filen == 3 && strlen(JQUERY)){ result = JQUERY; }
}
#else
if(filen == 1 && strlen(CSS) > 0){ result = CSS;}
else if(filen == 2 && strlen(JSCRIPT) > 0){result = JSCRIPT;}
else if(filen == 3 && strlen(JQUERY) > 0){result = JQUERY;}
#endif
moddate = first_client->login;
}
size = strlen(result);
if((etagheader == 0 && moddate < modifiedheader) || (etagheader > 0 && (uint32_t)crc32(0L, (uchar *)result, size) == etagheader))
{
send_header304(f, extraheader);
}
else
{
send_headers(f, 200, "OK", NULL, mimetype, 1, size, result, 0);
webif_write(result, f);
}
if(allocated) { NULLFREE(allocated); }
NULLFREE(CSS);
NULLFREE(JSCRIPT);
NULLFREE(JQUERY);
NULLFREE(TOUCH_CSS);
NULLFREE(TOUCH_JSCRIPT);
}
void CArenaMapNode::initialize(const std::string &filePath)
{
FILE *fp;
char tag[4];
void *memoryPtr;
uint16_t version;
uint16_t partCount;
int totalIndexCount;
int indexLayoutSize;
int totalVertexCount;
int vertexLayoutSize;
char meshNameTemp[MAP_PART_NAME_ARRAY_LENGTH + 1];
uint32_t definingVerticesCount;
uint32_t definingTrianglesCount;
std::string materialFilePath = filePath;
utils::changeExt(materialFilePath, "mat");
if(!(fp = fopen(filePath.c_str(), "rb")))
{
CLogger::failedLoadWarning(filePath, "File not found or broken");
return;
}
m_filePath = filePath;
fread(tag, sizeof(char), 4, fp);
if(strncmp(tag, "MAA", 3) != 0)
{
fclose(fp);
CLogger::failedLoadWarning(filePath, "File tag is not MAA");
return;
}
fread(&version, sizeof(uint16_t), 1, fp);
if(version != 1)
{
fclose(fp);
CLogger::failedLoadWarning(filePath, "Unsupported MAA version");
return;
}
vertexLayoutSize = 64;
fread(&partCount, sizeof(uint16_t), 1, fp);
fread(&totalVertexCount, sizeof(uint32_t), 1, fp);
fread(&totalIndexCount, sizeof(uint32_t), 1, fp);
indexLayoutSize = sizeof(uint32_t);
fread(&definingVerticesCount, sizeof(uint32_t), 1, fp);
fread(&definingTrianglesCount, sizeof(uint32_t), 1, fp);
for(uint16_t i = 0; i < partCount; i++)
{
int start;
CMapPart p = CMapPart();
// Make sure the temp will be null-terminated.
memset(meshNameTemp, '\0', MAP_PART_NAME_ARRAY_LENGTH + 1);
fread(meshNameTemp, sizeof(char), MAP_PART_NAME_ARRAY_LENGTH, fp);
memcpy(p.m_name, meshNameTemp, 32);
fread(&start, sizeof(uint32_t), 1, fp);
fread(&p.m_count, sizeof(uint32_t), 1, fp);
p.m_startPtr = (void *)((intptr_t)start);
p.setMaterial(m_resourceManager->getMaterial(materialFilePath, meshNameTemp));
m_parts.push_back(p);
InfoLog << "Part: " << meshNameTemp << NL;
}
glGenVertexArrays(1, &m_vaoId);
glBindVertexArray(m_vaoId);
glGenBuffers(1, &m_vboId);
glBindBuffer(GL_ARRAY_BUFFER, m_vboId);
glBufferData(GL_ARRAY_BUFFER, totalVertexCount * vertexLayoutSize, 0, GL_STATIC_DRAW);
memoryPtr = glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY);
fread(memoryPtr, vertexLayoutSize, totalVertexCount, fp);
glUnmapBuffer(GL_ARRAY_BUFFER);
glVertexAttribPointer(OPENGL_VXA_POSITION_ID, 3, GL_FLOAT, GL_FALSE, 64, (void *)(0));
glEnableVertexAttribArray(OPENGL_VXA_POSITION_ID);
glVertexAttribPointer(OPENGL_VXA_NORMAL_ID, 3, GL_FLOAT, GL_FALSE, 64, (void *)(12));
glEnableVertexAttribArray(OPENGL_VXA_NORMAL_ID);
glVertexAttribPointer(OPENGL_VXA_TEXCOORD0_ID, 2, GL_FLOAT, GL_FALSE, 64, (void *)(24));
glEnableVertexAttribArray(OPENGL_VXA_TEXCOORD0_ID);
glVertexAttribPointer(OPENGL_VXA_TANGENT_ID, 4, GL_FLOAT, GL_FALSE, 64, (void *)(32));
glEnableVertexAttribArray(OPENGL_VXA_TANGENT_ID);
glVertexAttribPointer(OPENGL_VXA_WEIGHT0_ID, 1, GL_FLOAT, GL_FALSE, 64, (void *)(48));
glEnableVertexAttribArray(OPENGL_VXA_WEIGHT0_ID);
glVertexAttribPointer(OPENGL_VXA_WEIGHT1_ID, 1, GL_FLOAT, GL_FALSE, 64, (void *)(52));
glEnableVertexAttribArray(OPENGL_VXA_WEIGHT1_ID);
glVertexAttribPointer(OPENGL_VXA_WEIGHT2_ID, 1, GL_FLOAT, GL_FALSE, 64, (void *)(56));
glEnableVertexAttribArray(OPENGL_VXA_WEIGHT2_ID);
glVertexAttribPointer(OPENGL_VXA_WEIGHT3_ID, 1, GL_FLOAT, GL_FALSE, 64, (void *)(60));
glEnableVertexAttribArray(OPENGL_VXA_WEIGHT3_ID);
glGenBuffers(1, &m_iboId);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_iboId);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, totalIndexCount * indexLayoutSize, 0, GL_STATIC_DRAW);
memoryPtr = glMapBuffer(GL_ELEMENT_ARRAY_BUFFER, GL_WRITE_ONLY);
fread(memoryPtr, indexLayoutSize, totalIndexCount, fp);
glUnmapBuffer(GL_ELEMENT_ARRAY_BUFFER);
glBindVertexArray(0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
m_vertices = 0;
m_indices = 0;
m_materials = 0;
uint32_t int32Temp;
unsigned char ucTemp;
float flTemp;
if(definingTrianglesCount > 0)
{
m_vertices = new btScalar[definingVerticesCount * 3];
m_indices = new int[definingTrianglesCount * 3];
m_materials = new int[definingTrianglesCount];
for(unsigned int i = 0; i < definingVerticesCount * 3; i++)
{
fread(&flTemp, sizeof(float), 1, fp);
m_vertices[i] = (btScalar)flTemp;
}
for(unsigned int i = 0; i < definingTrianglesCount * 3; i++)
{
fread(&int32Temp, sizeof(uint32_t), 1, fp);
m_indices[i] = (int)int32Temp;
}
for(unsigned int i = 0; i < definingTrianglesCount; i++)
{
fread(&ucTemp, sizeof(unsigned char), 1, fp);
m_materials[i] = (int)ucTemp;
}
setPosition(glm::vec3(0.0f, 0.0f, 0.0f));
update();
m_gMaterials = 0;
m_tivm = 0;
m_trimeshShape = 0;
m_rigidBody = 0;
int totalMaterials = 1;
m_gMaterials = new CustomMaterial[totalMaterials];
m_gMaterials[0].m_friction = 1.0f;
m_gMaterials[0].m_restitution = 0.1f;
m_gMaterials[0].m_foo1 = 1;
m_gMaterials[0].m_foo2 = 1;
m_tivm = new btTriangleIndexVertexMaterialArray(definingTrianglesCount,
m_indices,
3 * sizeof(int),
definingVerticesCount,
m_vertices,
3 * sizeof(btScalar),
totalMaterials,
(unsigned char *)m_gMaterials,
sizeof(CustomMaterial),
m_materials,
sizeof(int));
bool useQuantizedAabbCompression = true;
// Create the multimaterial mesh shape
m_trimeshShape = new btMultimaterialTriangleMeshShape(
(btTriangleIndexVertexMaterialArray*)m_tivm,
useQuantizedAabbCompression);
btTransform groundTransform;
groundTransform.setIdentity();
groundTransform.setOrigin(btVector3(m_position.x, m_position.y, m_position.z));
m_rigidBody = new btCollisionObject();
m_rigidBody->setCollisionShape(m_trimeshShape);
m_rigidBody->setWorldTransform(groundTransform);
m_rigidBody->setCollisionFlags(m_rigidBody->getCollisionFlags() |
btCollisionObject::CF_CUSTOM_MATERIAL_CALLBACK | btCollisionObject::CF_STATIC_OBJECT);
}
fclose(fp);
}
void buildOpenCLKernels_update_halo_kernel2_zvel_plus_4_left(int xdim0, int ydim0, int xdim1, int ydim1) {
//int ocl_fma = OCL_FMA;
if(!isbuilt_update_halo_kernel2_zvel_plus_4_left) {
buildOpenCLKernels();
//clSafeCall( clUnloadCompiler() );
cl_int ret;
char* source_filename[1] = {"./OpenCL/update_halo_kernel2_zvel_plus_4_left.cl"};
// Load the kernel source code into the array source_str
FILE *fid;
char *source_str[1];
size_t source_size[1];
for(int i=0; i<1; i++) {
fid = fopen(source_filename[i], "r");
if (!fid) {
fprintf(stderr, "Can't open the kernel source file!\n");
exit(1);
}
source_str[i] = (char*)malloc(4*0x1000000);
source_size[i] = fread(source_str[i], 1, 4*0x1000000, fid);
if(source_size[i] != 4*0x1000000) {
if (ferror(fid)) {
printf ("Error while reading kernel source file %s\n", source_filename[i]);
exit(-1);
}
if (feof(fid))
printf ("Kernel source file %s succesfuly read.\n", source_filename[i]);
//printf("%s\n",source_str[i]);
}
fclose(fid);
}
printf("Compiling update_halo_kernel2_zvel_plus_4_left %d source -- start \n",OCL_FMA);
// Create a program from the source
OPS_opencl_core.program = clCreateProgramWithSource(OPS_opencl_core.context, 1, (const char **) &source_str, (const size_t *) &source_size, &ret);
clSafeCall( ret );
// Build the program
char buildOpts[255*3];
char* pPath = NULL;
pPath = getenv ("OPS_INSTALL_PATH");
if (pPath!=NULL)
if(OCL_FMA)
sprintf(buildOpts,"-cl-mad-enable -DOCL_FMA -I%s/include -DOPS_WARPSIZE=%d -Dxdim0_update_halo_kernel2_zvel_plus_4_left=%d -Dydim0_update_halo_kernel2_zvel_plus_4_left=%d -Dxdim1_update_halo_kernel2_zvel_plus_4_left=%d -Dydim1_update_halo_kernel2_zvel_plus_4_left=%d ", pPath, 32,xdim0,ydim0,xdim1,ydim1);
else
sprintf(buildOpts,"-cl-mad-enable -I%s/include -DOPS_WARPSIZE=%d -Dxdim0_update_halo_kernel2_zvel_plus_4_left=%d -Dydim0_update_halo_kernel2_zvel_plus_4_left=%d -Dxdim1_update_halo_kernel2_zvel_plus_4_left=%d -Dydim1_update_halo_kernel2_zvel_plus_4_left=%d ", pPath, 32,xdim0,ydim0,xdim1,ydim1);
else {
sprintf("Incorrect OPS_INSTALL_PATH %s\n",pPath);
exit(EXIT_FAILURE);
}
ret = clBuildProgram(OPS_opencl_core.program, 1, &OPS_opencl_core.device_id, buildOpts, NULL, NULL);
if(ret != CL_SUCCESS) {
char* build_log;
size_t log_size;
clSafeCall( clGetProgramBuildInfo(OPS_opencl_core.program, OPS_opencl_core.device_id, CL_PROGRAM_BUILD_LOG, 0, NULL, &log_size) );
build_log = (char*) malloc(log_size+1);
clSafeCall( clGetProgramBuildInfo(OPS_opencl_core.program, OPS_opencl_core.device_id, CL_PROGRAM_BUILD_LOG, log_size, build_log, NULL) );
build_log[log_size] = '\0';
fprintf(stderr, "=============== OpenCL Program Build Info ================\n\n%s", build_log);
fprintf(stderr, "\n========================================================= \n");
free(build_log);
exit(EXIT_FAILURE);
}
printf("compiling update_halo_kernel2_zvel_plus_4_left -- done\n");
// Create the OpenCL kernel
OPS_opencl_core.kernel[81] = clCreateKernel(OPS_opencl_core.program, "ops_update_halo_kernel2_zvel_plus_4_left", &ret);
clSafeCall( ret );
isbuilt_update_halo_kernel2_zvel_plus_4_left = true;
}
}
int
main(int argc, char **argv)
{
size_t i;
size_t j;
size_t nh, nw;
size_t dh, dw;
size_t todo;
int failure;
if (argc < 4) {
bu_exit (1, "%s", usage);
}
nbytes = atoi(argv[1]);
iwidth = atoi(argv[2]);
iheight = atoi(argv[3]);
if (argc >= 6) {
owidth = atoi(argv[4]);
oheight = atoi(argv[5]);
}
if (nbytes <= 0 || nbytes > INT_MAX) {
failure = 1;
bu_log("decimate: bad nbytes/pixel: %ld\n", (long int)nbytes);
}
if (iwidth <= 0 || iwidth > INT_MAX || iheight <= 0 || iheight > INT_MAX) {
failure = 1;
bu_log("decimate: bad size of input range: %ldx%ld\n", (long int)iwidth, (long int)iheight);
}
if (owidth <= 0 || owidth > INT_MAX || oheight <= 0 || oheight > INT_MAX) {
failure = 1;
bu_log("decimate: bad size of output range: %ldx%ld\n", (long int)owidth, (long int)oheight);
}
if (failure) {
bu_exit(EXIT_FAILURE, usage);
}
/* Determine how many samples/lines to discard after each one saved,
* and how much padding to add to the end of each line.
*/
nh = (iheight + oheight-1) / oheight;
nw = (iwidth + owidth-1) / owidth;
dh = nh - 1;
dw = nw - 1;
discard = dh;
if (dw > discard) discard = dw;
wpad = owidth - (iwidth / (discard+1));
iline = (unsigned char *)bu_calloc((iwidth+1), nbytes, "iline");
oline = (unsigned char *)bu_calloc((owidth+1), nbytes, "oline");
todo = iwidth / (discard+1) * (discard+1);
if (owidth < todo) todo = owidth;
if (todo > iwidth/(discard+1)) todo = iwidth/(discard+1);
while (!feof(stdin)) {
size_t ret;
unsigned char *ip, *op;
/* Scrunch down first scanline of input data */
ret = fread(iline, nbytes, iwidth, stdin);
if (ret != iwidth)
break;
ip = iline;
op = oline;
for (i=0; i < todo; i++) {
for (j=0; j < nbytes; j++) {
*op++ = *ip++;
}
ip += discard * nbytes;
}
if (fwrite(oline, nbytes, owidth, stdout) != owidth) {
perror("fwrite");
goto out;
}
/* Discard extra scanlines of input data */
for (i=0; i < discard; i++) {
if (fread(iline, nbytes, iwidth, stdin) != iwidth) {
goto out;
}
}
}
out:
bu_free(iline, "iline");
bu_free(oline, "oline");
return 0;
}
int send_file(HTHREAD_PTR descr, char *filename)
{
WSADATA wsa_data;
SOCKET data_socket = INVALID_SOCKET;
struct sockaddr_in send_data_addr;
HPACKET packet;
HPARTITION partition;
FILE *fp;
int return_code;
unsigned long at_location,
read_amount,
tries;
unsigned char packet_count;
char control_message[MAX_INPUT_LENGTH];
if(fopen_s(&fp, filename, "rb") > 0)
{
memset(control_message, 0, sizeof(MAX_INPUT_LENGTH));
control_message[0] = CONTROL_MESSAGE_NO_SUCH_FILE;
return_code = send(descr->socket, control_message, (int)strlen(control_message), 0);
return 1;
}
for(tries = 0; tries < CONTROL_MESSAGE_RECV_RETRIES; tries++)
{
memset(control_message, 0, sizeof(MAX_INPUT_LENGTH));
return_code = recv(descr->socket, control_message, MAX_INPUT_LENGTH-1, 0);
if(return_code < 1)
{
printf("failed to recv command: %d\n", WSAGetLastError());
closesocket(data_socket);
return 0;
}
if(control_message[0] == CONTROL_MESSAGE_OK_START_SENDING)
break;
}
if(tries >= CONTROL_MESSAGE_RECV_RETRIES)
{
printf("No CONTROL_MESSAGE_OK_START_SENDING from %s\n", inet_ntoa(descr->address.sin_addr));
closesocket(data_socket);
return 0;
}
WSAStartup(MAKEWORD(2,2), &wsa_data);
data_socket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
send_data_addr.sin_family = AF_INET;
send_data_addr.sin_port = htons(CONNECT_PORT_N);//descr->address.sin_port;
send_data_addr.sin_addr = descr->address.sin_addr;//inet_addr("123.456.789.1");
packet.partition_id = 0;
packet.reserved = 0;
while(!feof(fp))
{
memset(partition.packet_stats, 0, MAX_PARTITION_DIVISIONS+1);
partition.actual_size = (unsigned long)fread(partition.data, 1, PARTITION_LENGTH_TOTAL, fp);
packet_count = (unsigned char)ceil(partition.actual_size / PACKET_LENGTH_DATA);
memset(control_message, 0, sizeof(MAX_INPUT_LENGTH));
sprintf_s(control_message, MAX_INPUT_LENGTH, " %u", partition.actual_size);
control_message[0] = CONTROL_MESSAGE_SENDING_DATA;
return_code = send(descr->socket, control_message, (int)strlen(control_message)+1, 0);
if(return_code == SOCKET_ERROR)
{
printf("failed to send command: %d\n", WSAGetLastError());
closesocket(data_socket);
return 0;
}
while(1)
{
for(packet.packet_id = 0; packet.packet_id < packet_count; packet.packet_id++)
{
if(partition.packet_stats[packet.packet_id] != 1)
break;
}
if(packet.packet_id == packet_count)
break;
for(packet.packet_id = 0; packet.packet_id < packet_count; packet.packet_id++)
{
if(partition.packet_stats[packet.packet_id] != 1)
{
memset(packet.data, 0, sizeof(PARTITION_LENGTH_TOTAL));
at_location = packet.packet_id * PACKET_LENGTH_DATA;
read_amount = at_location + PACKET_LENGTH_DATA < partition.actual_size ? PACKET_LENGTH_DATA : partition.actual_size - at_location;
memcpy(packet.data, &partition.data[at_location], read_amount);
packet.crc = compute_crc((const unsigned char *)packet.data, PACKET_LENGTH_DATA);
return_code = sendto(data_socket, (char *)&packet, sizeof(packet), 0, (SOCKADDR *)&send_data_addr, sizeof(send_data_addr));
if(return_code == SOCKET_ERROR)
{
printf("failed to send command: %d\n", WSAGetLastError());
closesocket(data_socket);
return 0;
}
Sleep(5);
}
}
memset(control_message, 0, sizeof(MAX_INPUT_LENGTH));
control_message[0] = CONTROL_MESSAGE_PARTITION_SENT;
return_code = send(descr->socket, control_message, (int)strlen(control_message)+1, 0);
if(return_code == SOCKET_ERROR)
{
printf("failed to send command: %d\n", WSAGetLastError());
closesocket(data_socket);
return 0;
}
for(tries = 0; tries < CONTROL_MESSAGE_RECV_RETRIES; tries++)
{
memset(control_message, 0, sizeof(MAX_INPUT_LENGTH));
return_code = recv(descr->socket, control_message, MAX_INPUT_LENGTH-1, 0);
if(return_code < 1)
{
printf("failed to recv command: %d\n", WSAGetLastError());
closesocket(data_socket);
return 0;
}
if(control_message[0] == CONTROL_MESSAGE_PARTITION_STATUS)
{
memset(partition.packet_stats, 0, MAX_PARTITION_DIVISIONS+1);
memcpy(partition.packet_stats, &control_message[2], MAX_PARTITION_DIVISIONS);
break;
}
}
if(tries >= CONTROL_MESSAGE_RECV_RETRIES)
{
printf("No CONTROL_MESSAGE_PARTITION_STATUS from %s\n", inet_ntoa(descr->address.sin_addr));
closesocket(data_socket);
return 0;
}
}
packet.partition_id++;
}
fclose(fp);
memset(control_message, 0, sizeof(MAX_INPUT_LENGTH));
control_message[0] = CONTROL_MESSAGE_ALL_DATA_SENT;
return_code = send(descr->socket, control_message, (int)strlen(control_message)+1, 0);
if(return_code == SOCKET_ERROR)
{
printf("failed to send command: %d\n", WSAGetLastError());
closesocket(data_socket);
return 1;
}
closesocket(data_socket);
return 1;
}
int
main(int argc, char *argv[])
{
FILE* infile;
FILE* outfile;
unsigned char c;
unsigned char freq_s[128];
double freq;
unsigned char data[4];
int freq_i;
int ret;
int notfirst=0;
int ctr=0;
int i;
if (argc<2)
{
fprintf(stderr, "%s: Error: Invalid args\n", argv[0]);
fprintf(stderr, "Syntax is: %s <infile> [outfile]\n", argv[0]);
exit(1);
}
infile=fopen(argv[1], "rb");
if (infile==NULL)
{
fprintf(stderr, "%s: Error: Unable to open input file '%s'\n", argv[0], argv[1]);
exit(1);
}
if (argc>2)
{
outfile=fopen(argv[2], "w");
}
else
{
outfile=fopen("out.txt", "w");
}
if (outfile==NULL)
{
fprintf(stderr, "%s: Error: Unable to create output file\n", argv[0]);
exit(1);
}
// read until we see a comma or EOF
// Once we see comma or EOF, we can convert to FTW format
i=0;
while(1)
{
ret=fread(&c, 1, 1, infile);
if ((ret!=1) || (c==',') || (c=='\n') || c=='\r' || (c==' '))
{
// We have seen a separator or whitespace or EOF
if (i==0) // no characters read?
{
if (ret!=1) // EOF
{
// we're done
break;
}
continue;
}
else
{
// some characters were read. Convert to FTW
freq_s[i]='\0'; // terminate the string
i=0;
sscanf(freq_s, "%lf", &freq);
freq_i=(int)freq;
//freq2ftw(freq, data); // data array now contains the 4-byte FTW
if (notfirst)
{
fprintf(outfile, ", ");
}
else
{
notfirst=1;
}
if (ctr%10==0) // do a newline every so often
{
fprintf(outfile, "\n");
}
ctr++;
fprintf(outfile, "%d", freq_i);
}
}
else
{
freq_s[i]=c;
i++;
}
} // end while(1)
fclose(infile);
fclose(outfile);
return(0);
}
// TODO: clean up error handling, too much dupe code right now
bool PNG::_read_file(string const & file_name)
{
// unfortunately, we need to break down to the C-code level here, since
// libpng is written in C itself
// we need to open the file in binary mode
FILE * fp = fopen(file_name.c_str(), "rb");
if (!fp)
{
epng_err("Failed to open " + file_name);
return false;
}
// read in the header (max size of 8), use it to validate this as a PNG file
png_byte header[8];
fread(header, 1, 8, fp);
if (png_sig_cmp(header, 0, 8))
{
epng_err("File is not a valid PNG file");
fclose(fp);
_init();
return false;
}
// set up libpng structs for reading info
png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL); if (!png_ptr)
{
epng_err("Failed to create read struct");
fclose(fp);
_init();
return false;
}
png_infop info_ptr = png_create_info_struct(png_ptr);
if (!info_ptr)
{
epng_err("Failed to create info struct");
png_destroy_read_struct(&png_ptr, NULL, NULL);
fclose(fp);
_init();
return false;
}
// set error handling to not abort the entire program
if (setjmp(png_jmpbuf(png_ptr)))
{
epng_err("Error initializing libpng io");
png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
fclose(fp);
_init();
return false;
}
// initialize png reading
png_init_io(png_ptr, fp);
// let it know we've already read the first 8 bytes
png_set_sig_bytes(png_ptr, 8);
// read in the basic image info
png_read_info(png_ptr, info_ptr);
// convert to 8 bits
png_byte bit_depth = png_get_bit_depth(png_ptr, info_ptr);
if (bit_depth == 16)
png_set_strip_16(png_ptr);
// verify this is in RGBA format, and if not, convert it to RGBA
png_byte color_type = png_get_color_type(png_ptr, info_ptr);
if (color_type != PNG_COLOR_TYPE_RGBA && color_type != PNG_COLOR_TYPE_RGB)
{
if (color_type == PNG_COLOR_TYPE_GRAY || color_type == PNG_COLOR_TYPE_GRAY_ALPHA) {
if (bit_depth < 8)
png_set_expand(png_ptr);
png_set_gray_to_rgb(png_ptr);
}
if (color_type == PNG_COLOR_TYPE_PALETTE)
png_set_palette_to_rgb(png_ptr);
}
// convert tRNS to alpha channel
if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS))
png_set_tRNS_to_alpha(png_ptr);
_width = png_get_image_width(png_ptr, info_ptr);
_height = png_get_image_height(png_ptr, info_ptr);
png_read_update_info(png_ptr, info_ptr);
// begin reading in the image
if (setjmp(png_jmpbuf(png_ptr)))
{
epng_err("Error reading image with libpng");
png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
fclose(fp);
_init();
return false;
}
int bpr = png_get_rowbytes(png_ptr, info_ptr); // number of bytes in a row
int numchannels = png_get_channels(png_ptr, info_ptr);
// initialie our image storage
_pixels = new RGBAPixel[_height * _width];
png_byte * row = new png_byte[bpr];
for (int y = 0; y < _height; y++)
{
png_read_row(png_ptr, row, NULL);
png_byte * pix = row;
for (int x = 0; x < _width; x++)
{
RGBAPixel & pixel = _pixel(x,y);
if (numchannels == 1 || numchannels == 2)
{
// monochrome
unsigned char color = (unsigned char) *pix++;
pixel.red = color;
pixel.green = color;
pixel.blue = color;
if (numchannels == 2)
pixel.alpha = (unsigned char) *pix++;
else
pixel.alpha = 255;
}
else if (numchannels == 3 || numchannels == 4)
{
pixel.red = (unsigned char) *pix++;
pixel.green = (unsigned char) *pix++;
pixel.blue = (unsigned char) *pix++;
if (numchannels == 4)
pixel.alpha = (unsigned char) *pix++;
else
pixel.alpha = 255;
}
}
}
// cleanup
delete [] row;
png_read_end(png_ptr, NULL);
png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
fclose(fp);
return true;
}
bool usb_restore(FILE *image) {
return fread(&usb, sizeof(usb), 1, image) == 1;
}
EFI_STATUS
GetFileImage (
IN CHAR8 *InputFileName,
OUT CHAR8 **InputFileImage,
OUT UINT32 *BytesRead
)
/*++
Routine Description:
This function opens a file and reads it into a memory buffer. The function
will allocate the memory buffer and returns the size of the buffer.
Arguments:
InputFileName The name of the file to read.
InputFileImage A pointer to the memory buffer.
BytesRead The size of the memory buffer.
Returns:
EFI_SUCCESS The function completed successfully.
EFI_INVALID_PARAMETER One of the input parameters was invalid.
EFI_ABORTED An error occurred.
EFI_OUT_OF_RESOURCES No resource to complete operations.
--*/
{
FILE *InputFile;
UINT32 FileSize;
//
// Verify input parameters.
//
if (InputFileName == NULL || strlen (InputFileName) == 0 || InputFileImage == NULL) {
return EFI_INVALID_PARAMETER;
}
//
// Open the file and copy contents into a memory buffer.
//
//
// Open the file
//
InputFile = fopen (LongFilePath (InputFileName), "rb");
if (InputFile == NULL) {
Error (NULL, 0, 0001, "Error opening the input file", InputFileName);
return EFI_ABORTED;
}
//
// Go to the end so that we can determine the file size
//
if (fseek (InputFile, 0, SEEK_END)) {
Error (NULL, 0, 0004, "Error reading the input file", InputFileName);
fclose (InputFile);
return EFI_ABORTED;
}
//
// Get the file size
//
FileSize = ftell (InputFile);
if (FileSize == -1) {
Error (NULL, 0, 0003, "Error parsing the input file", InputFileName);
fclose (InputFile);
return EFI_ABORTED;
}
//
// Allocate a buffer
//
*InputFileImage = malloc (FileSize);
if (*InputFileImage == NULL) {
fclose (InputFile);
return EFI_OUT_OF_RESOURCES;
}
//
// Reset to the beginning of the file
//
if (fseek (InputFile, 0, SEEK_SET)) {
Error (NULL, 0, 0004, "Error reading the input file", InputFileName);
fclose (InputFile);
free (*InputFileImage);
*InputFileImage = NULL;
return EFI_ABORTED;
}
//
// Read all of the file contents.
//
*BytesRead = fread (*InputFileImage, sizeof (UINT8), FileSize, InputFile);
if (*BytesRead != sizeof (UINT8) * FileSize) {
Error (NULL, 0, 0004, "Error reading the input file", InputFileName);
fclose (InputFile);
free (*InputFileImage);
*InputFileImage = NULL;
return EFI_ABORTED;
}
//
// Close the file
//
fclose (InputFile);
return EFI_SUCCESS;
}
// Generate a sprite font from TTF file data (font size required)
// TODO: Review texture packing method and generation (use oversampling)
static SpriteFont LoadTTF(const char *fileName, int fontSize, int numChars, int *fontChars)
{
// NOTE: Font texture size is predicted (being as much conservative as possible)
// Predictive method consist of supposing same number of chars by line-column (sqrtf)
// and a maximum character width of 3/4 of fontSize... it worked ok with all my tests...
int textureSize = GetNextPOT(ceil((float)fontSize*3/4)*ceil(sqrtf((float)numChars)));
TraceLog(INFO, "TTF spritefont loading: Predicted texture size: %ix%i", textureSize, textureSize);
unsigned char *ttfBuffer = (unsigned char *)malloc(1 << 25);
unsigned char *dataBitmap = (unsigned char *)malloc(textureSize*textureSize*sizeof(unsigned char)); // One channel bitmap returned!
stbtt_bakedchar *charData = (stbtt_bakedchar *)malloc(sizeof(stbtt_bakedchar)*numChars);
SpriteFont font = { 0 };
FILE *ttfFile = fopen(fileName, "rb");
if (ttfFile == NULL)
{
TraceLog(WARNING, "[%s] TTF file could not be opened", fileName);
return font;
}
fread(ttfBuffer, 1, 1<<25, ttfFile);
if (fontChars[0] != 32) TraceLog(WARNING, "TTF spritefont loading: first character is not SPACE(32) character");
// NOTE: Using stb_truetype crappy packing method, no guarante the font fits the image...
// TODO: Replace this function by a proper packing method and support random chars order,
// we already receive a list (fontChars) with the ordered expected characters
int result = stbtt_BakeFontBitmap(ttfBuffer, 0, fontSize, dataBitmap, textureSize, textureSize, fontChars[0], numChars, charData);
//if (result > 0) TraceLog(INFO, "TTF spritefont loading: first unused row of generated bitmap: %i", result);
if (result < 0) TraceLog(WARNING, "TTF spritefont loading: Not all the characters fit in the font");
free(ttfBuffer);
// Convert image data from grayscale to to UNCOMPRESSED_GRAY_ALPHA
unsigned char *dataGrayAlpha = (unsigned char *)malloc(textureSize*textureSize*sizeof(unsigned char)*2); // Two channels
for (int i = 0, k = 0; i < textureSize*textureSize; i++, k += 2)
{
dataGrayAlpha[k] = 255;
dataGrayAlpha[k + 1] = dataBitmap[i];
}
free(dataBitmap);
// Sprite font generation from TTF extracted data
Image image;
image.width = textureSize;
image.height = textureSize;
image.mipmaps = 1;
image.format = UNCOMPRESSED_GRAY_ALPHA;
image.data = dataGrayAlpha;
font.texture = LoadTextureFromImage(image);
//WritePNG("generated_ttf_image.png", (unsigned char *)image.data, image.width, image.height, 2);
UnloadImage(image); // Unloads dataGrayAlpha
font.size = fontSize;
font.numChars = numChars;
font.charValues = (int *)malloc(font.numChars*sizeof(int));
font.charRecs = (Rectangle *)malloc(font.numChars*sizeof(Rectangle));
font.charOffsets = (Vector2 *)malloc(font.numChars*sizeof(Vector2));
font.charAdvanceX = (int *)malloc(font.numChars*sizeof(int));
for (int i = 0; i < font.numChars; i++)
{
font.charValues[i] = fontChars[i];
font.charRecs[i].x = (int)charData[i].x0;
font.charRecs[i].y = (int)charData[i].y0;
font.charRecs[i].width = (int)charData[i].x1 - (int)charData[i].x0;
font.charRecs[i].height = (int)charData[i].y1 - (int)charData[i].y0;
font.charOffsets[i] = (Vector2){ charData[i].xoff, charData[i].yoff };
font.charAdvanceX[i] = (int)charData[i].xadvance;
}
free(charData);
return font;
}
int main(int argc, char **argv){
FILE *fid;
DIR* dir;
int nhalos;
long int ln;
int ix,iy,iz,i;
Halo_sim *halo_in;
Halo_t *halo_out;
char fname[300];
size_t elem;
double z, dx;
if(argc!=4) {
printf("\nConverts halo catalogues from Mellema to Simfast21 format\n");
printf("usage: convert_halos.x work_dir halo_catalog_input z\n\n");
exit(1);
}
get_Simfast21_params(argv[1]);
print_parms();
z=atof(argv[3]);
sprintf(fname, "%s/Halos/halo_z%.3f_N%ld_L%.0f.dat.catalog",argv[1],z,global_N_halo,global_L);
fid=fopen(fname,"rb");
if(fid!=NULL) {
printf("File:%s already exists - exiting...\n",fname);
exit(1);
}
#ifdef _OMPTHREAD_
omp_set_num_threads(global_nthreads);
printf("Using %d threads\n",global_nthreads);
#endif
dx=global_dx_halo/global_hubble; /* convert to Mpc */
/* read halo catalog */
if((fid=fopen(argv[2],"rb"))==NULL){
printf("Halo file: %s does not exist...\n",argv[2]);
exit(1);
}
elem=fread(&nhalos,sizeof(int),1,fid);
printf("Reading %d halos...\n",nhalos);fflush(0);
if(!(halo_in=(Halo_sim *) malloc(nhalos*sizeof(Halo_sim)))) {
printf("Memory problem - halos...\n");
exit(1);
}
elem=fread(halo_in,sizeof(Halo_sim),nhalos,fid);
if((int)elem!=nhalos) {printf("Problem reading halos. Exiting...\n"); exit(1);}
fclose(fid);
if(!(halo_out=(Halo_t *) malloc(nhalos*sizeof(Halo_t)))) {
printf("Memory problem - halos...\n");
exit(1);
}
printf("Converting...\n"); fflush(0);
//#ifdef _OMPTHREAD_
//#pragma omp parallel for shared(halo_in,halo_out) private(i)
//#endif
for(i=0;i<nhalos;i++) {
halo_out[i].Mass=pow(10.0,halo_in[i].val[10]); /* Mass in Msun */
halo_out[i].Radius=halo_in[i].val[9]*(1.0+z)/1000.0*global_hubble; /* Convert from radius in proper Kpc to comoving Mpc/h*/
ix=(int)roundf(halo_in[i].val[0]/dx);
if(ix < 0 || ix >= global_N_halo) {
//#pragma omp critical
{
printf("Error in halo index: i, ix = %d, %d. Exiting...\n",i,ix);
exit(1);
}
}
iy=(int)roundf(halo_in[i].val[1]/dx);
if(iy < 0 || iy >= global_N_halo) {
//#pragma omp critical
{
printf("Error in halo index: i, iy = %d, %d. Exiting...\n",i, iy);
exit(1);
}
}
iz=(int)roundf(halo_in[i].val[2]/dx);
if(iz < 0 || iz >= global_N_halo) {
//#pragma omp critical
{
printf("Error in halo index: i, iz = %d, %d. Exiting...\n",i, iz);
exit(1);
}
}
/* switch indexes since we're assuming x should be the slowest moving index, not the fastest as in Garrelt... */
halo_out[i].x=iz;
halo_out[i].y=iy;
halo_out[i].z=ix;
}
printf("Writing...\n"); fflush(0);
sprintf(fname,"%s/Halos",argv[1]);
if((dir=opendir(fname))==NULL) {
printf("Creating Halo directory\n");
if(mkdir(fname,(S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH))!=0) {
printf("Error creating directory!\n");
exit(1);
}
}
sprintf(fname, "%s/Halos/halo_z%.3f_N%ld_L%.0f.dat.catalog",argv[1],z,global_N_halo,global_L);
fid=fopen(fname,"wb");
if(fid==NULL){printf("\nCatalog file output error. Exiting...\n"); exit (1);}
ln=(long int)nhalos;
elem=fwrite(&ln,sizeof(long int),1,fid);
elem=fwrite(halo_out,sizeof(Halo_t),nhalos,fid);
if((int)elem!=nhalos) {printf("Problem writing halos. Exiting...\n"); exit(1);}
exit(0);
}
/* this function read a file and verify if it is a valid mpq archive, then it read and decrypt the hash table. */
int32_t libmpq__archive_open(mpq_archive_s **mpq_archive, const char *mpq_filename, libmpq__off_t archive_offset) {
/* some common variables. */
uint32_t i = 0;
uint32_t count = 0;
int32_t result = 0;
uint32_t header_search = FALSE;
if (archive_offset == -1) {
archive_offset = 0;
header_search = TRUE;
}
if ((*mpq_archive = calloc(1, sizeof(mpq_archive_s))) == NULL) {
/* archive struct could not be allocated */
return LIBMPQ_ERROR_MALLOC;
}
/* check if file exists and is readable */
if (((*mpq_archive)->fp = fopen(mpq_filename, "rb")) == NULL) {
/* file could not be opened. */
result = LIBMPQ_ERROR_OPEN;
goto error;
}
/* assign some default values. */
(*mpq_archive)->mpq_header.mpq_magic = 0;
(*mpq_archive)->files = 0;
/* loop through file and search for mpq signature. */
while (TRUE) {
/* reset header values. */
(*mpq_archive)->mpq_header.mpq_magic = 0;
/* seek in file. */
if (fseeko((*mpq_archive)->fp, archive_offset, SEEK_SET) < 0) {
/* seek in file failed. */
result = LIBMPQ_ERROR_SEEK;
goto error;
}
/* read header from file. */
if (fread(&(*mpq_archive)->mpq_header, 1, sizeof(mpq_header_s), (*mpq_archive)->fp) != sizeof(mpq_header_s)) {
/* no valid mpq archive. */
result = LIBMPQ_ERROR_FORMAT;
goto error;
}
/* check if we found a valid mpq header. */
if ((*mpq_archive)->mpq_header.mpq_magic == LIBMPQ_HEADER) {
/* check if we process old mpq archive version. */
if ((*mpq_archive)->mpq_header.version == LIBMPQ_ARCHIVE_VERSION_ONE) {
/* check if the archive is protected. */
if ((*mpq_archive)->mpq_header.header_size != sizeof(mpq_header_s)) {
/* correct header size. */
(*mpq_archive)->mpq_header.header_size = sizeof(mpq_header_s);
}
}
/* check if we process new mpq archive version. */
if ((*mpq_archive)->mpq_header.version == LIBMPQ_ARCHIVE_VERSION_TWO) {
/* check if the archive is protected. */
if ((*mpq_archive)->mpq_header.header_size != sizeof(mpq_header_s) + sizeof(mpq_header_ex_s)) {
/* correct header size. */
(*mpq_archive)->mpq_header.header_size = sizeof(mpq_header_s) + sizeof(mpq_header_ex_s);
}
}
/* break the loop, because header was found. */
break;
}
/* move to the next possible offset. */
if (!header_search) {
/* no valid mpq archive. */
result = LIBMPQ_ERROR_FORMAT;
goto error;
}
archive_offset += 512;
}
/* store block size for later use. */
(*mpq_archive)->block_size = 512 << (*mpq_archive)->mpq_header.block_size;
/* store archive offset and size for later use. */
(*mpq_archive)->archive_offset = archive_offset;
/* check if we process new mpq archive version. */
if ((*mpq_archive)->mpq_header.version == LIBMPQ_ARCHIVE_VERSION_TWO) {
/* seek in file. */
if (fseeko((*mpq_archive)->fp, sizeof(mpq_header_s) + archive_offset, SEEK_SET) < 0) {
/* seek in file failed. */
result = LIBMPQ_ERROR_SEEK;
goto error;
}
/* read header from file. */
if (fread(&(*mpq_archive)->mpq_header_ex, 1, sizeof(mpq_header_ex_s), (*mpq_archive)->fp) != sizeof(mpq_header_ex_s)) {
/* no valid mpq archive. */
result = LIBMPQ_ERROR_FORMAT;
goto error;
}
}
/* allocate memory for the block table, hash table, file and block table to file mapping. */
if (((*mpq_archive)->mpq_block = calloc((*mpq_archive)->mpq_header.block_table_count, sizeof(mpq_block_s))) == NULL ||
((*mpq_archive)->mpq_block_ex = calloc((*mpq_archive)->mpq_header.block_table_count, sizeof(mpq_block_ex_s))) == NULL ||
((*mpq_archive)->mpq_hash = calloc((*mpq_archive)->mpq_header.hash_table_count, sizeof(mpq_hash_s))) == NULL ||
((*mpq_archive)->mpq_file = calloc((*mpq_archive)->mpq_header.block_table_count, sizeof(mpq_file_s))) == NULL ||
((*mpq_archive)->mpq_map = calloc((*mpq_archive)->mpq_header.block_table_count, sizeof(mpq_map_s))) == NULL) {
/* memory allocation problem. */
result = LIBMPQ_ERROR_MALLOC;
goto error;
}
/* seek in file. */
if (fseeko((*mpq_archive)->fp, (*mpq_archive)->mpq_header.hash_table_offset + (((long long)((*mpq_archive)->mpq_header_ex.hash_table_offset_high)) << 32) + (*mpq_archive)->archive_offset, SEEK_SET) < 0) {
/* seek in file failed. */
result = LIBMPQ_ERROR_SEEK;
goto error;
}
/* read the hash table into the buffer. */
if (fread((*mpq_archive)->mpq_hash, 1, (*mpq_archive)->mpq_header.hash_table_count * sizeof(mpq_hash_s), (*mpq_archive)->fp) != (*mpq_archive)->mpq_header.hash_table_count * sizeof(mpq_hash_s)) {
/* something on read failed. */
result = LIBMPQ_ERROR_READ;
goto error;
}
/* decrypt the hashtable. */
libmpq__decrypt_block((uint32_t *)((*mpq_archive)->mpq_hash), (*mpq_archive)->mpq_header.hash_table_count * sizeof(mpq_hash_s), libmpq__hash_string("(hash table)", 0x300));
/* seek in file. */
if (fseeko((*mpq_archive)->fp, (*mpq_archive)->mpq_header.block_table_offset + (((long long)((*mpq_archive)->mpq_header_ex.block_table_offset_high)) << 32) + (*mpq_archive)->archive_offset, SEEK_SET) < 0) {
/* seek in file failed. */
result = LIBMPQ_ERROR_SEEK;
goto error;
}
/* read the block table into the buffer. */
if (fread((*mpq_archive)->mpq_block, 1, (*mpq_archive)->mpq_header.block_table_count * sizeof(mpq_block_s), (*mpq_archive)->fp) != (*mpq_archive)->mpq_header.block_table_count * sizeof(mpq_block_s)) {
/* something on read failed. */
result = LIBMPQ_ERROR_READ;
goto error;
}
/* decrypt block table. */
libmpq__decrypt_block((uint32_t *)((*mpq_archive)->mpq_block), (*mpq_archive)->mpq_header.block_table_count * sizeof(mpq_block_s), libmpq__hash_string("(block table)", 0x300));
/* check if extended block table is present, regardless of version 2 it is only present in archives > 4GB. */
if ((*mpq_archive)->mpq_header_ex.extended_offset > 0) {
/* seek in file. */
if (fseeko((*mpq_archive)->fp, (*mpq_archive)->mpq_header_ex.extended_offset + archive_offset, SEEK_SET) < 0) {
/* seek in file failed. */
result = LIBMPQ_ERROR_SEEK;
goto error;
}
/* read header from file. */
if (fread((*mpq_archive)->mpq_block_ex, 1, (*mpq_archive)->mpq_header.block_table_count * sizeof(mpq_block_ex_s), (*mpq_archive)->fp) != (*mpq_archive)->mpq_header.block_table_count * sizeof(mpq_block_ex_s)) {
/* no valid mpq archive. */
result = LIBMPQ_ERROR_FORMAT;
goto error;
}
}
/* loop through all files in mpq archive and check if they are valid. */
for (i = 0; i < (*mpq_archive)->mpq_header.block_table_count; i++) {
/* save block difference between valid and invalid blocks. */
(*mpq_archive)->mpq_map[i].block_table_diff = i - count;
/* check if file exists, sizes and offsets are correct. */
if (((*mpq_archive)->mpq_block[i].flags & LIBMPQ_FLAG_EXISTS) == 0) {
/* file does not exist, so nothing to do with that block. */
continue;
}
/* create final indices tables. */
(*mpq_archive)->mpq_map[count].block_table_indices = i;
/* increase file counter. */
count++;
}
/* save the number of files. */
(*mpq_archive)->files = count;
/* if no error was found, return zero. */
return LIBMPQ_SUCCESS;
error:
if ((*mpq_archive)->fp)
fclose((*mpq_archive)->fp);
free((*mpq_archive)->mpq_map);
free((*mpq_archive)->mpq_file);
free((*mpq_archive)->mpq_hash);
free((*mpq_archive)->mpq_block);
free((*mpq_archive)->mpq_block_ex);
free(*mpq_archive);
*mpq_archive = NULL;
return result;
}
int APIENTRY pngLoadRawF(FILE *fp, pngRawInfo *pinfo) {
unsigned char header[8];
png_structp png;
png_infop info;
png_infop endinfo;
png_bytep data;
png_bytep *row_p;
double fileGamma;
png_uint_32 width, height;
int depth, color;
png_uint_32 i;
if (pinfo == NULL) return 0;
fread(header, 1, 8, fp);
if (!png_check_sig(header, 8)) return 0;
png = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
info = png_create_info_struct(png);
endinfo = png_create_info_struct(png);
// DH: added following lines
if (setjmp(png->jmpbuf))
{
png_destroy_read_struct(&png, &info, &endinfo);
return 0;
}
// ~DH
png_init_io(png, fp);
png_set_sig_bytes(png, 8);
png_read_info(png, info);
png_get_IHDR(png, info, &width, &height, &depth, &color, NULL, NULL, NULL);
pinfo->Width = width;
pinfo->Height = height;
pinfo->Depth = depth;
/*--GAMMA--*/
checkForGammaEnv();
if (png_get_gAMA(png, info, &fileGamma))
png_set_gamma(png, screenGamma, fileGamma);
else
png_set_gamma(png, screenGamma, 1.0/2.2);
png_read_update_info(png, info);
data = (png_bytep) malloc(png_get_rowbytes(png, info)*height);
row_p = (png_bytep *) malloc(sizeof(png_bytep)*height);
for (i = 0; i < height; i++) {
if (StandardOrientation)
row_p[height - 1 - i] = &data[png_get_rowbytes(png, info)*i];
else
row_p[i] = &data[png_get_rowbytes(png, info)*i];
}
png_read_image(png, row_p);
free(row_p);
if (color == PNG_COLOR_TYPE_PALETTE) {
int cols;
png_get_PLTE(png, info, (png_colorp *) &pinfo->Palette, &cols);
}
else {
pinfo->Palette = NULL;
}
if (color&PNG_COLOR_MASK_ALPHA) {
if (color&PNG_COLOR_MASK_PALETTE || color == PNG_COLOR_TYPE_GRAY_ALPHA)
pinfo->Components = 2;
else
pinfo->Components = 4;
pinfo->Alpha = 8;
}
else {
if (color&PNG_COLOR_MASK_PALETTE || color == PNG_COLOR_TYPE_GRAY)
pinfo->Components = 1;
else
pinfo->Components = 3;
pinfo->Alpha = 0;
}
pinfo->Data = data;
png_read_end(png, endinfo);
png_destroy_read_struct(&png, &info, &endinfo);
return 1;
}
