static struct font* font_load_header(struct font *pf) { /* Check we have enough data */ if (!HAVEBYTES(28)) return NULL; /* read magic and version #*/ if (memcmp(pf->buffer_position, VERSION, 4) != 0) return NULL; pf->buffer_position += 4; /* font info*/ pf->maxwidth = readshort(pf); pf->height = readshort(pf); pf->ascent = readshort(pf); pf->buffer_position += 2; /* Skip padding */ pf->firstchar = readlong(pf); pf->defaultchar = readlong(pf); pf->size = readlong(pf); /* get variable font data sizes*/ /* # words of bitmap_t*/ pf->bits_size = readlong(pf); return pf; }
void conv1213() { long nper, i; long *buf; long kk = 0, f1, f2; MESSAGE(0,("Permutation on %d points\n",nor)); buf = NALLOC(long,nor); if (buf == NULL) { MTX_ERROR("Cannot allocate permutation: %S"); return; } WriteHeader(-fl,nor,noc); for (nper = noc; nper != 0; --nper) { for (i = 0; i < nor; ++i) { switch (mod) { case 12: kk = readlong(); break; case 13: f1 = readlong(); f2 = readlong(); kk = (f1 - 1) * fl + f2 + 1; break; } buf[i] = kk; } if (SysWriteLong(out,buf,nor) != nor) { MTX_ERROR1("Cannot write %s: %S",outname); } } }
/* Load cached font */ static struct font* font_load_cached(struct font* pf) { uint32_t noffset, nwidth; unsigned char* oldfileptr = pf->buffer_position; if (!HAVEBYTES(2 * sizeof(int32_t))) return NULL; /* # longs of offset*/ noffset = readlong(pf); /* # bytes of width*/ nwidth = readlong(pf); /* We are now at the bitmap data, this is fixed at 36.. */ pf->bits = NULL; /* Calculate offset to offset data */ pf->buffer_position += pf->bits_size * sizeof(unsigned char); if (pf->bits_size < MAX_FONTSIZE_FOR_16_BIT_OFFSETS) { pf->long_offset = 0; /* pad to 16-bit boundary */ pf->buffer_position = (unsigned char *)(((intptr_t)pf->buffer_position + 1) & ~1); } else { pf->long_offset = 1; /* pad to 32-bit boundary*/ pf->buffer_position = (unsigned char *)(((intptr_t)pf->buffer_position + 3) & ~3); } if (noffset) pf->file_offset_offset = (uint32_t)(pf->buffer_position - pf->buffer_start); else pf->file_offset_offset = 0; /* Calculate offset to widths data */ if (pf->bits_size < MAX_FONTSIZE_FOR_16_BIT_OFFSETS) pf->buffer_position += noffset * sizeof(uint16_t); else pf->buffer_position += noffset * sizeof(uint32_t); if (nwidth) pf->file_width_offset = (uint32_t)(pf->buffer_position - pf->buffer_start); else pf->file_width_offset = 0; pf->buffer_position = oldfileptr; /* Create the cache */ cache_create(pf, pf->maxwidth, pf->height); return pf; }
void obj_ReadRGB1(FILE * pObjfile) { struct sSection *pFirstSection; SLONG nNumberOfSymbols, nNumberOfSections, i; nNumberOfSymbols = readlong(pObjfile); nNumberOfSections = readlong(pObjfile); /* First comes the symbols */ if (nNumberOfSymbols) { tSymbols = malloc(nNumberOfSymbols * sizeof *tSymbols); if (!tSymbols) { err(1, NULL); } for (i = 0; i < nNumberOfSymbols; i += 1) tSymbols[i] = obj_ReadSymbol(pObjfile); } else tSymbols = (struct sSymbol **) & dummymem; /* Next we have the sections */ pFirstSection = NULL; while (nNumberOfSections--) { struct sSection *pNewSection; pNewSection = obj_ReadRGB1Section(pObjfile); pNewSection->nNumberOfSymbols = nNumberOfSymbols; if (pFirstSection == NULL) pFirstSection = pNewSection; } /* * Fill in the pSection entry in the symbolstructure. * This REALLY needs some cleaning up... but, hey, it works * */ for (i = 0; i < nNumberOfSymbols; i += 1) { struct sSection *pConvSect = pFirstSection; if (tSymbols[i]->Type != SYM_IMPORT && tSymbols[i]->nSectionID != -1) { SLONG j = 0; while (j != tSymbols[i]->nSectionID) { j += 1; pConvSect = pConvSect->pNext; } tSymbols[i]->pSection = pConvSect; } else tSymbols[i]->pSection = NULL; } }
static void bit_savi2c_setsda(void *data, int val) { unsigned int r; r = readlong(); if(val) r |= I2C_SDA_OUT; else r &= ~I2C_SDA_OUT; outlong(r); readlong(); /* flush posted write */ }
static void ConvertPermutation() { long i; long *buf; long kk; MESSAGE(0,("Permutation on %d points\n",nor)); buf = NALLOC(long,nor); if (buf == NULL) { MTX_ERROR("Cannot allocate permutation: %S"); } WriteHeader(-1,nor,1); for (i = 0; i < nor; ++i) { kk = readlong(); buf[i] = kk - 1; if ((kk < 1) || (kk > nor)) { MTX_ERROR3("%s: Invalid point %d in permutation of degree %d", inpname,(int)kk,nor); } } if (SysWriteLong(out,buf,nor) != nor) { MTX_ERROR1("Cannot write to %s",outname); } }
static long readfile(int sock,FILE *f) { int partition_id; if (!sendLong(sock, partition_id)) return kReadFileFailure; long filesize; if (!readlong(sock, &filesize)) return kReadFileFailure; if (filesize > 0) { char buffer[1024]; do { int num = min(filesize, sizeof(buffer)); if (!readdata(sock, buffer, num)) return kReadFileFailure; int offset = 0; do { size_t written = fwrite(&buffer[offset], 1, num-offset, f); if (written < 1) return kReadFileFailure; offset += written; } while (offset < num); filesize -= num; } while (filesize > 0); } return partition_id; }
END_TEST START_TEST(test_read_putlong) { uint32_t k; uint32_t l; char* p; int i; int j; for (i = 0; i < 32; i++) { p = (char*)&k; j = 0xf << i; putlong(&p, j); fail_unless(ntohl(k) == j, "Bad value on putlong for %d: %d != %d", i, ntohl(j), j); p = (char*)&k; readlong(NULL, &p, &l); fail_unless(l == j, "Bad value on readlong for %d: %d != %d", i, l, j); } }
void readMidiFileHeader(FILE *fp, struct mhead *h) { fread(h->chunktype, sizeof h->chunktype, 1, fp); h->length = readlong(fp); h->format = readshort(fp); h->ntrks = readshort(fp); h->division = readshort(fp); }
struct sSymbol * obj_ReadSymbol(FILE * f) { char s[256]; struct sSymbol *pSym; pSym = malloc(sizeof *pSym); if (!pSym) { err(1, NULL); } readasciiz(s, f); pSym->pzName = malloc(strlen(s) + 1); if (!pSym->pzName) { err(1, NULL); } strcpy(pSym->pzName, s); if ((pSym->Type = (enum eSymbolType) fgetc(f)) != SYM_IMPORT) { pSym->nSectionID = readlong(f); pSym->nOffset = readlong(f); } return pSym; }
static void ConvertIntMatrix() { long i, j; long *x; MESSAGE(0,("%dx%d integer matrix\n",nor,noc)); x = NALLOC(long,noc); WriteHeader(-8,nor,noc); /* 8 = T_IMAT */ for (i = 1; i <= nor; ++i) { for (j = 0; j < noc; ++j) { x[j] = readlong(); } SysWriteLong(out,x,noc); } free(x); }
static void ConvertPolynomial() { long i; Poly_t *p; MESSAGE(0,("Polynomial of degree %d over GF(%d)\n",nor,fl)); FfSetNoc(fl); p = PolAlloc(fl,nor); if ((out = SysFopen(outname,FM_CREATE)) == NULL) { MTX_ERROR1("Cannot open %s: %S",outname); } for (i = 0; i <= nor; ++i) { long kk = readlong(); p->Data[i] = FfFromInt(kk); } PolWrite(p,out); }
void convperm() { long i, val; PTR m1; MESSAGE(0,("%dx%d permutation matrix over GF(%d)\n",nor,noc,fl)); FfSetField(fl); FfSetNoc(noc); m1 = FfAlloc((long)1); WriteHeader(fl,nor,noc); for (i = 1; i <= nor; ++i) { val = readlong(); FfMulRow(m1,FF_ZERO); FfInsert(m1,val - 1,FF_ONE); FfWriteRows(out,m1,1); } }
int main() { int n; n=readlong(); int i,j; for(i=2; i<=100; i++) { number[0][i]=0; } for(i=1; i<=n; i++) { int a; a=readlong(); for(j=1; j<=100; j++) number[i][j]=number[i-1][j]; number[i][a]++; } int t; t=readlong(); int l,r; long long MOD; while(t--) { l=readlong(); r=readlong(); MOD=readlong(); long long ans=1; if(MOD==1) printf("%d\n",0); else { for(i=1; i<=100; i++) { if(number[r][i]-number[l-1][i]) { ans=ans*p(i,number[r][i]-number[l-1][i],MOD); ans=ans%MOD; } } writeInt(ans); } } return 0; }
void lib_ReadXLB0(FILE * f) { SLONG size; size = file_Length(f) - 4; while (size) { char name[256]; size -= readasciiz(name, f); readword(f); size -= 2; readword(f); size -= 2; size -= readlong(f); size -= 4; obj_ReadOpenFile(f, name); } }
static void ConvertMatrix() { long i, j; PTR m1; long val; MESSAGE(0,("%dx%d matrix over GF(%d)\n",nor,noc,fl)); FfSetField(fl); FfSetNoc(noc); m1 = FfAlloc((long)1); WriteHeader(fl,nor,noc); for (i = 1; i <= nor; ++i) { FfMulRow(m1,FF_ZERO); for (j = 0; j < noc; ++j) { val = readlong(); FfInsert(m1,j,FfFromInt(val)); } FfWriteRows(out,m1,1); } }
int main() { generate_hashmap(); int n; n=readlong(); int i,j; for(i=0;i<25;i++) { number[0][i]=0; } for(i=1;i<=n;i++) { int a; a=readlong(); for(j=0;j<25;j++) number[i][j]=number[i-1][j]+hashmap[a][j]; } int t; t=readlong(); int l,r; long long MOD; while(t--) { l=readlong(); r=readlong(); MOD=readlong(); long long ans=1; for(i=0;i<25;i++) { if(number[r][i]-number[l-1][i]) { ans=ans*p(prime[i],number[r][i]-number[l-1][i],MOD); ans=ans%MOD; } } writeInt(ans); } return 0; }
void comp_fpp_opp (uae_u32 opcode, uae_u16 extra) { int reg; int sreg, prec = 0; int dreg = (extra >> 7) & 7; int source = (extra >> 13) & 7; int opmode = extra & 0x7f; if (!currprefs.compfpu) { FAIL(1); return; } switch (source) { case 3: /* FMOVE FPx, <EA> */ if (comp_fp_put(opcode,extra) < 0) FAIL(1); return; case 4: /* FMOVE.L <EA>, ControlReg */ if (!(opcode & 0x30)) { /* Dn or An */ if (extra & 0x1000) { /* FPCR */ mov_l_mr((uae_u32)®s.fpcr,opcode & 15); #if USE_X86_FPUCW mov_l_rr(S1,opcode & 15); and_l_ri(S1,0xf0); fldcw_m_indexed(S1,(uae_u32)x86_fpucw); #endif return; } if (extra & 0x0800) { /* FPSR */ FAIL(1); return; // set_fpsr(m68k_dreg (regs, opcode & 15)); } if (extra & 0x0400) { /* FPIAR */ mov_l_mr((uae_u32)®s.fpiar,opcode & 15); return; } } else if ((opcode & 0x3f) == 0x3c) { if (extra & 0x1000) { /* FPCR */ uae_u32 val=comp_get_ilong((m68k_pc_offset+=4)-4); mov_l_mi((uae_u32)®s.fpcr,val); #if USE_X86_FPUCW mov_l_ri(S1,val&0xf0); fldcw_m_indexed(S1,(uae_u32)x86_fpucw); #endif return; } if (extra & 0x0800) { /* FPSR */ FAIL(1); return; } if (extra & 0x0400) { /* FPIAR */ uae_u32 val=comp_get_ilong((m68k_pc_offset+=4)-4); mov_l_mi((uae_u32)®s.fpiar,val); return; } } FAIL(1); return; case 5: /* FMOVE.L ControlReg, <EA> */ if (!(opcode & 0x30)) { /* Dn or An */ if (extra & 0x1000) { /* FPCR */ mov_l_rm(opcode & 15,(uae_u32)®s.fpcr); return; } if (extra & 0x0800) { /* FPSR */ FAIL(1); return; } if (extra & 0x0400) { /* FPIAR */ mov_l_rm(opcode & 15,(uae_u32)®s.fpiar); return; } } FAIL(1); return; case 6: case 7: { uae_u32 list = 0; int incr = 0; if (extra & 0x2000) { uae_u32 ad; /* FMOVEM FPP->memory */ switch ((extra >> 11) & 3) { /* Get out early if failure */ case 0: case 2: break; case 1: case 3: default: FAIL(1); return; } ad = comp_fp_adr (opcode); if (ad < 0) { m68k_setpc (m68k_getpc () - 4); op_illg (opcode); return; } switch ((extra >> 11) & 3) { case 0: /* static pred */ list = extra & 0xff; incr = -1; break; case 2: /* static postinc */ list = extra & 0xff; incr = 1; break; case 1: /* dynamic pred */ case 3: /* dynamic postinc */ abort(); } if (incr < 0) { /* Predecrement */ for (reg = 7; reg >= 0; reg--) { if (list & 0x80) { fmov_ext_mr((uintptr)temp_fp,reg); sub_l_ri(ad,4); mov_l_rm(S2,(uintptr)temp_fp); writelong_clobber(ad,S2,S3); sub_l_ri(ad,4); mov_l_rm(S2,(uintptr)temp_fp+4); writelong_clobber(ad,S2,S3); sub_l_ri(ad,4); mov_w_rm(S2,(uintptr)temp_fp+8); writeword_clobber(ad,S2,S3); } list <<= 1; } } else { /* Postincrement */ for (reg = 0; reg <= 7; reg++) { if (list & 0x80) { fmov_ext_mr((uintptr)temp_fp,reg); mov_w_rm(S2,(uintptr)temp_fp+8); writeword_clobber(ad,S2,S3); add_l_ri(ad,4); mov_l_rm(S2,(uintptr)temp_fp+4); writelong_clobber(ad,S2,S3); add_l_ri(ad,4); mov_l_rm(S2,(uintptr)temp_fp); writelong_clobber(ad,S2,S3); add_l_ri(ad,4); } list <<= 1; } } if ((opcode & 0x38) == 0x18) mov_l_rr((opcode & 7)+8,ad); if ((opcode & 0x38) == 0x20) mov_l_rr((opcode & 7)+8,ad); } else { /* FMOVEM memory->FPP */ uae_u32 ad; switch ((extra >> 11) & 3) { /* Get out early if failure */ case 0: case 2: break; case 1: case 3: default: FAIL(1); return; } ad=comp_fp_adr (opcode); if (ad < 0) { m68k_setpc (m68k_getpc () - 4); op_illg (opcode); return; } switch ((extra >> 11) & 3) { case 0: /* static pred */ list = extra & 0xff; incr = -1; break; case 2: /* static postinc */ list = extra & 0xff; incr = 1; break; case 1: /* dynamic pred */ case 3: /* dynamic postinc */ abort(); } if (incr < 0) { // not reached for (reg = 7; reg >= 0; reg--) { if (list & 0x80) { sub_l_ri(ad,4); readlong(ad,S2,S3); mov_l_mr((uintptr)(temp_fp),S2); sub_l_ri(ad,4); readlong(ad,S2,S3); mov_l_mr((uintptr)(temp_fp)+4,S2); sub_l_ri(ad,4); readword(ad,S2,S3); mov_w_mr(((uintptr)temp_fp)+8,S2); fmov_ext_rm(reg,(uintptr)(temp_fp)); } list <<= 1; } } else { for (reg = 0; reg <= 7; reg++) { if (list & 0x80) { readword(ad,S2,S3); mov_w_mr(((uintptr)temp_fp)+8,S2); add_l_ri(ad,4); readlong(ad,S2,S3); mov_l_mr((uintptr)(temp_fp)+4,S2); add_l_ri(ad,4); readlong(ad,S2,S3); mov_l_mr((uintptr)(temp_fp),S2); add_l_ri(ad,4); fmov_ext_rm(reg,(uintptr)(temp_fp)); } list <<= 1; } } if ((opcode & 0x38) == 0x18) mov_l_rr((opcode & 7)+8,ad); if ((opcode & 0x38) == 0x20) mov_l_rr((opcode & 7)+8,ad); } }
/* return the required floating point precision or -1 for failure, 0=E, 1=S, 2=D */ STATIC_INLINE int comp_fp_get (uae_u32 opcode, uae_u16 extra, int treg) { int reg = opcode & 7; int mode = (opcode >> 3) & 7; int size = (extra >> 10) & 7; if (size == 3 || size == 7) /* 3 = packed decimal, 7 is not defined */ return -1; switch (mode) { case 0: /* Dn */ switch (size) { case 0: /* Long */ mov_l_mr((uae_u32)temp_fp,reg); fmovi_rm(treg,(uae_u32)temp_fp); return 2; case 1: /* Single */ mov_l_mr((uae_u32)temp_fp,reg); fmovs_rm(treg,(uae_u32)temp_fp); return 1; case 4: /* Word */ sign_extend_16_rr(S1,reg); mov_l_mr((uae_u32)temp_fp,S1); fmovi_rm(treg,(uae_u32)temp_fp); return 1; case 6: /* Byte */ sign_extend_8_rr(S1,reg); mov_l_mr((uae_u32)temp_fp,S1); fmovi_rm(treg,(uae_u32)temp_fp); return 1; default: return -1; } case 1: /* An, invalid mode */ return -1; case 2: /* (An) */ mov_l_rr(S1,reg+8); break; case 3: /* (An)+ */ mov_l_rr(S1,reg+8); lea_l_brr(reg+8,reg+8,(reg == 7?sz2[size]:sz1[size])); break; case 4: /* -(An) */ lea_l_brr(reg+8,reg+8,-(reg == 7?sz2[size]:sz1[size])); mov_l_rr(S1,reg+8); break; case 5: /* (d16,An) */ { uae_u32 off=(uae_s32)(uae_s16)comp_get_iword((m68k_pc_offset+=2)-2); mov_l_rr(S1,reg+8); lea_l_brr(S1,S1,off); break; } case 6: /* (d8,An,Xn) or (bd,An,Xn) or ([bd,An,Xn],od) or ([bd,An],Xn,od) */ { uae_u32 dp=comp_get_iword((m68k_pc_offset+=2)-2); calc_disp_ea_020(reg+8,dp,S1,S2); break; } case 7: switch (reg) { case 0: /* (xxx).W */ { uae_u32 off=(uae_s32)(uae_s16)comp_get_iword((m68k_pc_offset+=2)-2); mov_l_ri(S1,off); break; } case 1: /* (xxx).L */ { uae_u32 off=comp_get_ilong((m68k_pc_offset+=4)-4); mov_l_ri(S1,off); break; } case 2: /* (d16,PC) */ { uae_u32 address=start_pc+((uae_char*)comp_pc_p-(uae_char*)start_pc_p)+ m68k_pc_offset; uae_s32 PC16off =(uae_s32)(uae_s16)comp_get_iword((m68k_pc_offset+=2)-2); mov_l_ri(S1,address+PC16off); break; } case 3: /* (d8,PC,Xn) or (bd,PC,Xn) or ([bd,PC,Xn],od) or ([bd,PC],Xn,od) */ return -1; /* rarely used, fallback to non-JIT */ case 4: /* # < data >; Constants should be converted just once by the JIT */ m68k_pc_offset+=sz2[size]; switch (size) { case 0: { uae_s32 li = comp_get_ilong(m68k_pc_offset-4); float si = (float) li; if (li == (int) si) { //write_log (_T("converted immediate LONG constant to SINGLE\n")); fmovs_ri(treg,*(uae_u32 *)&si); return 1; } //write_log (_T("immediate LONG constant\n")); fmovl_ri(treg,li); return 2; } case 1: //write_log (_T("immediate SINGLE constant\n")); fmovs_ri(treg,comp_get_ilong(m68k_pc_offset-4)); return 1; case 2: //write_log (_T("immediate LONG DOUBLE constant\n")); fmov_ext_ri(treg,comp_get_ilong(m68k_pc_offset-4), comp_get_ilong(m68k_pc_offset-8), (comp_get_ilong(m68k_pc_offset-12)>>16)&0xffff); return 0; case 4: { float si = (float)(uae_s16)comp_get_iword(m68k_pc_offset-2); //write_log (_T("converted immediate WORD constant to SINGLE\n")); fmovs_ri(treg,*(uae_u32 *)&si); return 1; } case 5: { uae_u32 longarray[] = {comp_get_ilong(m68k_pc_offset-4), comp_get_ilong(m68k_pc_offset-8)}; float si = (float)*(double *)longarray; if (*(double *)longarray == (double)si) { //write_log (_T("SPEED GAIN: converted a DOUBLE constant to SINGLE\n")); fmovs_ri(treg,*(uae_u32 *)&si); return 1; } //write_log (_T("immediate DOUBLE constant\n")); fmov_ri(treg,longarray[0],longarray[1]); return 2; } case 6: { float si = (float)(uae_s8)comp_get_ibyte(m68k_pc_offset-2); //write_log (_T("immediate BYTE constant converted to SINGLE\n")); fmovs_ri(treg,*(uae_u32 *)&si); return 1; } default: /* never reached */ return -1; } default: /* never reached */ return -1; } } switch (size) { case 0: /* Long */ readlong(S1,S2,S3); mov_l_mr((uae_u32)temp_fp,S2); fmovi_rm(treg,(uae_u32)temp_fp); return 2; case 1: /* Single */ readlong(S1,S2,S3); mov_l_mr((uae_u32)temp_fp,S2); fmovs_rm(treg,(uae_u32)temp_fp); return 1; case 2: /* Long Double */ readword(S1,S2,S3); mov_w_mr(((uae_u32)temp_fp)+8,S2); add_l_ri(S1,4); readlong(S1,S2,S3); mov_l_mr((uae_u32)(temp_fp)+4,S2); add_l_ri(S1,4); readlong(S1,S2,S3); mov_l_mr((uae_u32)(temp_fp),S2); fmov_ext_rm(treg,(uae_u32)(temp_fp)); return 0; case 4: /* Word */ readword(S1,S2,S3); sign_extend_16_rr(S2,S2); mov_l_mr((uae_u32)temp_fp,S2); fmovi_rm(treg,(uae_u32)temp_fp); return 1; case 5: /* Double */ readlong(S1,S2,S3); mov_l_mr(((uae_u32)temp_fp)+4,S2); add_l_ri(S1,4); readlong(S1,S2,S3); mov_l_mr((uae_u32)(temp_fp),S2); fmov_rm(treg,(uae_u32)(temp_fp)); return 2; case 6: /* Byte */ readbyte(S1,S2,S3); sign_extend_8_rr(S2,S2); mov_l_mr((uae_u32)temp_fp,S2); fmovi_rm(treg,(uae_u32)temp_fp); return 1; default: return -1; } return -1; }
// ***********************************// // ========= MAIN FUNCTION ========= // // *********************************// int main (int argc, char *argv[]) { // ***********************************// // ========== OPEN FILE ============ // // *********************************// unsigned char *f; // Store Whole File to Memory unsigned char *fOrig; FILE *inFile, *outFile; if(!(inFile = fopen (argv[1], "rb"))) { printf("DOA5 Screenshot Converter\nBy: mario_kart64n\nDate: Sept 28 2012\n\nUsage: <Input> <Output>\n"); return 1; } if(!(outFile = fopen (argv[2], "wb"))) { printf("DOA5 Screenshot Converter\nBy: mario_kart64n\nDate: Sept 28 2012\n\nUsage: <Input> <Output>\n"); return 2; } if(!(f=(unsigned char*) malloc(getfilesize (inFile)))) { printf("Not enough memory.\n"); return(-1); } if(!fread(f, 1, (getfilesize (inFile)), inFile)) { printf("Error reading file.\n"); return(-1); } fOrig = f; // ***********************************// // ======== FILE OPERATION ========= // // *********************************// int cnt = 0; fseek(inFile, 0, SEEK_SET); fclose (inFile); f+=0xD010; // seek to texture data in the PIR int magic = readlong(f); if (magic == 0x53584554) { f+=64; for (int i = 1; i-1 < 54; i++) { fwrite(bmp_header+cnt, 1, 1, outFile);cnt+=1; //Write BMP Header } for (int i = 0; i-1 < 230400; i++) { // 1280 x 0720 pixels cnt = ((untile_ARGB32_1280_0720b[i]-1)*4); fwrite(f+(cnt+3), 1, 1, outFile); // Red fwrite(f+(cnt+2), 1, 1, outFile); // Green fwrite(f+(cnt+1), 1, 1, outFile); // Blue cnt+=4; fwrite(f+(cnt+3), 1, 1, outFile); // Red fwrite(f+(cnt+2), 1, 1, outFile); // Green fwrite(f+(cnt+1), 1, 1, outFile); // Blue cnt+=4; fwrite(f+(cnt+3), 1, 1, outFile); // Red fwrite(f+(cnt+2), 1, 1, outFile); // Green fwrite(f+(cnt+1), 1, 1, outFile); // Blue cnt+=4; fwrite(f+(cnt+3), 1, 1, outFile); // Red fwrite(f+(cnt+2), 1, 1, outFile); // Green fwrite(f+(cnt+1), 1, 1, outFile); // Blue } } else { f+=0x1000; int magic = readlong(f); if (magic == 0x53584554) { f+=64; for (int i = 1; i-1 < 54; i++) { fwrite(bmp_header+cnt, 1, 1, outFile);cnt+=1; //Write BMP Header } for (int i = 0; i-1 < 230400; i++) { // 1280 x 0720 pixels cnt = ((untile_ARGB32_1280_0720c[i]-1)*4); fwrite(f+(cnt+3), 1, 1, outFile); // Red fwrite(f+(cnt+2), 1, 1, outFile); // Green fwrite(f+(cnt+1), 1, 1, outFile); // Blue cnt+=4; fwrite(f+(cnt+3), 1, 1, outFile); // Red fwrite(f+(cnt+2), 1, 1, outFile); // Green fwrite(f+(cnt+1), 1, 1, outFile); // Blue cnt+=4; fwrite(f+(cnt+3), 1, 1, outFile); // Red fwrite(f+(cnt+2), 1, 1, outFile); // Green fwrite(f+(cnt+1), 1, 1, outFile); // Blue cnt+=4; fwrite(f+(cnt+3), 1, 1, outFile); // Red fwrite(f+(cnt+2), 1, 1, outFile); // Green fwrite(f+(cnt+1), 1, 1, outFile); // Blue } } } fclose(outFile); free(fOrig); return (0); }
/* Load memory font */ static struct font* font_load_in_memory(struct font* pf) { int32_t i, noffset, nwidth; if (!HAVEBYTES(4)) return NULL; /* # longs of offset*/ noffset = readlong(pf); /* # bytes of width*/ nwidth = readlong(pf); /* variable font data*/ pf->bits = (unsigned char *)pf->buffer_position; pf->buffer_position += pf->bits_size*sizeof(unsigned char); if (pf->bits_size < MAX_FONTSIZE_FOR_16_BIT_OFFSETS) { /* pad to 16-bit boundary */ pf->buffer_position = (unsigned char *)(((intptr_t)pf->buffer_position + 1) & ~1); } else { /* pad to 32-bit boundary*/ pf->buffer_position = (unsigned char *)(((intptr_t)pf->buffer_position + 3) & ~3); } if (noffset) { if (pf->bits_size < MAX_FONTSIZE_FOR_16_BIT_OFFSETS) { pf->long_offset = 0; pf->offset = (uint16_t*)pf->buffer_position; /* Check we have sufficient buffer */ if (!HAVEBYTES(noffset * sizeof(uint16_t))) return NULL; for (i=0; i<noffset; ++i) { ((uint16_t*)(pf->offset))[i] = (uint16_t)readshort(pf); } } else { pf->long_offset = 1; pf->offset = (uint16_t*)pf->buffer_position; /* Check we have sufficient buffer */ if (!HAVEBYTES(noffset * sizeof(int32_t))) return NULL; for (i=0; i<noffset; ++i) { ((uint32_t*)(pf->offset))[i] = (uint32_t)readlong(pf); } } } else pf->offset = NULL; if (nwidth) { pf->width = (unsigned char *)pf->buffer_position; pf->buffer_position += nwidth*sizeof(unsigned char); } else pf->width = NULL; if (pf->buffer_position > pf->buffer_end) return NULL; return pf; /* success!*/ }
int dns_decode(char *buf, size_t buflen, struct query *q, qr_t qr, char *packet, size_t packetlen) { char name[QUERY_NAME_SIZE]; char rdata[4*1024]; HEADER *header; short qdcount; short ancount; uint32_t ttl; unsigned short class; unsigned short type; char *data; unsigned short rlen; uint16_t id; int rv; rv = 0; header = (HEADER*)packet; /* Reject short packets */ if (packetlen < sizeof(HEADER)) return 0; if (header->qr != qr) { warnx("header->qr does not match the requested qr"); return -1; } data = packet + sizeof(HEADER); qdcount = ntohs(header->qdcount); ancount = ntohs(header->ancount); id = ntohs(header->id); rlen = 0; if (q != NULL) q->rcode = header->rcode; switch (qr) { case QR_ANSWER: if(qdcount < 1) { /* We need a question */ return -1; } if (q != NULL) q->id = id; /* Read name even if no answer, to give better error message */ readname(packet, packetlen, &data, name, sizeof(name)); CHECKLEN(4); readshort(packet, &data, &type); readshort(packet, &data, &class); /* if CHECKLEN okay, then we're sure to have a proper name */ if (q != NULL) { /* We only need the first char to check it */ q->name[0] = name[0]; q->name[1] = '\0'; } if (ancount < 1) { /* DNS errors like NXDOMAIN have ancount=0 and stop here. CNAME may also have A; MX/SRV may have multiple results. */ return -1; } /* Here type is still the question type */ if (type == T_NULL || type == T_PRIVATE) { /* Assume that first answer is what we wanted */ readname(packet, packetlen, &data, name, sizeof(name)); CHECKLEN(10); readshort(packet, &data, &type); readshort(packet, &data, &class); readlong(packet, &data, &ttl); readshort(packet, &data, &rlen); rv = MIN(rlen, sizeof(rdata)); rv = readdata(packet, &data, rdata, rv); if (rv >= 2 && buf) { rv = MIN(rv, buflen); memcpy(buf, rdata, rv); } else { rv = 0; } } else if ((type == T_A || type == T_CNAME ||
void readMidiTrackHeader(FILE *fp, struct mtrack *t) { fread(t->chunktype, sizeof t->chunktype, 1, fp); t->length = readlong(fp); }
static int bit_savi2c_getsda(void *data) { return (0 != (readlong() & I2C_SDA_IN)); }
void getoptions() { /* interactively set options */ long loopcount; Char ch; boolean done, gotopt; char input[100]; how = arb; usertree = false; goteof = false; thresh = false; threshold = spp; weights = false; ancvar = false; factors = false; dollo = true; loopcount = 0; do { cleerhome(); printf("\nInteractive Dollo or polymorphism parsimony,"); printf(" version %s\n\n",VERSION); printf("Settings for this run:\n"); printf(" P Parsimony method?"); printf(" %s\n",(dollo ? "Dollo" : "Polymorphism")); printf(" A Use ancestral states? %s\n", ancvar ? "Yes" : "No"); printf(" F Use factors information? %s\n", factors ? "Yes" : "No"); printf(" W Sites weighted? %s\n", (weights ? "Yes" : "No")); printf(" T Use Threshold parsimony?"); if (thresh) printf(" Yes, count steps up to%4.1f\n", threshold); else printf(" No, use ordinary parsimony\n"); printf(" A Use ancestral states in input file?"); printf(" %s\n",(ancvar ? "Yes" : "No")); printf(" U Initial tree (arbitrary, user, specify)?"); printf(" %s\n",(how == arb) ? "Arbitrary" : (how == use) ? "User tree from tree file" : "Tree you specify"); printf(" 0 Graphics type (IBM PC, ANSI, none)? %s\n", ibmpc ? "IBM PC" : ansi ? "ANSI" : "(none)"); printf(" L Number of lines on screen?%4ld\n",screenlines); printf(" S Width of terminal screen?%4ld\n",screenwidth); printf( "\n\nAre these settings correct? (type Y or the letter for one to change)\n"); #ifdef WIN32 phyFillScreenColor(); #endif getstryng(input); ch = input[0]; uppercase(&ch); done = (ch == 'Y'); gotopt = (strchr("SFTPULA0W",ch) != NULL) ? true : false; if (gotopt) { switch (ch) { case 'A': ancvar = !ancvar; break; case 'F': factors = !factors; break; case 'W': weights = !weights; break; case 'P': dollo = !dollo; break; case 'T': thresh = !thresh; if (thresh) initthreshold(&threshold); break; case 'U': if (how == arb) how = use; else if (how == use) how = spec; else how = arb; break; case '0': initterminal(&ibmpc, &ansi); break; case 'L': initnumlines(&screenlines); break; case 'S': screenwidth = readlong("Width of terminal screen (in characters)?\n"); } } else printf("Not a possible option!\n"); countup(&loopcount, 100); } while (!done); if (scrollinc < screenwidth / 2.0) hscroll = scrollinc; else hscroll = screenwidth / 2; if (scrollinc < screenlines / 2.0) vscroll = scrollinc; else vscroll = screenlines / 2; } /* getoptions */
struct rtgui_font *fnt_font_create(const char* filename, const char* font_family) { int fd = -1; rt_uint32_t index; struct rtgui_font *font = RT_NULL; struct fnt_font *fnt = RT_NULL; struct fnt_header *fnt_header; fd = open(filename, O_RDONLY, 0); if (fd < 0) { goto __exit; } font = (struct rtgui_font*) rtgui_malloc (sizeof(struct rtgui_font)); if (font == RT_NULL) goto __exit; fnt = (struct fnt_font*) rtgui_malloc (sizeof(struct fnt_font)); if (fnt == RT_NULL) goto __exit; rt_memset(fnt, 0x00, sizeof(struct fnt_font)); font->data = (void*)fnt; fnt_header = &(fnt->header); if (readstr(fd, fnt_header->version, 4) != 4) goto __exit; if (!readshort(fd, &fnt_header->max_width)) goto __exit; if (!readshort(fd, &fnt_header->height)) goto __exit; if (!readshort(fd, &fnt_header->ascent)) goto __exit; if (!readshort(fd, &fnt_header->depth)) goto __exit; if (!readlong(fd, &fnt_header->first_char)) goto __exit; if (!readlong(fd, &fnt_header->default_char)) goto __exit; if (!readlong(fd, &fnt_header->size)) goto __exit; if (!readlong(fd, &fnt_header->nbits)) goto __exit; if (!readlong(fd, &fnt_header->noffset)) goto __exit; if (!readlong(fd, &fnt_header->nwidth)) goto __exit; fnt->bits = (MWIMAGEBITS*) rtgui_malloc (fnt_header->nbits * sizeof(MWIMAGEBITS)); if (fnt->bits == RT_NULL) goto __exit; /* read data */ if (readstr(fd, &(fnt->bits[0]), fnt_header->nbits) != fnt_header->nbits) goto __exit; /* check boundary */ if (fnt_header->nbits & 0x01) { rt_uint16_t pad; readshort(fd, &pad); pad = pad; /* skip warning */ } if (fnt_header->noffset != 0) { fnt->offset = rtgui_malloc (fnt_header->noffset * sizeof(rt_uint32_t)); if (fnt->offset == RT_NULL) goto __exit; for (index = 0; index < fnt_header->noffset; index ++) { if (!readshort(fd, &(fnt->offset[index]))) goto __exit; } } if (fnt_header->nwidth != 0) { fnt->width = rtgui_malloc (fnt_header->nwidth * sizeof(rt_uint8_t)); if (fnt->width == RT_NULL) goto __exit; for (index = 0; index < fnt_header->nwidth; index ++) { if (!readbyte(fd, &(fnt->width[index]))) goto __exit; } } close(fd); font->family = rt_strdup(font_family); font->height = fnt->header.height; font->refer_count = 0; font->engine = &fnt_font_engine; /* add to system */ rtgui_font_system_add_font(font); return font; __exit: if (fd >= 0) close(fd); if (fnt != RT_NULL) { if (fnt->bits != RT_NULL) rtgui_free(fnt->bits); if (fnt->offset != RT_NULL) rtgui_free(fnt->offset); if (fnt->width != RT_NULL) rtgui_free(fnt->width); rtgui_free(fnt); } if (font != RT_NULL) { rtgui_free(font); } return RT_NULL; }
db_line* db_char2line(char** ss,int db){ int i; db_line* line=(db_line*)malloc(sizeof(db_line)*1); int* db_osize=0; DB_FIELD** db_order=NULL; switch (db) { case DB_OLD: { db_osize=&(conf->db_in_size); db_order=&(conf->db_in_order); break; } case DB_NEW: { db_osize=&(conf->db_new_size); db_order=&(conf->db_new_order); break; } } line->md5=NULL; line->sha1=NULL; line->rmd160=NULL; line->tiger=NULL; line->crc32=NULL; /* MHASH stuff.. */ line->crc32b=NULL; line->haval=NULL; line->gost=NULL; line->whirlpool=NULL; line->sha256=NULL; line->sha512=NULL; line->perm=0; line->uid=0; line->gid=0; line->atime=0; line->ctime=0; line->mtime=0; line->inode=0; line->nlink=0; line->bcount=0; line->size=0; line->filename=NULL; line->fullpath=NULL; line->linkname=NULL; line->acl=NULL; line->xattrs=NULL; line->e2fsattrs=0; line->cntx=NULL; line->attr=conf->attr; /* attributes from @@dbspec */ for(i=0;i<*db_osize;i++){ switch ((*db_order)[i]) { case db_filename : { if(ss[(*db_order)[i]]!=NULL){ decode_string(ss[(*db_order)[i]]); line->fullpath=strdup(ss[(*db_order)[i]]); line->filename=line->fullpath; } else { error(0,"db_char2line():Error while reading database\n"); exit(EXIT_FAILURE); } break; } case db_linkname : { line->linkname = db_readchar(ss[(*db_order)[i]]); break; } case db_mtime : { line->mtime=base64totime_t(ss[(*db_order)[i]]); break; } case db_bcount : { line->bcount=readint(ss[(*db_order)[i]],"bcount"); break; } case db_atime : { line->atime=base64totime_t(ss[(*db_order)[i]]); break; } case db_ctime : { line->ctime=base64totime_t(ss[(*db_order)[i]]); break; } case db_inode : { line->inode=readint(ss[(*db_order)[i]],"inode"); break; } case db_uid : { line->uid=readint(ss[(*db_order)[i]],"uid"); break; } case db_gid : { line->gid=readint(ss[(*db_order)[i]],"gid"); break; } case db_size : { line->size=readlong(ss[(*db_order)[i]],"size"); break; } case db_md5 : { line->md5=base64tobyte(ss[(*db_order)[i]], strlen(ss[(*db_order)[i]]), NULL); break; } case db_sha1 : { line->sha1=base64tobyte(ss[(*db_order)[i]], strlen(ss[(*db_order)[i]]), NULL); break; } case db_rmd160 : { line->rmd160=base64tobyte(ss[(*db_order)[i]], strlen(ss[(*db_order)[i]]), NULL); break; } case db_tiger : { line->tiger=base64tobyte(ss[(*db_order)[i]], strlen(ss[(*db_order)[i]]), NULL); break; } #ifdef WITH_MHASH case db_crc32 : { line->crc32=base64tobyte(ss[(*db_order)[i]], strlen(ss[(*db_order)[i]]), NULL); break; } case db_haval : { line->haval=base64tobyte(ss[(*db_order)[i]], strlen(ss[(*db_order)[i]]), NULL); break; } case db_gost : { line->gost=base64tobyte(ss[(*db_order)[i]], strlen(ss[(*db_order)[i]]), NULL); break; } case db_crc32b : { line->crc32b=base64tobyte(ss[(*db_order)[i]], strlen(ss[(*db_order)[i]]), NULL); break; } case db_whirlpool : { line->whirlpool=base64tobyte(ss[(*db_order)[i]], strlen(ss[(*db_order)[i]]), NULL); break; } #else WARN_ONCE(gost); WARN_ONCE(crc32b); WARN_ONCE(whirlpool); #endif case db_sha256 : { line->sha256=base64tobyte(ss[(*db_order)[i]], strlen(ss[(*db_order)[i]]), NULL); break; } case db_sha512 : { line->sha512=base64tobyte(ss[(*db_order)[i]], strlen(ss[(*db_order)[i]]), NULL); break; } #ifdef WITH_SUN_ACL case db_acl : { char* endp,*pos; int entries,lc; line->acl=NULL; entries=strtol(ss[(*db_order)[i]],&endp,10); if (endp==ss[(*db_order)[i]]) { /* Something went wrong */ break; } pos=endp+1; /* Warning! if acl in database is corrupted then this will break down. */ line->acl=malloc(sizeof(acl_type)); line->acl->entries=entries; line->acl->acl=malloc(sizeof(aclent_t)*entries); for (lc=0;lc<entries;lc++) { line->acl->acl[lc].a_type=strtol(pos,&endp,10); pos=endp+1; line->acl->acl[lc].a_id=strtol(pos,&endp,10); pos=endp+1; line->acl->acl[lc].a_perm=strtol(pos,&endp,10); pos=endp+1; } break; } #endif #ifdef WITH_POSIX_ACL case db_acl : { char *tval = NULL; tval = strtok(ss[(*db_order)[i]], ","); line->acl = NULL; if (tval[0] == '0') line->acl = NULL; else if (!strcmp(tval, "POSIX")) { line->acl = malloc(sizeof(acl_type)); line->acl->acl_a = NULL; line->acl->acl_d = NULL; tval = strtok(NULL, ","); line->acl->acl_a = (char *)base64tobyte(tval, strlen(tval), NULL); tval = strtok(NULL, ","); line->acl->acl_d = (char *)base64tobyte(tval, strlen(tval), NULL); } /* else, it's broken... */ break; } #endif case db_xattrs : { size_t num = 0; char *tval = NULL; tval = strtok(ss[(*db_order)[i]], ","); num = readlong(tval, "xattrs"); if (num) { line->xattrs = malloc(sizeof(xattrs_type)); line->xattrs->ents = calloc(sizeof(xattr_node), num); line->xattrs->sz = num; line->xattrs->num = num; num = 0; while (num < line->xattrs->num) { byte *val = NULL; size_t vsz = 0; tval = strtok(NULL, ","); line->xattrs->ents[num].key = db_readchar(strdup(tval)); tval = strtok(NULL, ","); val = base64tobyte(tval, strlen(tval), &vsz); line->xattrs->ents[num].val = val; line->xattrs->ents[num].vsz = vsz; ++num; } } break; } case db_selinux : { byte *val = NULL; val = base64tobyte(ss[(*db_order)[i]], strlen(ss[(*db_order)[i]]),NULL); line->cntx = (char *)val; break; } case db_perm : { line->perm=readoct(ss[(*db_order)[i]],"permissions"); break; } case db_lnkcount : { line->nlink=readint(ss[(*db_order)[i]],"nlink"); break; } case db_attr : { line->attr=readlong(ss[(*db_order)[i]],"attr"); break; } case db_e2fsattrs : { line->e2fsattrs=readlong(ss[(*db_order)[i]],"e2fsattrs"); break; } case db_unknown : { /* Unknown fields are ignored. */ break; } default : { error(0,_("Not implemented in db_char2line %i \n"),(*db_order)[i]); return NULL; } } } return line; }
struct sSection * obj_ReadRGB1Section(FILE * f) { struct sSection *pSection; pSection = AllocSection(); pSection->nByteSize = readlong(f); pSection->Type = (enum eSectionType) fgetc(f); /* * And because of THIS new feature I'll have to rewrite loads and * loads of stuff... oh well it needed to be done anyway * */ pSection->nOrg = readlong(f); pSection->nBank = readlong(f); /* does the user want the -s mode? */ if ((options & OPT_SMALL) && (pSection->Type == SECT_ROMX)) { pSection->Type = SECT_ROM0; } if ((pSection->Type == SECT_ROMX) || (pSection->Type == SECT_ROM0)) { /* * These sectiontypes contain data... * */ if (pSection->nByteSize) { pSection->pData = malloc(pSection->nByteSize); if (!pSection->pData) { err(1, NULL); } SLONG nNumberOfPatches; struct sPatch **ppPatch, *pPatch; char s[256]; fread(pSection->pData, sizeof(UBYTE), pSection->nByteSize, f); nNumberOfPatches = readlong(f); ppPatch = &pSection->pPatches; /* * And patches... * */ while (nNumberOfPatches--) { pPatch = malloc(sizeof *pPatch); if (!pPatch) { err(1, NULL); } *ppPatch = pPatch; readasciiz(s, f); pPatch->pzFilename = malloc(strlen(s) + 1); if (!pPatch->pzFilename) { err(1, NULL); } strcpy(pPatch->pzFilename, s); pPatch->nLineNo = readlong(f); pPatch->nOffset = readlong(f); pPatch->Type = (enum ePatchType) fgetc(f); if ((pPatch->nRPNSize = readlong(f)) > 0) { pPatch->pRPN = malloc(pPatch->nRPNSize); if (!pPatch->pRPN) { err(1, NULL); } fread(pPatch->pRPN, sizeof(UBYTE), pPatch->nRPNSize, f); } else pPatch->pRPN = NULL; pPatch->pNext = NULL; ppPatch = &(pPatch->pNext); } } else { /* Skip number of patches */ readlong(f); pSection->pData = &dummymem; } } return pSection; }