static void getsgiheader(struct sgiheader *head, FILE *fp) { head->magic = getshort(fp); head->format = getc(fp); head->bpc = getc(fp); head->dim = getshort(fp); head->width = getshort(fp); head->height = getshort(fp); head->chans = getshort(fp); head->pixmin = getlong(fp); head->pixmax = getlong(fp); fread(head->dummy,sizeof(head->dummy),1,fp); fread(head->imagename,sizeof(head->imagename),1,fp); head->colormap = getlong(fp); fread(head->pad,sizeof(head->pad),1,fp); }
void three_coord_out(FILE *fp, fastf_t *m) { point_t p1; short p2[3]; p1[0] = getshort(fp); /* get X */ p1[1] = getshort(fp); /* and Y */ p1[2] = getshort(fp); /* and Z */ MAT4X3PNT( p2, m, p1 ); putsi(p2[0]); /* put X */ putsi(p2[1]); /* and Y */ putsi(p2[2]); /* and Z */ }
/** * * * @param input * @param filename */ void do_ppt(FILE *input,char *filename) { int itemsread=1; int rectype; long reclen; unsigned char recbuf[8]; while(itemsread) { itemsread = catdoc_read(recbuf, 1, 8, input); /* fprintf(stderr,"itemsread=%d: ",itemsread); */ /* for(i=0; i<8; i++) */ /* fprintf(stderr,"%02x ",recbuf[i]); */ /* fprintf(stderr,"\n"); */ if (catdoc_eof(input)) { process_item(DOCUMENT_END,0,input); return; } if(itemsread < 8) break; rectype=getshort(recbuf,2); reclen=getulong(recbuf,4); if (reclen < 0) { return; } process_item(rectype,reclen,input); } }
long getvalue() { unsigned char ch; char c; short s; ch = getbyte(); if (ch < 128) { return (ch); } switch (ch & 0xff) { case OLF_STRING: s = getbyte(); dump_hex(s, true); return (0); case OLF_1_SIGNED: // Fix for vax compiler bug, doesn't cast procedure return // values correctly c = getbyte(); return (c); case OLF_2_SIGNED: s = getshort(); return (s); case OLF_2_UNSIGNED: return (getshort() & 0xffff); case OLF_4_UNSIGNED: case OLF_4_SIGNED: return (getlong()); case OLF_8_UNSIGNED: case OLF_8_SIGNED: StdOutPuts(L"??? 8 byte values not handled presently\n"); dump_hex(8, true); return(0); default: ty_error(ch, L"Expecting numeric leaf"); return (0); } }
void DumpCobL0 (BYTE level) { WORD NameAlg = getshort(); StdOutPrintf(L"\tLevel = %02d ", level); StdOutPrintf(L"root = \"%S\"", getstring()); dump_hex((Leaf_bytes - Leaf_pos), true); StdOutPuts(L"\n"); }
void outshort(int n) { int i; for (i = 0; i < n; i++) { (void)getshort(); } }
void NetDifficulty::Unpacketize(uint16 id, uint8* buf, uint16 size) { Assert(buf[0] == 'G' && buf[1] == 'D'); PLAYER_INDEX pidx = (PLAYER_INDEX)getshort(&buf[2]); Assert(pidx < k_MAX_PLAYERS); Assert(g_player[pidx] != NULL); *g_player[pidx]->m_difficulty = *(Difficulty*)&buf[4]; }
int sgiGetRow(sgi_t *sgip, /* I - SGI image */ unsigned short *row, /* O - Row to read */ int y, /* I - Line to read */ int z) /* I - Channel to read */ { int x; /* X coordinate */ long offset; /* File offset */ if (sgip == NULL || row == NULL || y < 0 || y >= sgip->ysize || z < 0 || z >= sgip->zsize) return (-1); switch (sgip->comp) { case SGI_COMP_NONE : /* * Seek to the image row - optimize buffering by only seeking if * necessary... */ offset = 512 + (y + z * sgip->ysize) * sgip->xsize * sgip->bpp; if (offset != ftell(sgip->file)) fseek(sgip->file, offset, SEEK_SET); if (sgip->bpp == 1) { for (x = sgip->xsize; x > 0; x --, row ++) *row = getc(sgip->file); } else { for (x = sgip->xsize; x > 0; x --, row ++) *row = getshort(sgip); }; break; case SGI_COMP_RLE : offset = sgip->table[z][y]; if (offset != ftell(sgip->file)) fseek(sgip->file, offset, SEEK_SET); if (sgip->bpp == 1) return (read_rle8(sgip, row, sgip->xsize)); else return (read_rle16(sgip, row, sgip->xsize)); break; }; return (0); }
unsigned short getindex() { unsigned char ch; ch = getbyte(); if (ch != OLF_INDEX) { ty_error(ch, L"Expecting index leaf"); } return(getshort()); }
static unsigned char *read_zip_file(FILE *file, int offset, int *sizep) { int sig, method, csize, usize; int namelength, extralength; char *cdata, *udata; fseek(file, offset, 0); sig = getlong(file); if (sig != ZIP_LOCAL_FILE_SIG) { warn("zip: wrong signature for local file"); return NULL; } (void) getshort(file); /* version */ (void) getshort(file); /* general */ method = getshort(file); (void) getshort(file); /* file time */ (void) getshort(file); /* file date */ (void) getlong(file); /* crc-32 */ csize = getlong(file); /* csize */ usize = getlong(file); /* usize */ namelength = getshort(file); extralength = getshort(file); fseek(file, namelength + extralength, 1); if (method == 0 && csize == usize) { cdata = malloc(csize); fread(cdata, 1, csize, file); *sizep = csize; return (unsigned char*) cdata; } if (method == 8) { cdata = malloc(csize); fread(cdata, 1, csize, file); udata = malloc(usize); usize = stbi_zlib_decode_noheader_buffer(udata, usize, cdata, csize); free(cdata); if (usize < 0) { warn("zip: %s", stbi_failure_reason()); return NULL; } *sizep = usize; return (unsigned char*) udata; } warn("zip: unknown compression method"); return NULL; }
void MBR_parse(struct disk *disk, struct dos_mbr *dos_mbr, off_t offset, off_t reloff, struct mbr *mbr) { int i; memcpy(mbr->code, dos_mbr->dmbr_boot, sizeof(mbr->code)); mbr->offset = offset; mbr->reloffset = reloff; mbr->signature = getshort(&dos_mbr->dmbr_sign); for (i = 0; i < NDOSPART; i++) PRT_parse(disk, &dos_mbr->dmbr_parts[i], offset, reloff, &mbr->part[i]); }
static void rt_uplot_get_args(FILE *fp, const struct uplot *up, char *carg, fastf_t *arg) { size_t ret; int i, j; int cc = 0; char inbuf[SIZEOF_NETWORK_DOUBLE] = {'\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0'}; for (i = 0; i < up->narg; i++) { switch (up->targ) { case TSHORT: arg[i] = getshort(fp); break; case TIEEE: { double scan; ret = fread(inbuf, SIZEOF_NETWORK_DOUBLE, 1, fp); if (ret != 1) bu_log("WARNING: uplot read failure\n"); ntohd((unsigned char *)&scan, (unsigned char *)inbuf, 1); arg[i] = scan; /* convert double to fastf_t */ break; } case TSTRING: j = 0; while (!feof(fp) && (cc = getc(fp)) != '\n') carg[j++] = cc; carg[j] = '\0'; break; case TCHAR: cc = getc(fp); if (cc == EOF) return; carg[i] = cc; arg[i] = 0; break; case TNONE: default: arg[i] = 0; /* ? */ break; } } }
static int readheaderttf(FILE *pcl,struct ttf_header *hdr) { int i; int seg_id, seg_size; hdr->scale_factor = getshort(pcl); hdr->mupos = (short) getshort(pcl); hdr->muthick = getshort(pcl); hdr->fontscaletech = getc(pcl); hdr->variety = getc(pcl); if ( hdr->fd_size<72 || hdr->header_format!=15 ) { fprintf( stderr, "%s is not a PCL truetype font\n", hdr->fontname ); return( false ); } /* Manual says there font descriptor size is at least 72, but no indication */ /* given about what these variable data might contain. The examples I've */ /* been given have the fd_size==72 */ for ( i=0 ; i<hdr->fd_size-72; ++i ) getc(pcl); for (;;) { seg_id = getshort(pcl); seg_size = getshort(pcl); if ( seg_id == (('C'<<8)|'P') ) { hdr->copyright = malloc(seg_size+1); fread(hdr->copyright,1,seg_size,pcl); hdr->copyright[seg_size] = '\0'; } else if ( seg_id == (('C'<<8)|'C') ) { if ( seg_size==8 ) fread(hdr->charcompl,1,8,pcl); else fseek(pcl,seg_size,SEEK_CUR); } else if ( seg_id == (('P'<<8)|'A') ) { if ( seg_size==10 ) fread(hdr->panose,1,10,pcl); else fseek(pcl,seg_size,SEEK_CUR); } else if ( seg_id == (('G'<<8)|'T') ) { readttftables(pcl,hdr,seg_size); } else if ( seg_id == 0xffff || seg_id==EOF ) { getshort(pcl); break; } else fseek(pcl,seg_size,SEEK_CUR); } if ( !hasRequiredTables(hdr)) { fprintf( stderr, "%s is missing a required ttf table\n", hdr->fontname ); return( false ); } return( slurpglyphs(pcl,hdr)); }
void Archive::Open(IO::Stream* stream) { m_p->m_stream = stream; TRY { uint32 signature; while ((signature = getint32()) == 0x04034b50) { File* file = new File(this); file->m_bytepos = m_p->m_stream->GetPosition(); uint16 version_needed_to_extract = getshort();// 2 bytes uint16 general_purpose_bit_flag = getshort();// 2 bytes file->m_compression_method = getshort();// 2 bytes uint16 last_mod_file_time = getshort();// 2 bytes uint16 last_mod_file_date = getshort();// 2 bytes file->m_crc_32 = getint32();// 4 bytes file->m_compressed_size = getint32();// 4 bytes file->m_uncompressed_size = getint32();// 4 bytes uint16 file_name_length = getshort();// 2 bytes uint16 extra_field_length = getshort();// 2 bytes file->m_name = String(string_alloc<char>(file_name_length)); m_p->m_stream->Read(file->m_name.GetData8(), file_name_length); m_p->m_stream->Seek(extra_field_length, IO::STREAM_SEEK_CUR); file->m_dataoffset = m_p->m_stream->GetPosition() - file->m_bytepos; m_p->m_stream->Seek(file->m_compressed_size, IO::STREAM_SEEK_CUR); m_p->m_filesByName[file->m_name] = file; m_p->m_files.push_back(file); } while (signature == 0x02014b50) { signature = getint32(); } } CATCH (Exception* e) { } }
void getmaze(TCPsocket sock) { Uint16 n; int recv; switch (n = getshort(sock)) { case MAZE_MAGIC: break; case SRV_BUSY: fprintf(stderr, "Game is already going on :(\n"); exit(EXIT_FAILURE); default: fprintf(stderr, "Bad magic number from server: %x\n", n); exit(EXIT_FAILURE); } MAZE.w = getint(sock); MAZE.size = getint(sock); MAZE.h = MAZE.size / MAZE.w; #ifdef _DEBUG printf("[DEBUG] maze w size h = %ld %ld %ld\n", MAZE.w, MAZE.size, MAZE.h); #endif MAZE.data = malloc(MAZE.size); // uh no if ((recv = recvall(sock, MAZE.data, MAZE.size)) != MAZE.size) { fprintf(stderr, "Failed to get maze. Got %d bytes, expected %ld. %s\n", recv, MAZE.size, SDLNet_GetError()); exit(EXIT_FAILURE); } sendshort(sock, MAZE_MAGIC); /* Confirmation reply */ }
/** \brief Read pixel data from an SGI .rgb image. * * Reads an .rgb file, allocates memory for the pixels * and sets *w and *h to image width and height. * * \param name file name * \param w will be set to image width * \param h will be set to image height * \return pointer to the pixel data or NULL on error */ unsigned char * read_rgbimage(const char *name, int *w, int *h) { unsigned char *image, *temp; FILE *image_in; unsigned char input_char; unsigned short int input_short; unsigned char header[512]; unsigned long int loop; if ( (image_in = fopen(name, "rb")) == NULL) { printf("%s\n", name); std::string s = "read_rgbimage: Unable to open "; s += name; perror(s.c_str()); return NULL; } input_short=getshort(image_in); if (input_short == 0x01da) { input_char=getrgbchar(image_in); if (input_char == 0) { input_char=getrgbchar(image_in); input_short=getshort(image_in); if (input_short == 3) { input_short=getshort(image_in); *w=input_short; input_short=getshort(image_in); *h=input_short; image=(unsigned char*)malloc(*w * *h *4 *sizeof(unsigned char)); temp=(unsigned char*)malloc(*w * *h *sizeof(unsigned char)); if ((image == NULL) || (temp == NULL)) { fprintf(stderr, "Error allocating memory for %s\n", name); // just in case one of the two was malloc'ed correctly: free(image); free(temp); return NULL; } input_short=getshort(image_in); if (input_short == 4) { (void)fread(header,sizeof(unsigned char),500,image_in); (void)fread(temp, sizeof image[0], *w * *h, image_in); for (loop=0;loop<(unsigned long int)(*w * *h);loop++) { image[loop*4+0]=temp[loop]; } (void)fread(temp, sizeof image[0], *w * *h, image_in); for (loop=0;loop<(unsigned long int)(*w * *h);loop++) { image[loop*4+1]=temp[loop]; } (void)fread(temp, sizeof image[0], *w * *h, image_in); for (loop=0;loop<(unsigned long int)(*w * *h);loop++) { image[loop*4+2]=temp[loop]; } (void)fread(temp, sizeof image[0], *w * *h, image_in); for (loop=0;loop<(unsigned long int)(*w * *h);loop++) { image[loop*4+3]=temp[loop]; } free(temp); return image; } else { std::string s = "Error loading texture "; s += name; s += ":\nThis file isn't a 4 channel RGBA file."; fprintf(stderr, "%s\n", s.c_str()); return NULL; } } else { std::string s = "Error loading texture "; s += name; s += ":\nNot a useable RGB file."; fprintf(stderr, "%s\n", s.c_str()); return NULL; } } else { std::string s = "Error loading texture "; s += name; s += ":\nRLE encoded SGI files are not supported."; fprintf(stderr, "%s\n", s.c_str()); return NULL; } } else { std::string s = "Error loading texture "; s += name; s += ":\nFile doesn't appear to be an SGI rgb file!"; fprintf(stderr, "%s\n", s.c_str()); return NULL; } return NULL; }
static int readheaderformat(FILE *pcl,struct ttf_header *hdr) { int ch, i; memset(hdr,0,sizeof(*hdr)); fscanf(pcl,"%d", &hdr->header_size ); ch = getc(pcl); if ( ch!='W' ) { fprintf( stderr, "Bad font, font header command doesn't end in \"W\"\n" ); return( false ); } hdr->fd_size = getshort(pcl); hdr->header_format = getc(pcl); hdr->fonttype = getc(pcl); hdr->style = getc(pcl)<<8; (void) getc(pcl); hdr->baseline_pos = getshort(pcl); hdr->cell_width = getshort(pcl); hdr->cell_height = getshort(pcl); hdr->orientation = getc(pcl); hdr->spacing = getc(pcl); hdr->symbol_set = getshort(pcl); hdr->pitch = getshort(pcl); hdr->height = getshort(pcl); hdr->xheight = getshort(pcl); hdr->widthtype = getc(pcl); hdr->style |= getc(pcl); hdr->strokeweight = getc(pcl); hdr->typeface = getc(pcl); hdr->typeface |= getc(pcl)<<8; hdr->serifstyle = getc(pcl); hdr->quality = getc(pcl); hdr->placement = getc(pcl); hdr->upos = getc(pcl); hdr->uthick = getc(pcl); hdr->textheight = getshort(pcl); hdr->textwidth = getshort(pcl); hdr->firstcode = getshort(pcl); hdr->num_chars = getshort(pcl); hdr->pitchx = getc(pcl); hdr->heightx = getc(pcl); hdr->capheight = getshort(pcl); hdr->fontnumber = getlong(pcl); for ( i=0; i<16; ++i ) hdr->fontname[i] = getc(pcl); while ( i>1 && hdr->fontname[i-1]==' ' ) --i; hdr->fontname[i] = '\0'; return( false ); }
static int slurpglyph(FILE *pcl,struct ttf_header *hdr, int slot) { int unicode, size, ch; int desc_size, i; int cd_size; int glyph_start; int restart = ftell(pcl); if ( !skip2charcode(pcl)) { fprintf( stderr, "Fewer glyphs in font than expected\n" ); fseek(pcl,restart,SEEK_SET); return( false ); } fscanf(pcl,"%d", &unicode ); ch = getc(pcl); if ( ch!='E' ) { fprintf( stderr, "Fewer glyphs in font than expected\n" ); fseek(pcl,restart,SEEK_SET); return( false ); } if ( !skip2glyph(pcl)) return( false ); fscanf(pcl,"%d", &size ); ch = getc(pcl); if ( ch!='W' ) { fprintf( stderr, "Bad font, glyph size does not end in \"W\"\n" ); return( false ); } glyph_start = ftell(pcl); if ( getc(pcl)!=15 ) { fprintf( stderr, "Bad font, glyph format must be 15\n" ); return( false ); } if ( getc(pcl)!=0 ) { fprintf( stderr, "Bad font, continuation may not be specified here\n" ); return( false ); } desc_size = getc(pcl); if ( getc(pcl)!=15 ) { fprintf( stderr, "Bad font, glyph class must be 15\n" ); return( false ); } for ( i=2; i<desc_size; ++i ) getc(pcl); cd_size = getshort(pcl); hdr->glyphs[slot].glyph = getshort(pcl); hdr->glyphs[slot].unicode = unicode; hdr->glyphs[slot].len = cd_size-4; hdr->glyphs[slot].offset = ftell(pcl); hdr->glyphs[slot].continuation = NULL; fseek(pcl,glyph_start+size,SEEK_SET); if ( size<cd_size+4+desc_size ) { /* The docs only allow for one continuation glyph */ if ( !skip2glyph(pcl)) return( false ); fscanf(pcl,"%d", &size ); ch = getc(pcl); if ( ch!='W' ) { fprintf( stderr, "Bad font, glyph size does not end in \"W\"\n" ); return( false ); } if ( getc(pcl)!=15 ) { fprintf( stderr, "Bad font, glyph format must be 15\n" ); return( false ); } if ( getc(pcl)!=1 ) { fprintf( stderr, "Bad font, continuation must be specified here\n" ); return( false ); } hdr->glyphs[slot].continuation = calloc(1,sizeof(struct glyph)); hdr->glyphs[slot].continuation->offset = ftell(pcl); hdr->glyphs[slot].continuation->len = size-4; fseek(pcl,size-2,SEEK_CUR); } return( true ); }
float raster_contagion () { int *adj,*carea; int edgeval; int size; float sum,contagion,prop1,prop2; short i,j,n; short value,neighbor; short xptr,yptr; /* * Get a clean copy of the image. */ read_image(0); /* * Allocate space for needed variables. */ size = max_class - min_class + 1; adj = (int *) calloc ((unsigned)size,sizeof(int)); if (adj == NULL) { printf ("\nERROR! rascont: Can not allocate space for adj!"); exit(-1); } carea = (int *) calloc ((unsigned)size,sizeof(int)); if (carea == NULL) { printf ("\nERROR! rascont: Can not allocate space for carea!"); exit(-1); } /* * Initialize */ for (i=0; i < size; i++) { carea[i] = 0; adj[i] = 0; for(j=0; j < size; j++) setint(edge,num_wt,i,j,0); } /* * Step through all cells in the image */ for (i=0; i < num_rows; i++) { for (j=0; j < num_cols; j++) { value = getshort(image,num_cols,i,j); if (value < 0) continue; /* * Get the area of each class. */ carea[value-min_class] ++; /* * Look at this values 4 neighbors .... */ for (n=0; n < 4; n++) { xptr = j + xpos[n]; if (xptr < 0 || xptr >= num_cols) continue; yptr = i + ypos[n]; if (yptr < 0 || yptr >= num_rows) continue; neighbor = getshort(image,num_cols,yptr,xptr); /* * If the neighbor is within the landscape (value >=0), * increment the count of its patchtype, and increment the * count of the number of this edge type combo. */ if (neighbor >= 0) { adj[value-min_class] ++; edgeval = getint(edge,num_wt,value-min_class, neighbor-min_class); edgeval ++; setint(edge,num_wt,value-min_class,neighbor-min_class, edgeval); } } } } /* * Loop over all classes */ sum = 0.0; for (i=0; i < size; i++) { if (carea[i] == 0.0) continue; /* * Get the proportion of the landscape in this class. */ prop1 = (float)carea[i] / (float)total_size; /* * Look for adjacencies with other classes. */ for (j=0; j < size; j++) { edgeval = getint(edge,num_wt,i,j); if (edgeval > 0) { prop2 = (float)edgeval / (float)adj[i]; sum += (prop1 * prop2) * log(prop1 * prop2); } } } /* * Calculate contagion. */ contagion = (sum / (2.0 * log((double)total_num_classes))) + 1.0; free (adj); free (carea); return (contagion); }
/** * Initializes ole structure * * @param f (FILE *) compound document file, positioned at bufSize * byte. Might be pipe or socket * @param buffer (void *) bytes already read from f * @param bufSize number of bytes already read from f should be less * than 512 * * @return */ FILE* ole_init(FILE *f, void *buffer, size_t bufSize) { unsigned char oleBuf[BBD_BLOCK_SIZE]; unsigned char *tmpBuf; FILE *newfile; int ret=0, i; long int sbdMaxLen, sbdCurrent, propMaxLen, propCurrent, mblock, msat_size; oleEntry *tEntry; /* deleting old data (if it was allocated) */ ole_finish(); if (fseek(f,0,SEEK_SET) == -1) { if ( errno == ESPIPE ) { /* We got non-seekable file, create temp file */ if((newfile=tmpfile()) == NULL) { perror("Can't create tmp file"); return NULL; } if (bufSize > 0) { ret=fwrite(buffer, 1, bufSize, newfile); if(ret != bufSize) { perror("Can't write to tmp file"); return NULL; } } while(!feof(f)){ ret=fread(oleBuf,1,BBD_BLOCK_SIZE,f); fwrite(oleBuf, 1, ret, newfile); } fseek(newfile,0,SEEK_SET); } else { perror("Can't seek in file"); return NULL; } } else { newfile=f; } fseek(newfile,0,SEEK_END); fileLength=ftell(newfile); /* fprintf(stderr, "fileLength=%ld\n", fileLength); */ fseek(newfile,0,SEEK_SET); ret=fread(oleBuf,1,BBD_BLOCK_SIZE,newfile); if ( ret != BBD_BLOCK_SIZE ) { return NULL; } if (strncmp(oleBuf,ole_sign,8) != 0) { return NULL; } sectorSize = 1<<getshort(oleBuf,0x1e); shortSectorSize=1<<getshort(oleBuf,0x20); /* Read BBD into memory */ bbdNumBlocks = getulong(oleBuf,0x2c); if((BBD=malloc(bbdNumBlocks*sectorSize)) == NULL ) { return NULL; } if((tmpBuf=malloc(MSAT_ORIG_SIZE)) == NULL ) { return NULL; } memcpy(tmpBuf,oleBuf+0x4c,MSAT_ORIG_SIZE); mblock=getlong(oleBuf,0x44); msat_size=getlong(oleBuf,0x48); /* fprintf(stderr, "msat_size=%ld\n", msat_size); */ i=0; while((mblock >= 0) && (i < msat_size)) { unsigned char *newbuf; /* fprintf(stderr, "i=%d mblock=%ld\n", i, mblock); */ if ((newbuf=realloc(tmpBuf, sectorSize*(i+1)+MSAT_ORIG_SIZE)) != NULL) { tmpBuf=newbuf; } else { perror("MSAT realloc error"); free(tmpBuf); ole_finish(); return NULL; } fseek(newfile, 512+mblock*sectorSize, SEEK_SET); if(fread(tmpBuf+MSAT_ORIG_SIZE+(sectorSize-4)*i, 1, sectorSize, newfile) != sectorSize) { fprintf(stderr, "Error read MSAT!\n"); ole_finish(); return NULL; } i++; mblock=getlong(tmpBuf, MSAT_ORIG_SIZE+(sectorSize-4)*i); } /* fprintf(stderr, "bbdNumBlocks=%ld\n", bbdNumBlocks); */ for(i=0; i< bbdNumBlocks; i++) { long int bbdSector=getlong(tmpBuf,4*i); if (bbdSector >= fileLength/sectorSize || bbdSector < 0) { fprintf(stderr, "Bad BBD entry!\n"); ole_finish(); return NULL; } fseek(newfile, 512+bbdSector*sectorSize, SEEK_SET); if ( fread(BBD+i*sectorSize, 1, sectorSize, newfile) != sectorSize ) { fprintf(stderr, "Can't read BBD!\n"); free(tmpBuf); ole_finish(); return NULL; } } free(tmpBuf); /* Read SBD into memory */ sbdLen=0; sbdMaxLen=10; sbdCurrent = sbdStart = getlong(oleBuf,0x3c); if (sbdStart > 0) { if((SBD=malloc(sectorSize*sbdMaxLen)) == NULL ) { ole_finish(); return NULL; } while(1) { fseek(newfile, 512+sbdCurrent*sectorSize, SEEK_SET); fread(SBD+sbdLen*sectorSize, 1, sectorSize, newfile); sbdLen++; if (sbdLen >= sbdMaxLen) { unsigned char *newSBD; sbdMaxLen+=5; if ((newSBD=realloc(SBD, sectorSize*sbdMaxLen)) != NULL) { SBD=newSBD; } else { perror("SBD realloc error"); ole_finish(); return NULL; } } sbdCurrent = getlong(BBD, sbdCurrent*4); if(sbdCurrent < 0 || sbdCurrent >= fileLength/sectorSize) break; } sbdNumber = (sbdLen*sectorSize)/shortSectorSize; /* fprintf(stderr, "sbdLen=%ld sbdNumber=%ld\n",sbdLen, sbdNumber); */ } else { SBD=NULL; } /* Read property catalog into memory */ propLen = 0; propMaxLen = 5; propCurrent = propStart = getlong(oleBuf,0x30); if (propStart >= 0) { if((properties=malloc(propMaxLen*sectorSize)) == NULL ) { ole_finish(); return NULL; } while(1) { /* fprintf(stderr, "propCurrent=%ld\n",propCurrent); */ fseek(newfile, 512+propCurrent*sectorSize, SEEK_SET); fread(properties+propLen*sectorSize, 1, sectorSize, newfile); propLen++; if (propLen >= propMaxLen) { unsigned char *newProp; propMaxLen+=5; if ((newProp=realloc(properties, propMaxLen*sectorSize)) != NULL) properties=newProp; else { perror("Properties realloc error"); ole_finish(); return NULL; } } propCurrent = getlong(BBD, propCurrent*4); if(propCurrent < 0 || propCurrent >= fileLength/sectorSize ) { break; } } /* fprintf(stderr, "propLen=%ld\n",propLen); */ propNumber = (propLen*sectorSize)/PROP_BLOCK_SIZE; propCurNumber = 0; } else { ole_finish(); properties = NULL; return NULL; } /* Find Root Entry */ while((tEntry=(oleEntry*)ole_readdir(newfile)) != NULL) { if (tEntry->type == oleRootDir ) { rootEntry=tEntry; break; } ole_close((FILE*)tEntry); } propCurNumber = 0; fseek(newfile, 0, SEEK_SET); if (!rootEntry) { fprintf(stderr,"Broken OLE structure. Cannot find root entry in this file!\n"); ole_finish(); return NULL; } return newfile; }
/** * Reads next directory entry from file * * @param name buffer for name converted to us-ascii should be at least 33 chars long * @param size size of file * * @return 0 if everything is ok -1 on error */ FILE *ole_readdir(FILE *f) { int i, nLen; unsigned char *oleBuf; oleEntry *e=NULL; long int chainMaxLen, chainCurrent; if ( properties == NULL || propCurNumber >= propNumber || f == NULL ) return NULL; oleBuf=properties + propCurNumber*PROP_BLOCK_SIZE; if( !rightOleType(oleBuf)) return NULL; if ((e = (oleEntry*)malloc(sizeof(oleEntry))) == NULL) { perror("Can\'t allocate memory"); return NULL; } e->dirPos=oleBuf; e->type=getOleType(oleBuf); e->file=f; e->startBlock=getlong(oleBuf,0x74); e->blocks=NULL; nLen=getshort(oleBuf,0x40); for (i=0 ; i < nLen /2; i++) e->name[i]=(char)oleBuf[i*2]; e->name[i]='\0'; propCurNumber++; e->length=getulong(oleBuf,0x78); /* Read sector chain for object */ chainMaxLen = 25; e->numOfBlocks = 0; chainCurrent = e->startBlock; e->isBigBlock = (e->length >= 0x1000) || !strcmp(e->name, "Root Entry"); /* fprintf(stderr, "e->name=%s e->length=%ld\n", e->name, e->length); */ /* fprintf(stderr, "e->startBlock=%ld BBD=%p\n", e->startBlock, BBD); */ if (e->startBlock >= 0 && e->length >= 0 && (e->startBlock <= fileLength/(e->isBigBlock ? sectorSize : shortSectorSize))) { if((e->blocks=malloc(chainMaxLen*sizeof(long int))) == NULL ) { return NULL; } while(1) { /* fprintf(stderr, "chainCurrent=%ld\n", chainCurrent); */ e->blocks[e->numOfBlocks++] = chainCurrent; if (e->numOfBlocks >= chainMaxLen) { long int *newChain; chainMaxLen+=25; if ((newChain=realloc(e->blocks, chainMaxLen*sizeof(long int))) != NULL) e->blocks=newChain; else { perror("Properties realloc error"); free(e->blocks); e->blocks=NULL; return NULL; } } if ( e->isBigBlock ) { chainCurrent = getlong(BBD, chainCurrent*4); } else if ( SBD != NULL ) { chainCurrent = getlong(SBD, chainCurrent*4); } else { chainCurrent=-1; } if(chainCurrent <= 0 || chainCurrent >= ( e->isBigBlock ? ((bbdNumBlocks*sectorSize)/4) : ((sbdNumber*shortSectorSize)/4) ) || (e->numOfBlocks > e->length/(e->isBigBlock ? sectorSize : shortSectorSize))) { /* fprintf(stderr, "chain End=%ld\n", chainCurrent); */ break; } } } if(e->length > (e->isBigBlock ? sectorSize : shortSectorSize)*e->numOfBlocks) e->length = (e->isBigBlock ? sectorSize : shortSectorSize)*e->numOfBlocks; /* fprintf(stderr, "READDIR: e->name=%s e->numOfBlocks=%ld length=%ld\n", */ /* e->name, e->numOfBlocks, e->length); */ return (FILE*)e; }
static unsigned char * cbz_read_zip_entry(cbz_document *doc, int offset, int *sizep) { fz_context *ctx = doc->ctx; fz_stream *file = doc->file; int sig, method, namelength, extralength; unsigned long csize, usize; unsigned char *cdata; int code; fz_seek(file, offset, 0); sig = getlong(doc->file); if (sig != ZIP_LOCAL_FILE_SIG) fz_throw(ctx, "wrong zip local file signature (0x%x)", sig); (void) getshort(doc->file); /* version */ (void) getshort(doc->file); /* general */ method = getshort(doc->file); (void) getshort(doc->file); /* file time */ (void) getshort(doc->file); /* file date */ (void) getlong(doc->file); /* crc-32 */ csize = getlong(doc->file); /* csize */ usize = getlong(doc->file); /* usize */ namelength = getshort(doc->file); extralength = getshort(doc->file); fz_seek(file, namelength + extralength, 1); cdata = fz_malloc(ctx, csize); fz_try(ctx) { fz_read(file, cdata, csize); } fz_catch(ctx) { fz_free(ctx, cdata); fz_rethrow(ctx); } if (method == 0) { *sizep = usize; return cdata; } if (method == 8) { unsigned char *udata = fz_malloc(ctx, usize); z_stream stream; memset(&stream, 0, sizeof stream); stream.zalloc = cbz_zip_alloc_items; stream.zfree = cbz_zip_free; stream.opaque = ctx; stream.next_in = cdata; stream.avail_in = csize; stream.next_out = udata; stream.avail_out = usize; fz_try(ctx) { code = inflateInit2(&stream, -15); if (code != Z_OK) fz_throw(ctx, "zlib inflateInit2 error: %s", stream.msg); code = inflate(&stream, Z_FINISH); if (code != Z_STREAM_END) { inflateEnd(&stream); fz_throw(ctx, "zlib inflate error: %s", stream.msg); } code = inflateEnd(&stream); if (code != Z_OK) fz_throw(ctx, "zlib inflateEnd error: %s", stream.msg); } fz_always(ctx) { fz_free(ctx, cdata); } fz_catch(ctx) { fz_free(ctx, udata); fz_rethrow(ctx); } *sizep = usize; return udata; }
int SpriteCache::initFile(const char *filnam) { short vers; char buff[20]; short numspri = 0; int vv, wdd, htt; long spr_initial_offs = 0; int spriteFileID = 0; for (vv = 0; vv < elements; vv++) { images[vv] = NULL; offsets[vv] = 0; } ff = clibfopen((char *)filnam, "rb"); if (ff == NULL) return -1; spr_initial_offs = ftell(ff); fread(&vers, 2, 1, ff); // read the "Sprite File" signature fread(&buff[0], 13, 1, ff); if ((vers < 4) || (vers > 6)) { fclose(ff); ff = NULL; return -1; } // unknown version buff[13] = 0; if (strcmp(buff, spriteFileSig)) { fclose(ff); ff = NULL; return -1; } if (vers == 4) this->spritesAreCompressed = false; else if (vers == 5) this->spritesAreCompressed = true; else if (vers >= 6) { this->spritesAreCompressed = (fgetc(ff) == 1); spriteFileID = getw(ff); } if (vers < 5) { // skip the palette fseek(ff, 256 * 3, SEEK_CUR); } fread(&numspri, 2, 1, ff); if (vers < 4) numspri = 200; #ifdef THIS_IS_THE_ENGINE // adjust the buffers to the sprite file size changeMaxSize(numspri + 1); #endif // if there is a sprite index file, use it if (loadSpriteIndexFile(spriteFileID, spr_initial_offs, numspri)) { // Succeeded return 0; } // failed, delete the index file because it's invalid unlink(spindexfilename); // no sprite index file, manually index it for (vv = 0; vv <= numspri; vv++) { offsets[vv] = ftell(ff); flags[vv] = 0; int coldep = getshort(ff); if (coldep == 0) { offsets[vv] = 0; images[vv] = NULL; #ifdef THIS_IS_THE_ENGINE // make it a blue cup, to avoid crashes spritewidth[vv] = spritewidth[0]; spriteheight[vv] = spriteheight[0]; offsets[vv] = offsets[0]; flags[vv] = SPRCACHEFLAG_DOESNOTEXIST; #else // no sprite ... blank it out spritewidth[vv] = 0; spriteheight[vv] = 0; offsets[vv] = 0; #endif if (feof(ff)) break; continue; } if (feof(ff)) break; if (vv >= elements) break; images[vv] = NULL; wdd = getshort(ff); htt = getshort(ff); spritewidth[vv] = wdd; spriteheight[vv] = htt; get_new_size_for_sprite(vv, wdd, htt, spritewidth[vv], spriteheight[vv]); long spriteDataSize; if (vers == 5) { spriteDataSize = getw(ff); } else { spriteDataSize = wdd * coldep * htt; } fseek(ff, spriteDataSize, SEEK_CUR); } sprite0InitialOffset = offsets[0]; return 0; }
int SpriteCache::saveToFile(const char *filnam, int lastElement, bool compressOutput) { FILE *output = fopen(filnam, "wb"); if (output == NULL) return -1; if (compressOutput) { // re-open the file so that it can be seeked fclose(output); output = fopen(filnam, "r+b"); if (output == NULL) return -1; } int spriteFileIDCheck = (int)time(NULL); // version 6 putshort(6, output); fwrite(spriteFileSig, strlen(spriteFileSig), 1, output); fputc(compressOutput ? 1 : 0, output); putw(spriteFileIDCheck, output); int i, lastslot = 0; if (elements < lastElement) lastElement = elements; for (i = 1; i < lastElement; i++) { // slot empty if ((images[i] != NULL) || ((offsets[i] != 0) && (offsets[i] != sprite0InitialOffset))) lastslot = i; } putshort(lastslot, output); // allocate buffers to store the indexing info int numsprits = lastslot + 1; short *spritewidths = (short*)malloc(numsprits * sizeof(short)); short *spriteheights = (short*)malloc(numsprits * sizeof(short)); long *spriteoffs = (long*)malloc(numsprits * sizeof(long)); const int memBufferSize = 100000; char *memBuffer = (char*)malloc(memBufferSize); for (i = 0; i <= lastslot; i++) { spriteoffs[i] = ftell(output); // if compressing uncompressed sprites, load the sprite into memory if ((images[i] == NULL) && (this->spritesAreCompressed != compressOutput)) (*this)[i]; if (images[i] != NULL) { // image in memory -- write it out pre_save_sprite(i); int bpss = bitmap_color_depth(images[i]) / 8; spritewidths[i] = images[i]->w; spriteheights[i] = images[i]->h; putshort(bpss, output); putshort(spritewidths[i], output); putshort(spriteheights[i], output); if (compressOutput) { long lenloc = ftell(output); // write some space for the length data putw(0, output); compressSprite(images[i], output); long fileSizeSoFar = ftell(output); // write the length of the compressed data fseek(output, lenloc, SEEK_SET); putw((fileSizeSoFar - lenloc) - 4, output); fseek(output, 0, SEEK_END); } else fwrite(&images[i]->line[0][0], spritewidths[i] * bpss, spriteheights[i], output); continue; } if ((offsets[i] == 0) || ((offsets[i] == sprite0InitialOffset) && (i > 0))) { // sprite doesn't exist putshort(0, output); spritewidths[i] = 0; spriteheights[i] = 0; spriteoffs[i] = 0; continue; } // not in memory -- seek to it in the source file seekToSprite(i); lastLoad = i; short colDepth = getshort(ff); putshort(colDepth, output); if (colDepth == 0) { continue; } if (this->spritesAreCompressed != compressOutput) { // shouldn't be able to get here free(memBuffer); fclose(output); return -2; } // and copy the data across int width = getshort(ff); int height = getshort(ff); spritewidths[i] = width; spriteheights[i] = height; putshort(width, output); putshort(height, output); int sizeToCopy; if (this->spritesAreCompressed) { sizeToCopy = getw(ff); putw(sizeToCopy, output); } else { sizeToCopy = width * height * (int)colDepth; } while (sizeToCopy > memBufferSize) { fread(memBuffer, memBufferSize, 1, ff); fwrite(memBuffer, memBufferSize, 1, output); sizeToCopy -= memBufferSize; } fread(memBuffer, sizeToCopy, 1, ff); fwrite(memBuffer, sizeToCopy, 1, output); } free(memBuffer); fclose(output); // write the sprite index file FILE *ooo = fopen(spindexfilename, "wb"); // write "SPRINDEX" id fwrite(&spindexid[0], strlen(spindexid), 1, ooo); // write version (1) putw(2, ooo); putw(spriteFileIDCheck, ooo); // write last sprite number and num sprites, to verify that // it matches the spr file putw(lastslot, ooo); putw(numsprits, ooo); fwrite(&spritewidths[0], sizeof(short), numsprits, ooo); fwrite(&spriteheights[0], sizeof(short), numsprits, ooo); fwrite(&spriteoffs[0], sizeof(long), numsprits, ooo); fclose(ooo); free(spritewidths); free(spriteheights); free(spriteoffs); return 0; }
int SpriteCache::loadSprite(int index) { int hh = 0; while (cachesize > maxCacheSize) { removeOldest(); hh++; if (hh > 1000) { write_log("!!!! RUNTIME CACHE ERROR: STUCK IN FREE_UP_MEM; RESETTING CACHE"); removeAll(); } } if ((index < 0) || (index >= elements)) quit("sprite cache array index out of bounds"); // If we didn't just load the previous sprite, seek to it seekToSprite(index); int coldep = getshort(ff); if (coldep == 0) { lastLoad = index; return 0; } int wdd = getshort(ff); int htt = getshort(ff); // update the stored width/height spritewidth[index] = wdd; spriteheight[index] = htt; images[index] = create_bitmap_ex(coldep * 8, wdd, htt); if (images[index] == NULL) { offsets[index] = 0; return 0; } if (this->spritesAreCompressed) { getw(ff); // skip data size if (coldep == 1) { for (hh = 0; hh < htt; hh++) cunpackbitl(&images[index]->line[hh][0], wdd, ff); } else if (coldep == 2) { for (hh = 0; hh < htt; hh++) cunpackbitl16((unsigned short*)&images[index]->line[hh][0], wdd, ff); } else { for (hh = 0; hh < htt; hh++) cunpackbitl32((unsigned long*)&images[index]->line[hh][0], wdd, ff); } } else { for (hh = 0; hh < htt; hh++) // MACPORT FIX: size and nmemb split fread(&images[index]->line[hh][0], coldep, wdd, ff); } lastLoad = index; // Stop it adding the sprite to the used list just because it's loaded long offs = offsets[index]; offsets[index] = SPRITE_LOCKED; initialize_sprite(index); if (index != 0) // leave sprite 0 locked offsets[index] = offs; // we need to store this because the main program might // alter spritewidth/height if it resizes stuff sizes[index] = spritewidth[index] * spriteheight[index] * coldep; cachesize += sizes[index]; #ifdef DEBUG_SPRITECACHE char msgg[100]; sprintf(msgg, "Loaded %d, size now %d KB", index, cachesize / 1024); write_log(msgg); #endif return sizes[index]; }
void get_sizes() { short i,j; short value; short min_landscape_class; short max_landscape_class; char *class_exists; char *all_classes; int *npts; int numpts; int *npatches; int MAX_BCKGRND_SIZE; /* * Get space for 3 arrays needed to determine NUM_CLASSES, the classes * that exist, and the maximum number of patches per class. * (MAX_CLASSES is set in the routines that read in the input image.) */ class_exists = (char *) calloc ((unsigned)MAX_CLASSES,sizeof(char)); if (class_exists == NULL) { Rprintf ("\nERROR! Can not allocate space for class_exists!"); return; } all_classes = (char *) calloc ((unsigned)MAX_CLASSES,sizeof(char)); if (all_classes == NULL) { Rprintf ("\nERROR! Can not allocate space for all_classes"); return; } npatches = (int *) calloc ((unsigned)MAX_CLASSES,sizeof(int)); if (npatches == NULL) { Rprintf ("\nERROR! Can not allocate space for npatches"); return; } npts = (int *) calloc ((unsigned)MAX_CLASSES,sizeof(int)); if (npts == NULL) { Rprintf ("\nERROR! Can not allocate space for npts"); return; } /* * Initialize */ for (i=0; i < MAX_CLASSES; i++) { class_exists[i] = FALSE; all_classes[i] = FALSE; npatches[i] = 0; } MAX_PATCH_SIZE = 0; MAX_BCKGRND_SIZE = 0; /* * Step through all cells in the image. */ for (i=0; i < num_rows; i++) { for (j=0; j < num_cols; j++) { value = getshort(image,num_cols,i,j); /* * Flag all classes that exist (must have values >= 0). */ if (value >= 0) { class_exists[value] = TRUE; all_classes[value] = TRUE; } /* * Flag any classes in the landscape border that exist (values < 0 * but not background). This is needed to compute total_num_classes * used in contagion. */ if (value < 0 && value > -990 && value != -777) all_classes[-value] = TRUE; /* * Find every patch in the landscape. Keep track of the largest * patch (# cells) and the number of patches per class. */ if (value >= 0) { numpts = patch_size(j,i,value); npts[value] += numpts; if (numpts > MAX_PATCH_SIZE) MAX_PATCH_SIZE = numpts; npatches[value] ++; } /* * 9-15-94 BJM Changing so that it checks patch size for patches * in the landscape border as well as background patches. */ else if (value < 0 && value != -777 ) { numpts = patch_size (j,i,value); if (numpts > MAX_BCKGRND_SIZE) MAX_BCKGRND_SIZE = numpts; } } } /* * Now find the class that has the greatest number of patches and * save the number of patches. This is needed to dimension arrays * that hold patch level indices. Also find the total number of * patches in the landscape, the number of classes that exist, and * the total number of classes that exist (including any classes * in the landscape border). */ Rprintf ("\n"); for(i=0; i < MAX_CLASSES; i++) if (class_exists[i]) Rprintf ("\nClass %5d: %9d cells, %8d patches", i,npts[i],npatches[i]); Rprintf ("\n"); MAX_PATCHES = 0; NUM_CLASSES = total_num_classes = total_num_patches = 0; min_landscape_class = 999; max_landscape_class = -999; for (i=0; i < MAX_CLASSES; i++) { if (npatches[i] > MAX_PATCHES) MAX_PATCHES = npatches[i]; total_num_patches += npatches[i]; if (class_exists[i]) NUM_CLASSES ++; if (all_classes[i]) { total_num_classes ++; if (i < min_landscape_class) min_landscape_class = i; if (i > max_landscape_class) max_landscape_class = i; } } /* * Allocate space for an array that will hold the values of the * patch types (classes) that exist in the landscape. */ patchtype = (short *) calloc ((unsigned)NUM_CLASSES,sizeof(short)); if (patchtype == NULL) { Rprintf ("\nERROR! Can not allocate space for patchtype!"); return; } j = 0; for (i=0; i < MAX_CLASSES; i++) { if (class_exists[i]) { patchtype[j] = i; j++; } } Rprintf ("\nnumber of classes: %d",NUM_CLASSES); Rprintf ("\nmax patches/class: %d",MAX_PATCHES); if (MAX_BCKGRND_SIZE > MAX_PATCH_SIZE) { Rprintf ("\nmax_patch_size: %d (background/border patch)",MAX_BCKGRND_SIZE); MAX_PATCH_SIZE = MAX_BCKGRND_SIZE; } else Rprintf ("\nmax patch size: %d\n",MAX_PATCH_SIZE); /* * If a user did not specify a weight file for contrast indices, * set the min and max weight value to the min and max class * value in the landscape (includes patchtypes in the landscape border). * These are needed to index the "edge" array. */ if (!contrast_indices) { min_wt = min_landscape_class; max_wt = max_landscape_class; num_wt = max_landscape_class - min_landscape_class + 1; } free (npatches); free (all_classes); free (class_exists); free (npts); return; }
/* * cvt_trimtsip * * convert TSIP type format */ static unsigned long cvt_trimtsip( unsigned char *buffer, int size, struct format *format, clocktime_t *clock_time, void *local ) { register struct trimble *t = (struct trimble *)local; /* get local data space */ #define mb(_X_) (buffer[2+(_X_)]) /* shortcut for buffer access */ register u_char cmd; clock_time->flags = 0; if (!t) { return CVT_NONE; /* local data not allocated - sigh! */ } if ((size < 4) || (buffer[0] != DLE) || (buffer[size-1] != ETX) || (buffer[size-2] != DLE)) { printf("TRIMBLE BAD packet, size %d:\n", size); return CVT_NONE; } else { unsigned char *bp; cmd = buffer[1]; switch(cmd) { case CMD_RCURTIME: { /* GPS time */ l_fp secs; int week = getshort((unsigned char *)&mb(4)); l_fp utcoffset; l_fp gpstime; bp = &mb(0); if (fetch_ieee754(&bp, IEEE_SINGLE, &secs, trim_offsets) != IEEE_OK) return CVT_FAIL|CVT_BADFMT; if ((secs.l_i <= 0) || (t->t_utcknown == 0)) { clock_time->flags = PARSEB_POWERUP; return CVT_OK; } if (week < GPSWRAP) { week += GPSWEEKS; } /* time OK */ /* fetch UTC offset */ bp = &mb(6); if (fetch_ieee754(&bp, IEEE_SINGLE, &utcoffset, trim_offsets) != IEEE_OK) return CVT_FAIL|CVT_BADFMT; L_SUB(&secs, &utcoffset); /* adjust GPS time to UTC time */ gpstolfp((unsigned short)week, (unsigned short)0, secs.l_ui, &gpstime); gpstime.l_uf = secs.l_uf; clock_time->utctime = gpstime.l_ui - JAN_1970; TSFTOTVU(gpstime.l_uf, clock_time->usecond); if (t->t_leap == ADDSECOND) clock_time->flags |= PARSEB_LEAPADD; if (t->t_leap == DELSECOND) clock_time->flags |= PARSEB_LEAPDEL; switch (t->t_operable) { case STATUS_SYNC: clock_time->flags &= ~(PARSEB_POWERUP|PARSEB_NOSYNC); break; case STATUS_UNSAFE: clock_time->flags |= PARSEB_NOSYNC; break; case STATUS_BAD: clock_time->flags |= PARSEB_NOSYNC|PARSEB_POWERUP; break; } if (t->t_mode == 0) clock_time->flags |= PARSEB_POSITION; clock_time->flags |= PARSEB_S_LEAP|PARSEB_S_POSITION; return CVT_OK; } /* case 0x41 */ case CMD_RRECVHEALTH: { /* TRIMBLE health */ u_char status = mb(0); switch (status) { case 0x00: /* position fixes */ t->t_operable = STATUS_SYNC; break; case 0x09: /* 1 satellite */ case 0x0A: /* 2 satellites */ case 0x0B: /* 3 satellites */ t->t_operable = STATUS_UNSAFE; break; default: t->t_operable = STATUS_BAD; break; } t->t_mode = status; } break; case CMD_RUTCPARAM: { l_fp t0t; unsigned char *lbp; /* UTC correction data - derive a leap warning */ int tls = t->t_gpsutc = (u_short) getshort((unsigned char *)&mb(12)); /* current leap correction (GPS-UTC) */ int tlsf = t->t_gpsutcleap = (u_short) getshort((unsigned char *)&mb(24)); /* new leap correction */ t->t_weekleap = (u_short) getshort((unsigned char *)&mb(20)); /* week no of leap correction */ if (t->t_weekleap < GPSWRAP) t->t_weekleap = (u_short)(t->t_weekleap + GPSWEEKS); t->t_dayleap = (u_short) getshort((unsigned char *)&mb(22)); /* day in week of leap correction */ t->t_week = (u_short) getshort((unsigned char *)&mb(18)); /* current week no */ if (t->t_week < GPSWRAP) t->t_week = (u_short)(t->t_weekleap + GPSWEEKS); lbp = (unsigned char *)&mb(14); /* last update time */ if (fetch_ieee754(&lbp, IEEE_SINGLE, &t0t, trim_offsets) != IEEE_OK) return CVT_FAIL|CVT_BADFMT; t->t_utcknown = t0t.l_ui != 0; if ((t->t_utcknown) && /* got UTC information */ (tlsf != tls) && /* something will change */ ((t->t_weekleap - t->t_week) < 5)) /* and close in the future */ { /* generate a leap warning */ if (tlsf > tls) t->t_leap = ADDSECOND; else t->t_leap = DELSECOND; } else { t->t_leap = 0; } } break; default: /* it's validly formed, but we don't care about it! */ break; } } return CVT_SKIP; }
static int xps_read_zip_entry(xps_context *ctx, xps_entry *ent, unsigned char *outbuf) { z_stream stream; unsigned char *inbuf; int sig; int version, general, method; int namelength, extralength; int code; fz_seek(ctx->file, ent->offset, 0); sig = getlong(ctx->file); if (sig != ZIP_LOCAL_FILE_SIG) return fz_error_make(ctx->ctx, "wrong zip local file signature (0x%x)", sig); version = getshort(ctx->file); general = getshort(ctx->file); method = getshort(ctx->file); (void) getshort(ctx->file); /* file time */ (void) getshort(ctx->file); /* file date */ (void) getlong(ctx->file); /* crc-32 */ (void) getlong(ctx->file); /* csize */ (void) getlong(ctx->file); /* usize */ namelength = getshort(ctx->file); extralength = getshort(ctx->file); fz_seek(ctx->file, namelength + extralength, 1); if (method == 0) { fz_read(ctx->file, outbuf, ent->usize); } else if (method == 8) { inbuf = fz_malloc(ctx->ctx, ent->csize); fz_read(ctx->file, inbuf, ent->csize); memset(&stream, 0, sizeof(z_stream)); stream.zalloc = (alloc_func) xps_zip_alloc_items; stream.zfree = (free_func) xps_zip_free; stream.opaque = ctx; stream.next_in = inbuf; stream.avail_in = ent->csize; stream.next_out = outbuf; stream.avail_out = ent->usize; code = inflateInit2(&stream, -15); if (code != Z_OK) return fz_error_make(ctx->ctx, "zlib inflateInit2 error: %s", stream.msg); code = inflate(&stream, Z_FINISH); if (code != Z_STREAM_END) { inflateEnd(&stream); return fz_error_make(ctx->ctx, "zlib inflate error: %s", stream.msg); } code = inflateEnd(&stream); if (code != Z_OK) return fz_error_make(ctx->ctx, "zlib inflateEnd error: %s", stream.msg); fz_free(ctx->ctx, inbuf); } else { return fz_error_make(ctx->ctx, "unknown compression method (%d)", method); } return fz_okay; }
GImage * GImageReadRgb (char *filename) { FILE *fp = fopen (filename, "rb"); struct sgiheader header; int j, i; unsigned char *pt, *end; unsigned long *ipt, *iend; GImage *ret; struct _GImage *base; if (fp == NULL) return (NULL); getsgiheader (&header, fp); if (header.magic != SGI_MAGIC || (header.format != VERBATIM && header.format != RLE) || (header.bpc != 1 && header.bpc != 2) || header.dim < 1 || header.dim > 3 || header.pixmax > 65535 || (header.pixmax > 255 && header.bpc == 1) || (header.chans != 1 && header.chans != 3 && header.chans != 4) || header.pixmax < 0 || header.pixmin < 0 || header.pixmin > header.pixmax || header.colormap != 0) { fclose (fp); return (NULL); } ret = GImageCreate (header.dim == 3 ? it_true : it_index, header.width, header.height); base = ret->u.image; if (header.format == RLE) { unsigned long *starttab /*, *lengthtab */ ; unsigned char **ptrtab; long tablen; tablen = header.height * header.chans; starttab = (unsigned long *) xmalloc (szmax (1, tablen * sizeof (long))); /*lengthtab = (unsigned long *)xmalloc(szmax(1, tablen*sizeof(long))); */ ptrtab = (unsigned char **) xmalloc (szmax (1, tablen * sizeof (unsigned char *))); readlongtab (fp, starttab, tablen); /*readlongtab(fp,lengthtab,tablen); */ for (i = 0; i < tablen; ++i) find_scanline (fp, &header, i, starttab, ptrtab); if (header.chans == 1) { for (i = 0; i < header.height; ++i) memcpy (base->data + (header.height - 1 - i) * base->bytes_per_line, ptrtab[i], header.width); } else { unsigned long *ipt; for (i = 0; i < header.height; ++i) { ipt = (unsigned long *) (base->data + (header.height - 1 - i) * base->bytes_per_line); for (j = 0; j < header.width; ++j) *ipt++ = COLOR_CREATE (ptrtab[i][j], ptrtab[i + header.height][j], ptrtab[i + 2 * header.height][j]); } } freeptrtab (ptrtab, tablen); free (ptrtab); free (starttab); /*free(lengthtab); */ } else { if (header.chans == 1 && header.bpc == 1) { for (i = 0; i < header.height; ++i) { fread (base->data + (header.height - 1 - i) * base->bytes_per_line, header.width, 1, fp); if (header.pixmax != 255) { pt = (unsigned char *) (base->data + (header.height - 1 - i) * base->bytes_per_line); for (end = pt + header.width; pt < end; ++pt) *pt = (*pt * 255) / header.pixmax; } } } else if (header.chans == 1) { for (i = 0; i < header.height; ++i) { pt = (unsigned char *) (base->data + (header.height - 1 - i) * base->bytes_per_line); for (end = pt + header.width; pt < end;) *pt++ = (getshort (fp) * 255L) / header.pixmax; } } else if (header.bpc == 1) { unsigned char *r, *g, *b, *a = NULL; unsigned char *rpt, *gpt, *bpt; r = (unsigned char *) xmalloc (header.width); g = (unsigned char *) xmalloc (header.width); b = (unsigned char *) xmalloc (header.width); if (header.chans == 4) a = (unsigned char *) xmalloc (header.width); for (i = 0; i < header.height; ++i) { fread (r, header.width, 1, fp); fread (g, header.width, 1, fp); fread (b, header.width, 1, fp); if (header.chans == 4) fread (a, header.width, 1, fp); ipt = (unsigned long *) (base->data + (header.height - 1 - i) * base->bytes_per_line); rpt = r; gpt = g; bpt = b; for (iend = ipt + header.width; ipt < iend;) *ipt++ = COLOR_CREATE (*rpt++ * 255L / header.pixmax, *gpt++ * 255L / header.pixmax, *bpt++ * 255L / header.pixmax); } free (r); free (g); free (b); free (a); } else { unsigned char *r, *g, *b, *a = NULL; unsigned char *rpt, *gpt, *bpt; r = (unsigned char *) xmalloc (header.width); g = (unsigned char *) xmalloc (header.width); b = (unsigned char *) xmalloc (header.width); if (header.chans == 4) a = (unsigned char *) xmalloc (header.width); for (i = 0; i < header.height; ++i) { for (j = 0; j < header.width; ++j) r[j] = getshort (fp) * 255L / header.pixmax; for (j = 0; j < header.width; ++j) g[j] = getshort (fp) * 255L / header.pixmax; for (j = 0; j < header.width; ++j) b[j] = getshort (fp) * 255L / header.pixmax; if (header.chans == 4) { fread (a, header.width, 1, fp); fread (a, header.width, 1, fp); } ipt = (unsigned long *) (base->data + (header.height - 1 - i) * base->bytes_per_line); rpt = r; gpt = g; bpt = b; for (iend = ipt + header.width; ipt < iend;) *ipt++ = COLOR_CREATE (*rpt++, *gpt++, *bpt++); } free (r); free (g); free (b); free (a); } } return (ret); }
/* we always return a null-terminated string which has been malloc'ed. The string * is always in the tag=value form. If a temporary or permanent error occurs, * the string will be exactly "e=perm;" or "e=temp;". * Note that it never returns NULL. */ char *dns_text(char *dn) { // added by nhatier for compilation under MSVC #ifdef _MSC_VER DNS_RECORD * l_Records = NULL; DNS_STATUS l_Result = DnsQuery(dn, DNS_TYPE_TEXT, DNS_QUERY_STANDARD, NULL, &l_Records, NULL); if (l_Result == ERROR_SUCCESS) { if (l_Records->wType == DNS_TYPE_TEXT) { unsigned int i; char buf[4096]; buf[0] = 0; for (i = 0; i < l_Records->Data.TXT.dwStringCount; i++) { strcat(buf, l_Records->Data.TXT.pStringArray[i]); } DnsRecordListFree(l_Records, DnsFreeRecordList); return dk_strdup(buf); } else { DnsRecordListFree(l_Records, DnsFreeRecordList); return dk_strdup("e=perm;"); } } else if (l_Result == DNS_ERROR_RECORD_TIMED_OUT) { DnsRecordListFree(l_Records, DnsFreeRecordList); return dk_strdup("e=temp;"); } else { DnsRecordListFree(l_Records, DnsFreeRecordList); return dk_strdup("e=perm;"); } #else //end added by nhatier u_char response[PACKETSZ+1]; /* response */ int responselen; /* buffer length */ int i, rc; /* misc variables */ int ancount, qdcount; /* answer count and query count */ u_short type, rdlength; /* fields of records returned */ u_char *eom, *cp; u_char buf[PACKETSZ+1]; /* we're storing a TXT record here, not just a DNAME */ u_char *bufptr; responselen = res_query(dn, C_IN, T_TXT, response, sizeof(response)); if (responselen < 0){ if (h_errno == TRY_AGAIN) return dk_strdup("e=temp;"); else return dk_strdup("e=perm;"); } qdcount = getshort( response + 4); /* http://crynwr.com/rfc1035/rfc1035.html#4.1.1. */ ancount = getshort( response + 6); eom = response + responselen; cp = response + HFIXEDSZ; while( qdcount-- > 0 && cp < eom ) { rc = dn_expand( response, eom, cp, (char *)buf, MAXDNAME ); if( rc < 0 ) { return dk_strdup("e=perm;"); } cp += rc + QFIXEDSZ; } while( ancount-- > 0 && cp < eom ) { rc = dn_expand( response, eom, cp, (char *)buf, MAXDNAME ); if( rc < 0 ) { return dk_strdup("e=perm;"); } cp += rc; if (cp + RRFIXEDSZ >= eom) return dk_strdup("e=perm;"); type = getshort(cp + 0); /* http://crynwr.com/rfc1035/rfc1035.html#4.1.3. */ rdlength = getshort(cp + 8); cp += RRFIXEDSZ; if( type != T_TXT ) { cp += rdlength; continue; } bufptr = buf; while (rdlength && cp < eom) { int cnt; cnt = *cp++; /* http://crynwr.com/rfc1035/rfc1035.html#3.3.14. */ if( bufptr-buf + cnt + 1 >= PACKETSZ ) return dk_strdup("e=perm;"); if (cp + cnt > eom) return dk_strdup("e=perm;"); memcpy( bufptr, cp, cnt); rdlength -= cnt + 1; bufptr += cnt; cp += cnt; *bufptr = '\0'; } return (char *) dk_strdup( buf ); } return dk_strdup("e=perm;"); #endif }