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