ESTRUC_ *gr_equal (ESTRUC_ *lval, ESTRUC_ *rval) { btoi(lval); /* convert boolean to i */ btoi(rval); if (conflict(lval, rval, op_greq)) /* test type conflict */ return(lval); if ((lval->type & rval->type & (size_t)~ALLTYPES) == e_const) { if (test_type(lval, e_int)) lval->evalue = (lval->evalue >= rval->evalue); else { lval->evalue = ( strcmp ( stringtab[lval->evalue].string, stringtab[rval->evalue].string ) ) >= 0; set_type(lval, e_int | e_const); } } else defcode(lval, rval, op_greq); return (lval); /* return new expression */ }
int main(int argc, char* argv[]) { unsigned int val; if (argc < 2) { print_usage(); return 0; } if(strncmp(argv[1], "0b", 2) == 0) { printf("%s:\t0x%08x\n", itob(btoi(argv[1])), btoi(argv[1])); printf(" | | | \n"); printf(" 23 15 7 \n"); } else if(strncmp(argv[1], "0x", 2) == 0) { val = strtol(argv[1], (char**)NULL, 16); printf("0x%08x:\t%s", val, itob(val)); /* wrong usage: creates memory leak*/ printf("\n\t\t | | | \n"); printf("\t\t 23 15 7 \n"); } else print_usage(); return 0; }
void ASN1_TIME_extract(const unsigned char* date, unsigned char format, tm *t) { int i = 0; memset(t, 0, sizeof (tm)); assert(format == UTC_TIME || format == GENERALIZED_TIME); if (format == UTC_TIME) { if (btoi(date[0]) >= 5) t->tm_year = 1900; else t->tm_year = 2000; } else { // format == GENERALIZED_TIME t->tm_year += btoi(date[i++]) * 1000; t->tm_year += btoi(date[i++]) * 100; } GetTime(&t->tm_year, date, i); t->tm_year -= 1900; // adjust GetTime(&t->tm_mon, date, i); t->tm_mon -= 1; // adjust GetTime(&t->tm_mday, date, i); GetTime(&t->tm_hour, date, i); GetTime(&t->tm_min, date, i); GetTime(&t->tm_sec, date, i); assert(date[i] == 'Z'); // only Zulu supported for this profile }
void parseMemoryAddress(char *address, int TAG, int INDEX, int OFFSET, int *ta , int *in) { unsigned int dec; char *bstring, *bformatted, *tag, *index, *offset; int i; //dec = htoi(address); //bstring = getBinary(dec); //bformatted = formatBinary(bstring, TAG, INDEX, OFFSET); //bformatted = formatBinary(address, TAG, INDEX, OFFSET); bformatted = address; /* if(DEBUG) { printf("Hex: %s\n", address); printf("Decimal: %u\n", dec); printf("Binary: %s\n", bstring); printf("Formatted: %s\n", bformatted); } */ i = 0; tag = (char *) malloc( sizeof(char) * (TAG + 1) ); assert(tag != NULL); tag[TAG] = '\0'; for(i = 0; i < TAG; i++) { tag[i] = bformatted[i]; } index = (char *) malloc( sizeof(char) * (INDEX + 1) ); assert(index != NULL); index[INDEX] = '\0'; for(i = TAG + 1; i < INDEX + TAG + 1; i++) { index[i - TAG - 1] = bformatted[i]; } offset = (char *) malloc( sizeof(char) * (OFFSET + 1) ); assert(offset != NULL); offset[OFFSET] = '\0'; for(i = INDEX + TAG + 2; i < OFFSET + INDEX + TAG + 2; i++) { offset[i - INDEX - TAG - 2] = bformatted[i]; } *ta = btoi(tag); *in = btoi(index); //printf("Tag: %s (%i)\n", tag, btoi(tag)); //printf("Index: %s (%i)\n", index, btoi(index)); //printf("Offset: %s (%i)\n", offset, btoi(offset)); }
ID3v2_header* get_tag_header(const char* file_name) { char buffer[ID3_HEADER]; FILE* file = fopen(file_name, "rb"); if(file == NULL) { perror("Error opening file"); return NULL; } fread(buffer, ID3_HEADER, 1, file); fclose(file); ID3v2_header* tag_header = new_header(); if( ! _has_id3v2tag(buffer)) { if (tag_header != NULL) free (tag_header); return NULL; } int position = 0; memcpy(tag_header->tag, buffer, ID3_HEADER_TAG); tag_header->major_version = buffer[position += ID3_HEADER_TAG]; tag_header->minor_version = buffer[position += ID3_HEADER_VERSION]; tag_header->flags = buffer[position += ID3_HEADER_REVISION]; tag_header->tag_size = syncint_decode(btoi(buffer, ID3_HEADER_SIZE, position += ID3_HEADER_FLAGS)); return tag_header; }
ID3v2_frame* parse_frame(char* bytes, int offset, int version) { ID3v2_frame* frame = new_frame(); // Parse frame header memcpy(frame->frame_id, bytes + offset, ID3_FRAME_ID); // Check if we are into padding if(memcmp(frame->frame_id, "\0\0\0\0", 4) == 0) { return NULL; } frame->size = btoi(bytes, 4, offset += ID3_FRAME_ID); if(version == ID3v24) { frame->size = syncint_decode(frame->size); } memcpy(frame->flags, bytes + (offset += ID3_FRAME_SIZE), 2); // Load frame data frame->data = (char*) malloc(frame->size * sizeof(char*)); memcpy(frame->data, bytes + (offset += ID3_FRAME_FLAGS), frame->size); return frame; }
//turn false:自分から相手 true:相手から自分 int doxor(int fin_int, bool from, bool to, int shift, bool turn) { int tohand,fromhand; bool shifted[4],dest[16],fin[16]; itob(fin_int,fin); if (!turn) { tohand=to?3:2; fromhand=from?1:0; } else { tohand=to?1:0; fromhand=from?3:2; } for (int i=0;i<4;i++) { if (i!=tohand) { for (int j=0;j<4;j++) dest[i*4+j]=fin[i*4+j]; } else { for (int j=0;j<4;j++) shifted[j]=false; for (int j=0;j<4;j++) if (0<=j+shift && j+shift<4) shifted[j+shift]=fin[fromhand*4+j]; for (int j=0;j<4;j++) dest[tohand*4+j] = fin[tohand*4+j] ^ shifted[j]; } } return btoi(dest); }
int __main(int argc, char *argv[]) { if (argc < 2 || argc > 3) { printf("Syntax: px_p8 [-t] filename\n"); exit(1); } int sectors; if (argc == 3 && !strcmp(argv[1], "-t")) { argv[1] = argv[2]; sectors = 2352; } else sectors = 4704; FILE *sector_file; unsigned char *sector = new unsigned char[sectors]; const unsigned char sync[12] = {0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00}; sector_file = fopen(argv[1], "rb"); if (sector_file == NULL) { perror(argv[1]); exit(1); } if (argc == 3) { unsigned int hex; for (int i = 0; fscanf(sector_file, "%02x", &hex) != EOF && i < 3252; i++) { sector[i] = (unsigned char)hex; } } else { fread(sector, 1, sectors, sector_file); } int offset = memsearch(sector, sync, sectors, 12); if (offset == -1) { printf("Error searching for sync!\n"); exit(1); } int ShiftRegister = 0x1; //printf("MSF: %02x:%02x:%02x\n", sector[offset+12], sector[offset+12+1], sector[offset+12+2]); for (int i = 0; i < 3; i++) { sector[offset+12+i] ^= (ShiftRegister&0xFF); for (int j = 0; j < 8; j++) { int hibit = ((ShiftRegister & 1)^((ShiftRegister & 2)>>1)) << 15; ShiftRegister = (hibit | ShiftRegister) >> 1; } } int start_sector = (btoi(sector[offset+12])*60 + btoi(sector[offset+13]))*75 + btoi(sector[offset+14]) - 150; printf("MSF: %02x:%02x:%02x\n", sector[offset+12], sector[offset+12+1], sector[offset+12+2]); offset -= start_sector * 2352; printf("Combined offset: %+d bytes / %+d samples\n", offset, offset / 4); return 0; }
void CheckPPFCache(unsigned char *pB, unsigned char m, unsigned char s, unsigned char f) { PPF_CACHE *pcstart, *pcend, *pcpos; int addr = MSF2SECT(btoi(m), btoi(s), btoi(f)), pos, anz, start; if (ppfCache == NULL) return; pcstart = ppfCache; if (addr < pcstart->addr) return; pcend = ppfCache + iPPFNum; if (addr > pcend->addr) return; while (1) { if (addr == pcend->addr) { pcpos = pcend; break; } pcpos = pcstart + (pcend - pcstart) / 2; if (pcpos == pcstart) break; if (addr < pcpos->addr) { pcend = pcpos; continue; } if (addr > pcpos->addr) { pcstart = pcpos; continue; } break; } if (addr == pcpos->addr) { PPF_DATA *p = pcpos->pNext; while (p != NULL && p->addr == addr) { pos = p->pos - (CD_FRAMESIZE_RAW - DATA_SIZE); anz = p->anz; if (pos < 0) { start = -pos; pos = 0; anz -= start; } else start = 0; memcpy(pB + pos, (unsigned char *)(p + 1) + start, anz); p = p->pNext; } } }
/** @brief Charge un schema depuis un fichier RIFF @param mem Tampon mémoire @return Résultat de procèdure */ bool QEquipmentView::fromRIFF(PTR* mem){ RIFF riff; //supprime le contenu de la scene this->reset(); //lit l'entete if(!riff_read(mem,&riff)) return false; //Vérifie l'en-tete if(!(riff.id[0] == 'R' && riff.id[1] == 'I' && riff.id[2] == 'F' && riff.id[3] == 'F')) return QRESULT_DESC(Result::Failed, Result::RiffInvalidHeader); if(mem->ptr+riff.size > mem->down) return QRESULT_DESC(Result::Failed, Result::RiffInvalidTagSize); //lit les chunk char tag[4]; unsigned int tag_size; while(mem->ptr<mem->down && riff_read_tag(mem,tag,&tag_size)){ qDebug() << "tag=" << tag[0] << tag[1] << tag[2] << tag[3]; qDebug() << "tag_size=" << tag_size; if(mem->ptr+tag_size > mem->down) return QRESULT_DESC(Result::Failed, Result::RiffInvalidTagSize); if(memcmp("EQUIP",tag,sizeof(tag)) == 0 ){ qDebug() << "EQUIP tag..."; //Charge l'équipement RIFF_EQUIP equip; equip.id = btoi(mem); bread(mem,equip.name,sizeof(equip.name)); bread(mem,equip.type,sizeof(equip.type)); //Ajoute l'équipement à la scene Equipment qequip; qequip.equipmentId = equip.id; qequip.name = QString(equip.name); qequip.type = QString(equip.type); QPRINT(qequip.type); qequip.posX = qequip.posY = qequip.posZ = 0; this->addEquipment(qequip); } else{ qDebug() << "IGNORE tag"; mem->ptr += tag_size; } qDebug() << "offset=" << boffset(mem); } return QRESULT_OK(); }
int main(int argc, char *argv[]){ char str[1024]; int num = 0; int format = HEX; char opt; memset(str, 0, 1024); while((opt=getopt(argc, argv, "oxb")) != -1){ switch(opt){ case 'o': format = OCT; break; case 'x': format = HEX; break; case 'b': format = BIN; break; default: usage(argv[0]); } } if(optind >= argc){ scanf("%s", str); } else { strcpy(str, argv[optind]); } switch(format){ case HEX: num = htoi(str); break; case OCT: num = otoi(str); break; case BIN: num = btoi(str); break; default: num = -1; } if(num == -1){ fprintf(stderr, "Error: incorrectly formatted string %s\n", str); return EXIT_FAILURE; } printf("%d\n", num); return 0; }
main(int ac, char **av) { if (ac < 3) Usage(); if (!strcmp(av[1], "-s")) itob(ac, av); else if (!strcmp(av[1], "-i")) btoi(ac, av); else if (!strcmp(av[1], "-c")) check(ac, av); else if (!strcmp(av[1], "-r")) verifyRange(ac, av); else Usage(); exit(0); }
int main() { char record[20];//页表项大小 char page[20];//页大小 int level = 0;//级数 char* logicaddr = (char*)malloc(12 * sizeof(char));//逻辑地址,形如0x12345678H; scanf("%s", record); scanf("%s", page); scanf("%d", &level); scanf("%s", logicaddr); int recordbit = mapdec(record); int pagebit = mapdec(page); char* tmp = substring(logicaddr, 2, strlen(logicaddr)); int offset = btoi(substring(bmapo(tmp, "b"), ADDRSPACEBIT - 1 - pagebit, ADDRSPACEBIT - 1)); char* physicaddr = getpaddr(level, recordbit, pagebit, tmp); return 0; }
/* * Build a direct map huffman table from the array of codes given. * We build a prefix table such that we can directly index * table with the k-bit number at the head of the bit stream, where * k is the max-length code in the table. The table tells us * the value and the actual length of the code we have. * We need the length so we can tear that many bits off * the input stream. The length and value are packed as * two 16-bit quantities in a 32-bit word. The value is stored * in the upper 16-bits, so when we right-shift it over, * it is automatically sign-extended. */ void huffbuild(hufftab& ht, const huffcode* codes) { int i = 0; int maxlen = 0; for (; codes[i].str != 0; ++i) { int v = strlen(codes[i].str); if (v > maxlen) maxlen = v; } int size = 1 << maxlen; if (size > 65536) abort(); /* * Build the direct-map lookup table. */ ht.prefix = new short[size]; ht.maxlen = maxlen; /* * Initialize states to illegal, and arrange * for max bits to be stripped off the input. */ for (i = 0; i < size; ++i) ht.prefix[i] = (SYM_ILLEGAL << 5) | maxlen; for (i = 0; codes[i].str != 0; ++i) { int codelen = strlen(codes[i].str); int nbit = maxlen - codelen; int code = btoi(codes[i].str) << nbit; int map = (codes[i].val << 5) | codelen; /* * The low nbit bits are don't cares. * Spin through all possible combos. */ for (int n = 1 << nbit; --n >= 0; ) { if ((code | n) >= size) abort(); ht.prefix[code | n] = map; } } }
InputIterator parse(InputIterator buffer_begin, InputIterator buffer_end, Consumer& c) { if (buffer_begin == buffer_end) { return buffer_end; } byte b = *buffer_begin++; switch (b) { case ':': { auto r = btoi(buffer_begin, buffer_end); return c.on_int(r.first, r.second); } case '+': { return c.on_sstr(buffer_begin, buffer_end); } case '$': { if (buffer_begin != buffer_end && *buffer_begin == '-') { return c.on_nil(pass_nil(++buffer_begin, buffer_end)); } auto r = btou(buffer_begin, buffer_end); return c.on_str(r.first, r.second, buffer_end); } case '*': { if (buffer_begin != buffer_end && *buffer_begin == '-') { return c.on_nil(pass_nil(++buffer_begin, buffer_end)); } auto r = btou(buffer_begin, buffer_end); c.on_arr(r.first, r.second); buffer_begin = r.second; for (int i = 0; i < r.first && buffer_begin != buffer_end; ++i) { buffer_begin = parse(buffer_begin, buffer_end, c); } return buffer_begin; } case '-': { return c.on_err(buffer_begin, buffer_end); } default: throw BadRedisMessage(b); } }
/* <increment to be added to named parameter> . */ void o_addassign (memel *argp) { /* order of operands will be incorrect. * strictly speaking, only strings are not commutative but we need * to pop both operands anyway to check. */ char *pname = (char *) argp; char *pk, *t, *p, *f; struct param *pp; struct operand o1, o2; breakout (pname, &pk, &t, &p, &f); pp = paramsrch (pk, t, p); validparamget (pp, *f); o1 = popop(); o2 = popop(); if ((o2.o_type & OT_BASIC) == OT_STRING) { /* copy o2 onto dictionary to avoid overwriting it on stack * when o1 is pushed. we can get by with not worrying about o1 * as long as whatever code copies the string works when the * strings overlap. */ XINT oldtopd = topd; char *s2 = memneed (btoi (strlen (o2.o_val.v_s) + 1)); strcpy (s2, o2.o_val.v_s); o2.o_val.v_s = s2; pushop (&o1); pushop (&o2); topd = oldtopd; /* discard temp string area */ } else { pushop (&o1); pushop (&o2); } binop (OP_ADD); paramset (pp, *f); pp->p_flags |= P_SET; }
int apaGetTime(apa_ps2time_t *tm) { sceCdCLOCK cdtime; apa_ps2time_t timeBuf={ 0, 7, 6, 5, 4, 3, 2000 }; if(sceCdReadClock(&cdtime)!=0 && cdtime.stat==0) { timeBuf.sec=btoi(cdtime.second); timeBuf.min=btoi(cdtime.minute); timeBuf.hour=btoi(cdtime.hour); timeBuf.day=btoi(cdtime.day); timeBuf.month=btoi(cdtime.month & 0x7F); //The old CDVDMAN sceCdReadClock() function does not automatically file off the highest bit. timeBuf.year=btoi(cdtime.year)+2000; } memcpy(tm, &timeBuf, sizeof(apa_ps2time_t)); return 0; }
// read track // time: // byte 0 - minute // byte 1 - second // byte 2 - frame // uses bcd format long CDRreadTrack(unsigned char *time) { if (!IsCdHandleOpen()) { memset(cr.buf, 0, DATA_SIZE); return 0; } PRINTF("CDRreadTrack %d:%d:%d\n", btoi(time[0]), btoi(time[1]), btoi(time[2])); if (UseSubQ) memcpy(lastTime, time, 3); subqread = 0; cr.msf.cdmsf_min0 = btoi(time[0]); cr.msf.cdmsf_sec0 = btoi(time[1]); cr.msf.cdmsf_frame0 = btoi(time[2]); return fReadTrack(); }
void cdrInterrupt() { int i; unsigned char Irq = cdr.Irq; if (cdr.Stat) { CDR_INT(0x800); return; } cdr.Irq = 0xff; cdr.Ctrl&=~0x80; switch (Irq) { case CdlSync: SetResultSize(1); cdr.StatP|= 0x2; cdr.Result[0] = cdr.StatP; cdr.Stat = Acknowledge; break; case CdlNop: SetResultSize(1); cdr.Result[0] = cdr.StatP; cdr.Stat = Acknowledge; i = stat.Status; if (CDR_getStatus(&stat) != -1) { if (stat.Type == 0xff) cdr.Stat = DiskError; if (stat.Status & 0x10) { cdr.Stat = DiskError; cdr.Result[0]|= 0x11; cdr.Result[0]&=~0x02; } else if (i & 0x10) { cdr.StatP |= 0x2; cdr.Result[0]|= 0x2; CheckCdrom(); } } break; case CdlSetloc: cdr.CmdProcess = 0; SetResultSize(1); cdr.StatP|= 0x2; cdr.Result[0] = cdr.StatP; cdr.Stat = Acknowledge; break; case CdlPlay: cdr.CmdProcess = 0; SetResultSize(1); cdr.StatP|= 0x2; cdr.Result[0] = cdr.StatP; cdr.Stat = Acknowledge; cdr.StatP|= 0x80; // if ((cdr.Mode & 0x5) == 0x5) AddIrqQueue(REPPLAY, cdReadTime); break; case CdlForward: cdr.CmdProcess = 0; SetResultSize(1); cdr.StatP|= 0x2; cdr.Result[0] = cdr.StatP; cdr.Stat = Complete; break; case CdlBackward: cdr.CmdProcess = 0; SetResultSize(1); cdr.StatP|= 0x2; cdr.Result[0] = cdr.StatP; cdr.Stat = Complete; break; case CdlStandby: cdr.CmdProcess = 0; SetResultSize(1); cdr.StatP|= 0x2; cdr.Result[0] = cdr.StatP; cdr.Stat = Complete; break; case CdlStop: cdr.CmdProcess = 0; SetResultSize(1); cdr.StatP&=~0x2; cdr.Result[0] = cdr.StatP; cdr.Stat = Complete; // cdr.Stat = Acknowledge; break; case CdlPause: SetResultSize(1); cdr.Result[0] = cdr.StatP; cdr.Stat = Acknowledge; AddIrqQueue(CdlPause + 0x20, 0x800); cdr.Ctrl|= 0x80; break; case CdlPause + 0x20: SetResultSize(1); cdr.StatP&=~0x20; cdr.StatP|= 0x2; cdr.Result[0] = cdr.StatP; cdr.Stat = Complete; break; case CdlInit: SetResultSize(1); cdr.StatP = 0x2; cdr.Result[0] = cdr.StatP; cdr.Stat = Acknowledge; // if (!cdr.Init) { AddIrqQueue(CdlInit + 0x20, 0x800); // } break; case CdlInit + 0x20: SetResultSize(1); cdr.Result[0] = cdr.StatP; cdr.Stat = Complete; cdr.Init = 1; break; case CdlMute: SetResultSize(1); cdr.StatP|= 0x2; cdr.Result[0] = cdr.StatP; cdr.Stat = Acknowledge; break; case CdlDemute: SetResultSize(1); cdr.StatP|= 0x2; cdr.Result[0] = cdr.StatP; cdr.Stat = Acknowledge; break; case CdlSetfilter: SetResultSize(1); cdr.StatP|= 0x2; cdr.Result[0] = cdr.StatP; cdr.Stat = Acknowledge; break; case CdlSetmode: SetResultSize(1); cdr.StatP|= 0x2; cdr.Result[0] = cdr.StatP; cdr.Stat = Acknowledge; break; case CdlGetmode: SetResultSize(6); cdr.StatP|= 0x2; cdr.Result[0] = cdr.StatP; cdr.Result[1] = cdr.Mode; cdr.Result[2] = cdr.File; cdr.Result[3] = cdr.Channel; cdr.Result[4] = 0; cdr.Result[5] = 0; cdr.Stat = Acknowledge; break; case CdlGetlocL: SetResultSize(8); // for (i=0; i<8; i++) cdr.Result[i] = itob(cdr.Transfer[i]); for (i=0; i<8; i++) cdr.Result[i] = cdr.Transfer[i]; cdr.Stat = Acknowledge; break; case CdlGetlocP: SetResultSize(8); subq = (struct SubQ*) CDR_getBufferSub(); if (subq != NULL) { cdr.Result[0] = subq->TrackNumber; cdr.Result[1] = subq->IndexNumber; memcpy(cdr.Result+2, subq->TrackRelativeAddress, 3); memcpy(cdr.Result+5, subq->AbsoluteAddress, 3); } else { cdr.Result[0] = 1; cdr.Result[1] = 1; cdr.Result[2] = cdr.Prev[0]; cdr.Result[3] = itob((btoi(cdr.Prev[1])) - 2); cdr.Result[4] = cdr.Prev[2]; memcpy(cdr.Result+5, cdr.Prev, 3); } cdr.Stat = Acknowledge; break; case CdlGetTN: cdr.CmdProcess = 0; SetResultSize(3); cdr.StatP|= 0x2; cdr.Result[0] = cdr.StatP; if (CDR_getTN(cdr.ResultTN) == -1) { cdr.Stat = DiskError; cdr.Result[0]|= 0x01; } else { cdr.Stat = Acknowledge; cdr.Result[1] = itob(cdr.ResultTN[0]); cdr.Result[2] = itob(cdr.ResultTN[1]); } break; case CdlGetTD: cdr.CmdProcess = 0; cdr.Track = btoi(cdr.Param[0]); SetResultSize(4); cdr.StatP|= 0x2; if (CDR_getTD(cdr.Track, cdr.ResultTD) == -1) { cdr.Stat = DiskError; cdr.Result[0]|= 0x01; } else { cdr.Stat = Acknowledge; cdr.Result[0] = cdr.StatP; cdr.Result[1] = itob(cdr.ResultTD[2]); cdr.Result[2] = itob(cdr.ResultTD[1]); cdr.Result[3] = itob(cdr.ResultTD[0]); } break; case CdlSeekL: SetResultSize(1); cdr.StatP|= 0x2; cdr.Result[0] = cdr.StatP; cdr.StatP|= 0x40; cdr.Stat = Acknowledge; cdr.Seeked = 1; AddIrqQueue(CdlSeekL + 0x20, 0x800); break; case CdlSeekL + 0x20: SetResultSize(1); cdr.StatP|= 0x2; cdr.StatP&=~0x40; cdr.Result[0] = cdr.StatP; cdr.Stat = Complete; break; case CdlSeekP: SetResultSize(1); cdr.StatP|= 0x2; cdr.Result[0] = cdr.StatP; cdr.StatP|= 0x40; cdr.Stat = Acknowledge; AddIrqQueue(CdlSeekP + 0x20, 0x800); break; case CdlSeekP + 0x20: SetResultSize(1); cdr.StatP|= 0x2; cdr.StatP&=~0x40; cdr.Result[0] = cdr.StatP; cdr.Stat = Complete; break; case CdlTest: cdr.Stat = Acknowledge; switch (cdr.Param[0]) { case 0x20: // System Controller ROM Version SetResultSize(4); memcpy(cdr.Result, Test20, 4); break; case 0x22: SetResultSize(8); memcpy(cdr.Result, Test22, 4); break; case 0x23: case 0x24: SetResultSize(8); memcpy(cdr.Result, Test23, 4); break; } break; case CdlID: SetResultSize(1); cdr.StatP|= 0x2; cdr.Result[0] = cdr.StatP; cdr.Stat = Acknowledge; AddIrqQueue(CdlID + 0x20, 0x800); break; case CdlID + 0x20: SetResultSize(8); if (CDR_getStatus(&stat) == -1) { cdr.Result[0] = 0x00; // 0x00 Game CD cdr.Result[1] = 0x00; // 0x00 loads CD } else { if (stat.Type == 2) { cdr.Result[0] = 0x08; // 0x08 audio cd cdr.Result[1] = 0x10; // 0x10 enter cd player } else { cdr.Result[0] = 0x00; // 0x00 game CD cdr.Result[1] = 0x00; // 0x00 loads CD } } if (!LoadCdBios) cdr.Result[1] |= 0x80; //0x80 leads to the menu in the bios cdr.Result[2] = 0x00; cdr.Result[3] = 0x00; // strncpy((char *)&cdr.Result[4], "PCSX", 4); #ifdef HW_RVL strncpy((char *)&cdr.Result[4], "WSX ", 4); #else strncpy((char *)&cdr.Result[4], "GCSX", 4); #endif cdr.Stat = Complete; break; case CdlReset: SetResultSize(1); cdr.StatP = 0x2; cdr.Result[0] = cdr.StatP; cdr.Stat = Acknowledge; break; case CdlReadToc: SetResultSize(1); cdr.StatP|= 0x2; cdr.Result[0] = cdr.StatP; cdr.Stat = Acknowledge; AddIrqQueue(CdlReadToc + 0x20, 0x800); break; case CdlReadToc + 0x20: SetResultSize(1); cdr.StatP|= 0x2; cdr.Result[0] = cdr.StatP; cdr.Stat = Complete; break; case AUTOPAUSE: cdr.OCUP = 0; /* SetResultSize(1); StopCdda(); StopReading(); cdr.OCUP = 0; cdr.StatP&=~0x20; cdr.StatP|= 0x2; cdr.Result[0] = cdr.StatP; cdr.Stat = DataEnd; */ AddIrqQueue(CdlPause, 0x400); break; case READ_ACK: if (!cdr.Reading) return; SetResultSize(1); cdr.StatP|= 0x2; cdr.Result[0] = cdr.StatP; if (cdr.Seeked == 0) { cdr.Seeked = 1; cdr.StatP|= 0x40; } cdr.StatP|= 0x20; cdr.Stat = Acknowledge; ReadTrack(); // CDREAD_INT((cdr.Mode & 0x80) ? (cdReadTime / 2) : cdReadTime); CDREAD_INT(0x40000); break; case REPPLAY_ACK: cdr.Stat = Acknowledge; cdr.Result[0] = cdr.StatP; SetResultSize(1); AddIrqQueue(REPPLAY, cdReadTime); break; case REPPLAY: if ((cdr.Mode & 5) != 5) break; /* if (CDR_getStatus(&stat) == -1) { cdr.Result[0] = 0; cdr.Result[1] = 0; cdr.Result[2] = 0; cdr.Result[3] = 0; cdr.Result[4] = 0; cdr.Result[5] = 0; cdr.Result[6] = 0; cdr.Result[7] = 0; } else memcpy(cdr.Result, &stat.Track, 8); cdr.Stat = 1; SetResultSize(8); AddIrqQueue(REPPLAY_ACK, cdReadTime); */ break; case 0xff: return; default: cdr.Stat = Complete; break; } if (cdr.Stat != NoIntr && cdr.Reg2 != 0x18) { psxHu32ref(0x1070)|= SWAP32((u32)0x4); psxRegs.interrupt|= 0x80000000; } #ifdef CDR_LOG CDR_LOG("cdrInterrupt() Log: CDR Interrupt IRQ %x\n", Irq); #endif }
void cdrWrite1(u8 rt) { int i; CDVD_LOG("CD1 write: %x (%s)", rt, CmdName[rt]); cdr.Cmd = rt; cdr.OCUP = 0; #ifdef CDRCMD_DEBUG SysPrintf("CD1 write: %x (%s)", rt, CmdName[rt]); if (cdr.ParamC) { SysPrintf(" Param[%d] = {", cdr.ParamC); for (i=0;i<cdr.ParamC;i++) SysPrintf(" %x,", cdr.Param[i]); SysPrintf("}\n"); } else SysPrintf("\n"); #endif if (cdr.Ctrl & 0x1) return; switch(cdr.Cmd) { case CdlSync: cdr.Ctrl|= 0x80; cdr.Stat = NoIntr; AddIrqQueue(cdr.Cmd, 0x800); break; case CdlNop: cdr.Ctrl|= 0x80; cdr.Stat = NoIntr; AddIrqQueue(cdr.Cmd, 0x800); break; case CdlSetloc: StopReading(); for (i=0; i<3; i++) cdr.SetSector[i] = btoi(cdr.Param[i]); cdr.SetSector[3] = 0; if ((cdr.SetSector[0] | cdr.SetSector[1] | cdr.SetSector[2]) == 0) { *(u32 *)cdr.SetSector = *(u32 *)cdr.SetSectorSeek; } cdr.Ctrl|= 0x80; cdr.Stat = NoIntr; AddIrqQueue(cdr.Cmd, 0x800); break; case CdlPlay: cdr.Play = 1; cdr.Ctrl|= 0x80; cdr.Stat = NoIntr; AddIrqQueue(cdr.Cmd, 0x800); break; case CdlForward: if (cdr.CurTrack < 0xaa) cdr.CurTrack++; cdr.Ctrl|= 0x80; cdr.Stat = NoIntr; AddIrqQueue(cdr.Cmd, 0x800); break; case CdlBackward: if (cdr.CurTrack > 1) cdr.CurTrack--; cdr.Ctrl|= 0x80; cdr.Stat = NoIntr; AddIrqQueue(cdr.Cmd, 0x800); break; case CdlReadN: cdr.Irq = 0; StopReading(); cdr.Ctrl|= 0x80; cdr.Stat = NoIntr; StartReading(1); break; case CdlStandby: StopCdda(); StopReading(); cdr.Ctrl|= 0x80; cdr.Stat = NoIntr; AddIrqQueue(cdr.Cmd, 0x800); break; case CdlStop: StopCdda(); StopReading(); cdr.Ctrl|= 0x80; cdr.Stat = NoIntr; AddIrqQueue(cdr.Cmd, 0x800); break; case CdlPause: StopCdda(); StopReading(); cdr.Ctrl|= 0x80; cdr.Stat = NoIntr; AddIrqQueue(cdr.Cmd, 0x40000); break; case CdlReset: case CdlInit: StopCdda(); StopReading(); cdr.Ctrl|= 0x80; cdr.Stat = NoIntr; AddIrqQueue(cdr.Cmd, 0x800); break; case CdlMute: cdr.Muted = 0; cdr.Ctrl|= 0x80; cdr.Stat = NoIntr; AddIrqQueue(cdr.Cmd, 0x800); break; case CdlDemute: cdr.Muted = 1; cdr.Ctrl|= 0x80; cdr.Stat = NoIntr; AddIrqQueue(cdr.Cmd, 0x800); break; case CdlSetfilter: cdr.File = cdr.Param[0]; cdr.Channel = cdr.Param[1]; cdr.Ctrl|= 0x80; cdr.Stat = NoIntr; AddIrqQueue(cdr.Cmd, 0x800); break; case CdlSetmode: CDVD_LOG("Setmode %x", cdr.Param[0]); cdr.Mode = cdr.Param[0]; cdr.Ctrl|= 0x80; cdr.Stat = NoIntr; AddIrqQueue(cdr.Cmd, 0x800); break; case CdlGetmode: cdr.Ctrl|= 0x80; cdr.Stat = NoIntr; AddIrqQueue(cdr.Cmd, 0x800); break; case CdlGetlocL: cdr.Ctrl|= 0x80; cdr.Stat = NoIntr; AddIrqQueue(cdr.Cmd, 0x800); break; case CdlGetlocP: cdr.Ctrl|= 0x80; cdr.Stat = NoIntr; AddIrqQueue(cdr.Cmd, 0x800); break; case CdlGetTN: cdr.Ctrl|= 0x80; cdr.Stat = NoIntr; AddIrqQueue(cdr.Cmd, 0x800); break; case CdlGetTD: cdr.Ctrl|= 0x80; cdr.Stat = NoIntr; AddIrqQueue(cdr.Cmd, 0x800); break; case CdlSeekL: ((u32 *)cdr.SetSectorSeek)[0] = ((u32 *)cdr.SetSector)[0]; cdr.Ctrl|= 0x80; cdr.Stat = NoIntr; AddIrqQueue(cdr.Cmd, 0x800); break; case CdlSeekP: ((u32 *)cdr.SetSectorSeek)[0] = ((u32 *)cdr.SetSector)[0]; cdr.Ctrl|= 0x80; cdr.Stat = NoIntr; AddIrqQueue(cdr.Cmd, 0x800); break; case CdlTest: cdr.Ctrl|= 0x80; cdr.Stat = NoIntr; AddIrqQueue(cdr.Cmd, 0x800); break; case CdlID: cdr.Ctrl|= 0x80; cdr.Stat = NoIntr; AddIrqQueue(cdr.Cmd, 0x800); break; case CdlReadS: cdr.Irq = 0; StopReading(); cdr.Ctrl|= 0x80; cdr.Stat = NoIntr; StartReading(2); break; case CdlReadToc: cdr.Ctrl|= 0x80; cdr.Stat = NoIntr; AddIrqQueue(cdr.Cmd, 0x800); break; default: CDVD_LOG("Unknown Cmd: %x\n", cdr.Cmd); return; } if (cdr.Stat != NoIntr) iopIntcIrq( 2 ); }
void cdrInterrupt() { cdvdTD trackInfo; int i; u8 Irq = cdr.Irq; if (cdr.Stat) { CDR_INT(0x800); return; } cdr.Irq = 0xff; cdr.Ctrl&=~0x80; switch (Irq) { case CdlSync: SetResultSize(1); cdr.StatP|= 0x2; cdr.Result[0] = cdr.StatP; cdr.Stat = Acknowledge; break; case CdlNop: SetResultSize(1); cdr.Result[0] = cdr.StatP; cdr.Stat = Acknowledge; break; case CdlSetloc: cdr.CmdProcess = 0; SetResultSize(1); cdr.StatP|= 0x2; cdr.Result[0] = cdr.StatP; cdr.Stat = Acknowledge; break; case CdlPlay: cdr.CmdProcess = 0; SetResultSize(1); cdr.Result[0] = cdr.StatP; cdr.Stat = Acknowledge; cdr.StatP|= 0x82; break; case CdlForward: cdr.CmdProcess = 0; SetResultSize(1); cdr.StatP|= 0x2; cdr.Result[0] = cdr.StatP; cdr.Stat = Complete; break; case CdlBackward: cdr.CmdProcess = 0; SetResultSize(1); cdr.StatP|= 0x2; cdr.Result[0] = cdr.StatP; cdr.Stat = Complete; break; case CdlStandby: cdr.CmdProcess = 0; SetResultSize(1); cdr.StatP|= 0x2; cdr.Result[0] = cdr.StatP; cdr.Stat = Complete; break; case CdlStop: cdr.CmdProcess = 0; SetResultSize(1); cdr.StatP&=~0x2; cdr.Result[0] = cdr.StatP; cdr.Stat = Complete; // cdr.Stat = Acknowledge; break; case CdlPause: SetResultSize(1); cdr.Result[0] = cdr.StatP; cdr.Stat = Acknowledge; AddIrqQueue(CdlPause + 0x20, 0x800); break; case CdlPause + 0x20: SetResultSize(1); cdr.StatP&=~0x20; cdr.StatP|= 0x2; cdr.Result[0] = cdr.StatP; cdr.Stat = Complete; break; case CdlInit: SetResultSize(1); cdr.StatP = 0x2; cdr.Result[0] = cdr.StatP; cdr.Stat = Acknowledge; AddIrqQueue(CdlInit + 0x20, 0x800); break; case CdlInit + 0x20: SetResultSize(1); cdr.Result[0] = cdr.StatP; cdr.Stat = Complete; cdr.Init = 1; break; case CdlMute: SetResultSize(1); cdr.StatP|= 0x2; cdr.Result[0] = cdr.StatP; cdr.Stat = Acknowledge; break; case CdlDemute: SetResultSize(1); cdr.StatP|= 0x2; cdr.Result[0] = cdr.StatP; cdr.Stat = Acknowledge; break; case CdlSetfilter: SetResultSize(1); cdr.StatP|= 0x2; cdr.Result[0] = cdr.StatP; cdr.Stat = Acknowledge; break; case CdlSetmode: SetResultSize(1); cdr.StatP|= 0x2; cdr.Result[0] = cdr.StatP; cdr.Stat = Acknowledge; break; case CdlGetmode: SetResultSize(6); cdr.StatP|= 0x2; cdr.Result[0] = cdr.StatP; cdr.Result[1] = cdr.Mode; cdr.Result[2] = cdr.File; cdr.Result[3] = cdr.Channel; cdr.Result[4] = 0; cdr.Result[5] = 0; cdr.Stat = Acknowledge; break; case CdlGetlocL: SetResultSize(8); for (i=0; i<8; i++) cdr.Result[i] = cdr.Transfer[i]; cdr.Stat = Acknowledge; break; case CdlGetlocP: SetResultSize(8); cdr.Result[0] = 1; cdr.Result[1] = 1; cdr.Result[2] = cdr.Prev[0]; cdr.Result[3] = itob((btoi(cdr.Prev[1])) - 2); cdr.Result[4] = cdr.Prev[2]; cdr.Result[5] = cdr.Prev[0]; cdr.Result[6] = cdr.Prev[1]; cdr.Result[7] = cdr.Prev[2]; cdr.Stat = Acknowledge; break; case CdlGetTN: cdr.CmdProcess = 0; SetResultSize(3); cdr.StatP|= 0x2; cdr.Result[0] = cdr.StatP; if (CDVD->getTN(&cdr.ResultTN) == -1) { cdr.Stat = DiskError; cdr.Result[0]|= 0x01; } else { cdr.Stat = Acknowledge; cdr.Result[1] = itob(cdr.ResultTN.strack); cdr.Result[2] = itob(cdr.ResultTN.etrack); } break; case CdlGetTD: cdr.CmdProcess = 0; cdr.Track = btoi(cdr.Param[0]); SetResultSize(4); cdr.StatP|= 0x2; if (CDVD->getTD(cdr.Track, &trackInfo) == -1) { cdr.Stat = DiskError; cdr.Result[0]|= 0x01; } else { lsn_to_msf(cdr.ResultTD, trackInfo.lsn); cdr.Stat = Acknowledge; cdr.Result[0] = cdr.StatP; cdr.Result[1] = cdr.ResultTD[2]; cdr.Result[2] = cdr.ResultTD[1]; cdr.Result[3] = cdr.ResultTD[0]; } break; case CdlSeekL: SetResultSize(1); cdr.StatP|= 0x2; cdr.Result[0] = cdr.StatP; cdr.Stat = Acknowledge; AddIrqQueue(CdlSeekL + 0x20, 0x800); break; case CdlSeekL + 0x20: SetResultSize(1); cdr.StatP|= 0x2; cdr.Result[0] = cdr.StatP; cdr.Stat = Complete; break; case CdlSeekP: SetResultSize(1); cdr.StatP|= 0x2; cdr.Result[0] = cdr.StatP; cdr.Stat = Acknowledge; AddIrqQueue(CdlSeekP + 0x20, 0x800); break; case CdlSeekP + 0x20: SetResultSize(1); cdr.StatP|= 0x2; cdr.Result[0] = cdr.StatP; cdr.Stat = Complete; break; case CdlTest: cdr.Stat = Acknowledge; switch (cdr.Param[0]) { case 0x20: // System Controller ROM Version SetResultSize(4); *(int*)cdr.Result = *(int*)Test20; break; case 0x22: SetResultSize(8); *(int*)cdr.Result = *(int*)Test22; break; case 0x23: case 0x24: SetResultSize(8); *(int*)cdr.Result = *(int*)Test23; break; } break; case CdlID: SetResultSize(1); cdr.StatP|= 0x2; cdr.Result[0] = cdr.StatP; cdr.Stat = Acknowledge; AddIrqQueue(CdlID + 0x20, 0x800); break; case CdlID + 0x20: SetResultSize(8); cdr.Result[0] = 0x00; // 0x08 and cdr.Result[1]|0x10 : audio cd, enters cd player cdr.Result[1] = 0x00; // 0x80 leads to the menu in the bios, else loads CD if (!LoadCdBios) cdr.Result[1] |= 0x80; cdr.Result[2] = 0x00; cdr.Result[3] = 0x00; strncpy((char *)&cdr.Result[4], "PCSX", 4); cdr.Stat = Complete; break; case CdlReset: SetResultSize(1); cdr.StatP = 0x2; cdr.Result[0] = cdr.StatP; cdr.Stat = Acknowledge; break; case CdlReadToc: SetResultSize(1); cdr.StatP|= 0x2; cdr.Result[0] = cdr.StatP; cdr.Stat = Acknowledge; AddIrqQueue(CdlReadToc + 0x20, 0x800); break; case CdlReadToc + 0x20: SetResultSize(1); cdr.StatP|= 0x2; cdr.Result[0] = cdr.StatP; cdr.Stat = Complete; break; case AUTOPAUSE: cdr.OCUP = 0; AddIrqQueue(CdlPause, 0x400); break; case READ_ACK: if (!cdr.Reading) return; SetResultSize(1); cdr.StatP|= 0x2; cdr.Result[0] = cdr.StatP; cdr.Stat = Acknowledge; ReadTrack(); CDREAD_INT((cdr.Mode & 0x80) ? (cdReadTime / 2) : cdReadTime); break; case REPPLAY_ACK: cdr.Stat = Acknowledge; cdr.Result[0] = cdr.StatP; SetResultSize(1); AddIrqQueue(REPPLAY, cdReadTime); break; case REPPLAY: //if ((cdr.Mode & 5) != 5) break; break; case 0xff: return; default: cdr.Stat = Complete; break; } if (cdr.Stat != NoIntr && cdr.Reg2 != 0x18) psxHu32(0x1070)|= 0x4; CDVD_LOG("Cdr Interrupt %x\n", Irq); }
bool Card::GetFileList( const char* mask, Lst::Head< File > &file_list ) { int result, i; Dbg_MsgAssert( mask != NULL,( "Mask must be a valid search string. You may use wildcards\n" )); Dbg_MsgAssert( (((uint32)file_table)&63)==0, ("file_table not 64 byte aligned")); int CallNumber=0; while (true) { result = sceMcGetDir( m_port, m_slot, mask, CallNumber, vMAX_FILES_PER_DIRECTORY, file_table ); if( result != 0 ) { SetError( vUNKNOWN ); return 0; } int NumFilesReturned = wait_for_async_call_to_finish( this ); for( i = 0; i < NumFilesReturned; i++ ) { File *new_file; new_file = new File( 0, this ); strcpy( new_file->m_Filename, (char *) file_table[i].EntryName ); new_file->m_Size = file_table[i].FileSizeByte; new_file->m_Attribs = 0; if( file_table[i].AttrFile & sceMcFileAttrReadable ) { new_file->m_Attribs |= File::mATTRIB_READABLE; } if( file_table[i].AttrFile & sceMcFileAttrWriteable ) { new_file->m_Attribs |= File::mATTRIB_WRITEABLE; } if( file_table[i].AttrFile & sceMcFileAttrExecutable ) { new_file->m_Attribs |= File::mATTRIB_EXECUTABLE; } if( file_table[i].AttrFile & sceMcFileAttrDupProhibit ) { new_file->m_Attribs |= File::mATTRIB_DUP_PROHIBITED; } if( file_table[i].AttrFile & sceMcFileAttrSubdir ) { new_file->m_Attribs |= File::mATTRIB_DIRECTORY; } if( file_table[i].AttrFile & sceMcFileAttrClosed ) { new_file->m_Attribs |= File::mATTRIB_CLOSED; } if( file_table[i].AttrFile & sceMcFileAttrPDAExec ) { new_file->m_Attribs |= File::mATTRIB_PDA_APP; } if( file_table[i].AttrFile & sceMcFileAttrPS1 ) { new_file->m_Attribs |= File::mATTRIB_PS1_FILE; } sceCdCLOCK myClock; myClock.day=itob(file_table[i]._Modify.Day); myClock.hour=itob(file_table[i]._Modify.Hour); myClock.minute=itob(file_table[i]._Modify.Min); myClock.month=itob(file_table[i]._Modify.Month); myClock.second=itob(file_table[i]._Modify.Sec); myClock.year=itob(file_table[i]._Modify.Year%100); sceScfGetLocalTimefromRTC(&myClock); new_file->m_Modified.m_Seconds = btoi(myClock.second); new_file->m_Modified.m_Minutes = btoi(myClock.minute); new_file->m_Modified.m_Hour = btoi(myClock.hour); new_file->m_Modified.m_Day = btoi(myClock.day); new_file->m_Modified.m_Month = btoi(myClock.month); new_file->m_Modified.m_Year = btoi(myClock.year)+2000; myClock.day=itob(file_table[i]._Create.Day); myClock.hour=itob(file_table[i]._Create.Hour); myClock.minute=itob(file_table[i]._Create.Min); myClock.month=itob(file_table[i]._Create.Month); myClock.second=itob(file_table[i]._Create.Sec); myClock.year=itob(file_table[i]._Create.Year%100); sceScfGetLocalTimefromRTC(&myClock); new_file->m_Created.m_Seconds = btoi(myClock.second); new_file->m_Created.m_Minutes = btoi(myClock.minute); new_file->m_Created.m_Hour = btoi(myClock.hour); new_file->m_Created.m_Day = btoi(myClock.day); new_file->m_Created.m_Month = btoi(myClock.month); new_file->m_Created.m_Year = btoi(myClock.year)+2000; file_list.AddToTail( new_file ); } if (NumFilesReturned<vMAX_FILES_PER_DIRECTORY) { break; } ++CallNumber; } return true; }
uint32_t ec_hdr_section_get(uint8_t offset, int len) { uint8_t buf[HDR_SECT_MAX_SIZE]; eeprom_read(CFG_I2C_EEPROM_ADDR, offset, buf, len); return btoi(buf, len); }
DumpRegisters () { printf ("\nProgramCounter : %s base 10: %6d\n", ProgramCounter, btoi(ProgramCounter)) ; printf ("Accumulator : %s base 10: %6d\n", Accumulator, btoi(Accumulator)) ; printf ("InstructionReg : %s base 10: %6d\n", InstructionReg, btoi(InstructionReg)) ; printf ("TempInstr : %s base 10: %6d\n", TempInstruction, btoi(TempInstruction)) ; printf ("StackPointer : %s base 10: %6d\n", StackPointer, btoi(StackPointer)) ; printf ("ARegister : %s base 10: %6d\n", ARegister, btoi(ARegister)) ; printf ("BRegister : %s base 10: %6d\n", BRegister, btoi(BRegister)) ; printf ("CRegister : %s base 10: %6d\n", CRegister, btoi(CRegister)) ; printf ("DRegister : %s base 10: %6d\n", DRegister, btoi(DRegister)) ; printf ("ERegister : %s base 10: %6d\n", ERegister, btoi(ERegister)) ; printf ("FRegister : %s base 10: %6d\n", FRegister, btoi(FRegister)) ; }/* END DumpRegisters */
void cdrInterrupt() { u16 Irq = cdr.Irq; int no_busy_error = 0; int start_rotating = 0; int error = 0; int delay; // Reschedule IRQ if (cdr.Stat) { CDR_LOG_I("cdrom: stat hack: %02x %x\n", cdr.Irq, cdr.Stat); CDR_INT(0x1000); return; } cdr.Ctrl &= ~0x80; // default response SetResultSize(1); cdr.Result[0] = cdr.StatP; cdr.Stat = Acknowledge; if (cdr.IrqRepeated) { cdr.IrqRepeated = 0; if (cdr.eCycle > psxRegs.cycle) { CDR_INT(cdr.eCycle); goto finish; } } cdr.Irq = 0; switch (Irq) { case CdlSync: // TOOD: sometimes/always return error? break; case CdlNop: if (cdr.DriveState != DRIVESTATE_LID_OPEN) cdr.StatP &= ~STATUS_SHELLOPEN; no_busy_error = 1; break; case CdlSetloc: break; do_CdlPlay: case CdlPlay: StopCdda(); if (cdr.Seeked == SEEK_PENDING) { // XXX: wrong, should seek instead.. cdr.Seeked = SEEK_DONE; } if (cdr.SetlocPending) { memcpy(cdr.SetSectorPlay, cdr.SetSector, 4); cdr.SetlocPending = 0; } // BIOS CD Player // - Pause player, hit Track 01/02/../xx (Setloc issued!!) if (cdr.ParamC == 0 || cdr.Param[0] == 0) { CDR_LOG("PLAY Resume @ %d:%d:%d\n", cdr.SetSectorPlay[0], cdr.SetSectorPlay[1], cdr.SetSectorPlay[2]); } else { int track = btoi( cdr.Param[0] ); if (track <= cdr.ResultTN[1]) cdr.CurTrack = track; CDR_LOG("PLAY track %d\n", cdr.CurTrack); if (CDR_getTD((u8)cdr.CurTrack, cdr.ResultTD) != -1) { cdr.SetSectorPlay[0] = cdr.ResultTD[2]; cdr.SetSectorPlay[1] = cdr.ResultTD[1]; cdr.SetSectorPlay[2] = cdr.ResultTD[0]; } } /* Rayman: detect track changes - fixes logo freeze Twisted Metal 2: skip PREGAP + starting accurate SubQ - plays tracks without retry play Wild 9: skip PREGAP + starting accurate SubQ - plays tracks without retry play */ Find_CurTrack(cdr.SetSectorPlay); ReadTrack(cdr.SetSectorPlay); cdr.TrackChanged = FALSE; if (!Config.Cdda) CDR_play(cdr.SetSectorPlay); // Vib Ribbon: gameplay checks flag cdr.StatP &= ~STATUS_SEEK; cdr.Result[0] = cdr.StatP; cdr.StatP |= STATUS_PLAY; // BIOS player - set flag again cdr.Play = TRUE; CDRMISC_INT( cdReadTime ); start_rotating = 1; break; case CdlForward: // TODO: error 80 if stopped cdr.Stat = Complete; // GameShark CD Player: Calls 2x + Play 2x if( cdr.FastForward == 0 ) cdr.FastForward = 2; else cdr.FastForward++; cdr.FastBackward = 0; break; case CdlBackward: cdr.Stat = Complete; // GameShark CD Player: Calls 2x + Play 2x if( cdr.FastBackward == 0 ) cdr.FastBackward = 2; else cdr.FastBackward++; cdr.FastForward = 0; break; case CdlStandby: if (cdr.DriveState != DRIVESTATE_STOPPED) { error = ERROR_INVALIDARG; goto set_error; } AddIrqQueue(CdlStandby + 0x100, cdReadTime * 125 / 2); start_rotating = 1; break; case CdlStandby + 0x100: cdr.Stat = Complete; break; case CdlStop: if (cdr.Play) { // grab time for current track CDR_getTD((u8)(cdr.CurTrack), cdr.ResultTD); cdr.SetSectorPlay[0] = cdr.ResultTD[2]; cdr.SetSectorPlay[1] = cdr.ResultTD[1]; cdr.SetSectorPlay[2] = cdr.ResultTD[0]; } StopCdda(); StopReading(); delay = 0x800; if (cdr.DriveState == DRIVESTATE_STANDBY) delay = cdReadTime * 30 / 2; cdr.DriveState = DRIVESTATE_STOPPED; AddIrqQueue(CdlStop + 0x100, delay); break; case CdlStop + 0x100: cdr.StatP &= ~STATUS_ROTATING; cdr.Result[0] = cdr.StatP; cdr.Stat = Complete; break; case CdlPause: /* Gundam Battle Assault 2: much slower (*) - Fixes boot, gameplay Hokuto no Ken 2: slower - Fixes intro + subtitles InuYasha - Feudal Fairy Tale: slower - Fixes battles */ AddIrqQueue(CdlPause + 0x100, cdReadTime * 3); cdr.Ctrl |= 0x80; break; case CdlPause + 0x100: cdr.StatP &= ~STATUS_READ; cdr.Result[0] = cdr.StatP; cdr.Stat = Complete; break; case CdlInit: AddIrqQueue(CdlInit + 0x100, cdReadTime * 6); no_busy_error = 1; start_rotating = 1; break; case CdlInit + 0x100: cdr.Stat = Complete; break; case CdlMute: cdr.Muted = TRUE; break; case CdlDemute: cdr.Muted = FALSE; break; case CdlSetfilter: cdr.File = cdr.Param[0]; cdr.Channel = cdr.Param[1]; break; case CdlSetmode: no_busy_error = 1; break; case CdlGetmode: SetResultSize(6); cdr.Result[1] = cdr.Mode; cdr.Result[2] = cdr.File; cdr.Result[3] = cdr.Channel; cdr.Result[4] = 0; cdr.Result[5] = 0; no_busy_error = 1; break; case CdlGetlocL: SetResultSize(8); memcpy(cdr.Result, cdr.Transfer, 8); break; case CdlGetlocP: SetResultSize(8); memcpy(&cdr.Result, &cdr.subq, 8); if (!cdr.Play && !cdr.Reading) cdr.Result[1] = 0; // HACK? break; case CdlReadT: // SetSession? // really long AddIrqQueue(CdlReadT + 0x100, cdReadTime * 290 / 4); start_rotating = 1; break; case CdlReadT + 0x100: cdr.Stat = Complete; break; case CdlGetTN: SetResultSize(3); if (CDR_getTN(cdr.ResultTN) == -1) { cdr.Stat = DiskError; cdr.Result[0] |= STATUS_ERROR; } else { cdr.Stat = Acknowledge; cdr.Result[1] = itob(cdr.ResultTN[0]); cdr.Result[2] = itob(cdr.ResultTN[1]); } break; case CdlGetTD: cdr.Track = btoi(cdr.Param[0]); SetResultSize(4); if (CDR_getTD(cdr.Track, cdr.ResultTD) == -1) { cdr.Stat = DiskError; cdr.Result[0] |= STATUS_ERROR; } else { cdr.Stat = Acknowledge; cdr.Result[0] = cdr.StatP; cdr.Result[1] = itob(cdr.ResultTD[2]); cdr.Result[2] = itob(cdr.ResultTD[1]); cdr.Result[3] = itob(cdr.ResultTD[0]); } break; case CdlSeekL: case CdlSeekP: StopCdda(); StopReading(); cdr.StatP |= STATUS_SEEK; /* Crusaders of Might and Magic = 0.5x-4x - fix cutscene speech start Eggs of Steel = 2x-? - fix new game Medievil = ?-4x - fix cutscene speech Rockman X5 = 0.5-4x - fix capcom logo */ CDRMISC_INT(cdr.Seeked == SEEK_DONE ? 0x800 : cdReadTime * 4); cdr.Seeked = SEEK_PENDING; start_rotating = 1; break; case CdlTest: switch (cdr.Param[0]) { case 0x20: // System Controller ROM Version SetResultSize(4); memcpy(cdr.Result, Test20, 4); break; case 0x22: SetResultSize(8); memcpy(cdr.Result, Test22, 4); break; case 0x23: case 0x24: SetResultSize(8); memcpy(cdr.Result, Test23, 4); break; } no_busy_error = 1; break; case CdlID: AddIrqQueue(CdlID + 0x100, 20480); break; case CdlID + 0x100: SetResultSize(8); cdr.Result[0] = cdr.StatP; cdr.Result[1] = 0; cdr.Result[2] = 0; cdr.Result[3] = 0; // 0x10 - audio | 0x40 - disk missing | 0x80 - unlicensed if (CDR_getStatus(&stat) == -1 || stat.Type == 0 || stat.Type == 0xff) { cdr.Result[1] = 0xc0; } else { if (stat.Type == 2) cdr.Result[1] |= 0x10; if (CdromId[0] == '\0') cdr.Result[1] |= 0x80; } cdr.Result[0] |= (cdr.Result[1] >> 4) & 0x08; strncpy((char *)&cdr.Result[4], "PCSX", 4); cdr.Stat = Complete; break; case CdlReset: // yes, it really sets STATUS_SHELLOPEN cdr.StatP |= STATUS_SHELLOPEN; cdr.DriveState = DRIVESTATE_RESCAN_CD; CDRLID_INT(20480); no_busy_error = 1; start_rotating = 1; break; case CdlGetQ: // TODO? CDR_LOG_I("got CdlGetQ\n"); break; case CdlReadToc: AddIrqQueue(CdlReadToc + 0x100, cdReadTime * 180 / 4); no_busy_error = 1; start_rotating = 1; break; case CdlReadToc + 0x100: cdr.Stat = Complete; no_busy_error = 1; break; case CdlReadN: case CdlReadS: if (cdr.SetlocPending) { memcpy(cdr.SetSectorPlay, cdr.SetSector, 4); cdr.SetlocPending = 0; } Find_CurTrack(cdr.SetSectorPlay); if ((cdr.Mode & MODE_CDDA) && cdr.CurTrack > 1) // Read* acts as play for cdda tracks in cdda mode goto do_CdlPlay; cdr.Reading = 1; cdr.FirstSector = 1; // Fighting Force 2 - update subq time immediately // - fixes new game ReadTrack(cdr.SetSectorPlay); // Crusaders of Might and Magic - update getlocl now // - fixes cutscene speech { u8 *buf = CDR_getBuffer(); if (buf != NULL) memcpy(cdr.Transfer, buf, 8); } /* Duke Nukem: Land of the Babes - seek then delay read for one frame - fixes cutscenes C-12 - Final Resistance - doesn't like seek */ if (cdr.Seeked != SEEK_DONE) { cdr.StatP |= STATUS_SEEK; cdr.StatP &= ~STATUS_READ; // Crusaders of Might and Magic - use short time // - fix cutscene speech (startup) // ??? - use more accurate seek time later CDREAD_INT((cdr.Mode & 0x80) ? (cdReadTime / 2) : cdReadTime * 1); } else { cdr.StatP |= STATUS_READ; cdr.StatP &= ~STATUS_SEEK; CDREAD_INT((cdr.Mode & 0x80) ? (cdReadTime / 2) : cdReadTime * 1); } cdr.Result[0] = cdr.StatP; start_rotating = 1; break; default: CDR_LOG_I("Invalid command: %02x\n", Irq); error = ERROR_INVALIDCMD; // FALLTHROUGH set_error: SetResultSize(2); cdr.Result[0] = cdr.StatP | STATUS_ERROR; cdr.Result[1] = error; cdr.Stat = DiskError; break; } if (cdr.DriveState == DRIVESTATE_STOPPED && start_rotating) { cdr.DriveState = DRIVESTATE_STANDBY; cdr.StatP |= STATUS_ROTATING; } if (!no_busy_error) { switch (cdr.DriveState) { case DRIVESTATE_LID_OPEN: case DRIVESTATE_RESCAN_CD: case DRIVESTATE_PREPARE_CD: SetResultSize(2); cdr.Result[0] = cdr.StatP | STATUS_ERROR; cdr.Result[1] = ERROR_NOT_READY; cdr.Stat = DiskError; break; } } finish: setIrq(); cdr.ParamC = 0; #ifdef CDR_LOG_CMD_IRQ { int i; SysPrintf("CDR IRQ %d cmd %02x stat %02x: ", !!(cdr.Stat & cdr.Reg2), Irq, cdr.Stat); for (i = 0; i < cdr.ResultC; i++) SysPrintf("%02x ", cdr.Result[i]); SysPrintf("\n"); } #endif }
// two byte date/time, add to value void GetTime(int *value, const byte* date, int& i) { *value += btoi(date[i++]) * 10; *value += btoi(date[i++]); }
static int handlepbp(const char *isofile) { struct { unsigned int sig; unsigned int dontcare[8]; unsigned int psar_offs; } pbp_hdr; struct { unsigned char type; unsigned char pad0; unsigned char track; char index0[3]; char pad1; char index1[3]; } toc_entry; struct { unsigned int offset; unsigned int size; unsigned int dontcare[6]; } index_entry; char psar_sig[11]; unsigned int t, cd_length, cdimg_base; unsigned int offsettab[8], psisoimg_offs; const char *ext = NULL; int i, ret; if (strlen(isofile) >= 4) ext = isofile + strlen(isofile) - 4; if (ext == NULL || (strcmp(ext, ".pbp") != 0 && strcmp(ext, ".PBP") != 0)) return -1; numtracks = 0; ret = fread(&pbp_hdr, 1, sizeof(pbp_hdr), cdHandle); if (ret != sizeof(pbp_hdr)) { SysPrintf("failed to read pbp\n"); goto fail_io; } ret = fseek(cdHandle, pbp_hdr.psar_offs, SEEK_SET); if (ret != 0) { SysPrintf("failed to seek to %x\n", pbp_hdr.psar_offs); goto fail_io; } psisoimg_offs = pbp_hdr.psar_offs; fread(psar_sig, 1, sizeof(psar_sig), cdHandle); psar_sig[10] = 0; if (strcmp(psar_sig, "PSTITLEIMG") == 0) { // multidisk image? ret = fseek(cdHandle, pbp_hdr.psar_offs + 0x200, SEEK_SET); if (ret != 0) { SysPrintf("failed to seek to %x\n", pbp_hdr.psar_offs + 0x200); goto fail_io; } if (fread(&offsettab, 1, sizeof(offsettab), cdHandle) != sizeof(offsettab)) { SysPrintf("failed to read offsettab\n"); goto fail_io; } for (i = 0; i < sizeof(offsettab) / sizeof(offsettab[0]); i++) { if (offsettab[i] == 0) break; } cdrIsoMultidiskCount = i; if (cdrIsoMultidiskCount == 0) { SysPrintf("multidisk eboot has 0 images?\n"); goto fail_io; } if (cdrIsoMultidiskSelect >= cdrIsoMultidiskCount) cdrIsoMultidiskSelect = 0; psisoimg_offs += offsettab[cdrIsoMultidiskSelect]; ret = fseek(cdHandle, psisoimg_offs, SEEK_SET); if (ret != 0) { SysPrintf("failed to seek to %x\n", psisoimg_offs); goto fail_io; } fread(psar_sig, 1, sizeof(psar_sig), cdHandle); psar_sig[10] = 0; } if (strcmp(psar_sig, "PSISOIMG00") != 0) { SysPrintf("bad psar_sig: %s\n", psar_sig); goto fail_io; } // seek to TOC ret = fseek(cdHandle, psisoimg_offs + 0x800, SEEK_SET); if (ret != 0) { SysPrintf("failed to seek to %x\n", psisoimg_offs + 0x800); goto fail_io; } // first 3 entries are special fseek(cdHandle, sizeof(toc_entry), SEEK_CUR); fread(&toc_entry, 1, sizeof(toc_entry), cdHandle); numtracks = btoi(toc_entry.index1[0]); fread(&toc_entry, 1, sizeof(toc_entry), cdHandle); cd_length = btoi(toc_entry.index1[0]) * 60 * 75 + btoi(toc_entry.index1[1]) * 75 + btoi(toc_entry.index1[2]); for (i = 1; i <= numtracks; i++) { fread(&toc_entry, 1, sizeof(toc_entry), cdHandle); ti[i].type = (toc_entry.type == 1) ? CDDA : DATA; ti[i].start_offset = btoi(toc_entry.index0[0]) * 60 * 75 + btoi(toc_entry.index0[1]) * 75 + btoi(toc_entry.index0[2]); ti[i].start_offset *= 2352; ti[i].start[0] = btoi(toc_entry.index1[0]); ti[i].start[1] = btoi(toc_entry.index1[1]); ti[i].start[2] = btoi(toc_entry.index1[2]); if (i > 1) { t = msf2sec(ti[i].start) - msf2sec(ti[i - 1].start); sec2msf(t, ti[i - 1].length); } } t = cd_length - ti[numtracks].start_offset / 2352; sec2msf(t, ti[numtracks].length); // seek to ISO index ret = fseek(cdHandle, psisoimg_offs + 0x4000, SEEK_SET); if (ret != 0) { SysPrintf("failed to seek to ISO index\n"); goto fail_io; } compr_img = calloc(1, sizeof(*compr_img)); if (compr_img == NULL) goto fail_io; compr_img->block_shift = 4; compr_img->current_block = (unsigned int)-1; compr_img->index_len = (0x100000 - 0x4000) / sizeof(index_entry); compr_img->index_table = malloc((compr_img->index_len + 1) * sizeof(compr_img->index_table[0])); if (compr_img->index_table == NULL) goto fail_io; cdimg_base = psisoimg_offs + 0x100000; for (i = 0; i < compr_img->index_len; i++) { ret = fread(&index_entry, 1, sizeof(index_entry), cdHandle); if (ret != sizeof(index_entry)) { SysPrintf("failed to read index_entry #%d\n", i); goto fail_index; } if (index_entry.size == 0) break; compr_img->index_table[i] = cdimg_base + index_entry.offset; } compr_img->index_table[i] = cdimg_base + index_entry.offset + index_entry.size; return 0; fail_index: free(compr_img->index_table); compr_img->index_table = NULL; fail_io: if (compr_img != NULL) { free(compr_img); compr_img = NULL; } return -1; }
static int parsepbp(const char *isofile) { struct { unsigned int sig; unsigned int dontcare[8]; unsigned int psar_offs; } pbp_hdr; struct { unsigned char type; unsigned char pad0; unsigned char track; char index0[3]; char pad1; char index1[3]; } toc_entry; struct { unsigned int offset; unsigned int size; unsigned int dontcare[6]; } index_entry; char psar_sig[9]; unsigned int t, cd_length, cdimg_base; const char *ext = NULL; int i, ret; if (strlen(isofile) >= 4) ext = isofile + strlen(isofile) - 4; if (ext == NULL || (strcmp(ext, ".pbp") != 0 && strcmp(ext, ".PBP") != 0)) return -1; numtracks = 0; ret = fread(&pbp_hdr, 1, sizeof(pbp_hdr), cdHandle); if (ret != sizeof(pbp_hdr)) { fprintf(stderr, "failed to read pbp\n"); goto fail_io; } ret = fseek(cdHandle, pbp_hdr.psar_offs, SEEK_SET); if (ret != 0) { fprintf(stderr, "failed to seek to %x\n", pbp_hdr.psar_offs); goto fail_io; } fread(psar_sig, 1, sizeof(psar_sig), cdHandle); psar_sig[8] = 0; if (strcmp(psar_sig, "PSISOIMG") != 0) { fprintf(stderr, "bad psar_sig: %s\n", psar_sig); goto fail_io; } // seek to TOC ret = fseek(cdHandle, pbp_hdr.psar_offs + 0x800, SEEK_SET); if (ret != 0) { fprintf(stderr, "failed to seek to %x\n", pbp_hdr.psar_offs); goto fail_io; } // first 3 entries are special fseek(cdHandle, sizeof(toc_entry), SEEK_CUR); fread(&toc_entry, 1, sizeof(toc_entry), cdHandle); numtracks = btoi(toc_entry.index1[0]); fread(&toc_entry, 1, sizeof(toc_entry), cdHandle); cd_length = btoi(toc_entry.index1[0]) * 60 * 75 + btoi(toc_entry.index1[1]) * 75 + btoi(toc_entry.index1[2]); for (i = 1; i <= numtracks; i++) { fread(&toc_entry, 1, sizeof(toc_entry), cdHandle); ti[i].type = (toc_entry.type == 1) ? trackinfo::CDDA : trackinfo::DATA; ti[i].start_offset = btoi(toc_entry.index0[0]) * 60 * 75 + btoi(toc_entry.index0[1]) * 75 + btoi(toc_entry.index0[2]); ti[i].start[0] = btoi(toc_entry.index1[0]); ti[i].start[1] = btoi(toc_entry.index1[1]); ti[i].start[2] = btoi(toc_entry.index1[2]); if (i > 1) { t = msf2sec((char *)ti[i].start) - msf2sec((char *)ti[i - 1].start); sec2msf(t, (char *)ti[i - 1].length); } } t = cd_length - ti[numtracks].start_offset; sec2msf(t, (char *)ti[numtracks].length); // seek to ISO index ret = fseek(cdHandle, pbp_hdr.psar_offs + 0x4000, SEEK_SET); if (ret != 0) { fprintf(stderr, "failed to seek to ISO index\n"); goto fail_io; } compr_img = (struct compr_img_struct *)calloc(1, sizeof(*compr_img)); if (compr_img == NULL) goto fail_io; compr_img->current_block = (unsigned int)-1; compr_img->index_len = (0x100000 - 0x4000) / sizeof(index_entry); compr_img->index_table = (u32 *)malloc((compr_img->index_len + 1) * sizeof(compr_img->index_table[0])); if (compr_img->index_table == NULL) goto fail_io; cdimg_base = pbp_hdr.psar_offs + 0x100000; for (i = 0; i < compr_img->index_len; i++) { ret = fread(&index_entry, 1, sizeof(index_entry), cdHandle); if (ret != sizeof(index_entry)) { fprintf(stderr, "failed to read index_entry #%d\n", i); goto fail_index; } if (index_entry.size == 0) break; compr_img->index_table[i] = cdimg_base + index_entry.offset; } compr_img->index_table[i] = cdimg_base + index_entry.offset + index_entry.size; return 0; fail_index: free(compr_img->index_table); compr_img->index_table = NULL; fail_io: return -1; }
void cdrWrite1(unsigned char rt) { int i; #ifdef CDR_LOG CDR_LOG("cdrWrite1() Log: CD1 write: %x (%s)\n", rt, CmdName[rt]); #endif // psxHu8(0x1801) = rt; cdr.Cmd = rt; cdr.OCUP = 0; #ifdef CDRCMD_DEBUG SysPrintf("cdrWrite1() Log: CD1 write: %x (%s)", rt, CmdName[rt]); if (cdr.ParamC) { SysPrintf(" Param[%d] = {", cdr.ParamC); for (i=0;i<cdr.ParamC;i++) SysPrintf(" %x,", cdr.Param[i]); SysPrintf("}\n"); } else SysPrintf("\n"); #endif if (cdr.Ctrl & 0x1) return; switch(cdr.Cmd) { case CdlSync: cdr.Ctrl|= 0x80; cdr.Stat = NoIntr; AddIrqQueue(cdr.Cmd, 0x800); break; case CdlNop: cdr.Ctrl|= 0x80; cdr.Stat = NoIntr; AddIrqQueue(cdr.Cmd, 0x800); break; case CdlSetloc: StopReading(); cdr.Seeked = 0; for (i=0; i<3; i++) cdr.SetSector[i] = btoi(cdr.Param[i]); cdr.SetSector[3] = 0; /* if ((cdr.SetSector[0] | cdr.SetSector[1] | cdr.SetSector[2]) == 0) { *(u32 *)cdr.SetSector = *(u32 *)cdr.SetSectorSeek; }*/ cdr.Ctrl|= 0x80; cdr.Stat = NoIntr; AddIrqQueue(cdr.Cmd, 0x800); break; case CdlPlay: if (!cdr.SetSector[0] && !cdr.SetSector[1] && !cdr.SetSector[2]) { if (CDR_getTN(cdr.ResultTN) != -1) { if (cdr.CurTrack > cdr.ResultTN[1]) cdr.CurTrack = cdr.ResultTN[1]; if (CDR_getTD((unsigned char)(cdr.CurTrack), cdr.ResultTD) != -1) { int tmp = cdr.ResultTD[2]; cdr.ResultTD[2] = cdr.ResultTD[0]; cdr.ResultTD[0] = tmp; if (!Config.Cdda) CDR_play(cdr.ResultTD); } } } else if (!Config.Cdda) CDR_play(cdr.SetSector); cdr.Play = 1; cdr.Ctrl|= 0x80; cdr.Stat = NoIntr; AddIrqQueue(cdr.Cmd, 0x800); break; case CdlForward: if (cdr.CurTrack < 0xaa) cdr.CurTrack++; cdr.Ctrl|= 0x80; cdr.Stat = NoIntr; AddIrqQueue(cdr.Cmd, 0x800); break; case CdlBackward: if (cdr.CurTrack > 1) cdr.CurTrack--; cdr.Ctrl|= 0x80; cdr.Stat = NoIntr; AddIrqQueue(cdr.Cmd, 0x800); break; case CdlReadN: cdr.Irq = 0; StopReading(); cdr.Ctrl|= 0x80; cdr.Stat = NoIntr; StartReading(1); break; case CdlStandby: StopCdda(); StopReading(); cdr.Ctrl|= 0x80; cdr.Stat = NoIntr; AddIrqQueue(cdr.Cmd, 0x800); break; case CdlStop: StopCdda(); StopReading(); cdr.Ctrl|= 0x80; cdr.Stat = NoIntr; AddIrqQueue(cdr.Cmd, 0x800); break; case CdlPause: StopCdda(); StopReading(); cdr.Ctrl|= 0x80; cdr.Stat = NoIntr; AddIrqQueue(cdr.Cmd, 0x40000); break; case CdlReset: case CdlInit: StopCdda(); StopReading(); cdr.Ctrl|= 0x80; cdr.Stat = NoIntr; AddIrqQueue(cdr.Cmd, 0x800); break; case CdlMute: cdr.Muted = 0; cdr.Ctrl|= 0x80; cdr.Stat = NoIntr; AddIrqQueue(cdr.Cmd, 0x800); break; case CdlDemute: cdr.Muted = 1; cdr.Ctrl|= 0x80; cdr.Stat = NoIntr; AddIrqQueue(cdr.Cmd, 0x800); break; case CdlSetfilter: cdr.File = cdr.Param[0]; cdr.Channel = cdr.Param[1]; cdr.Ctrl|= 0x80; cdr.Stat = NoIntr; AddIrqQueue(cdr.Cmd, 0x800); break; case CdlSetmode: #ifdef CDR_LOG CDR_LOG("cdrWrite1() Log: Setmode %x\n", cdr.Param[0]); #endif cdr.Mode = cdr.Param[0]; cdr.Ctrl|= 0x80; cdr.Stat = NoIntr; AddIrqQueue(cdr.Cmd, 0x800); break; case CdlGetmode: cdr.Ctrl|= 0x80; cdr.Stat = NoIntr; AddIrqQueue(cdr.Cmd, 0x800); break; case CdlGetlocL: cdr.Ctrl|= 0x80; cdr.Stat = NoIntr; AddIrqQueue(cdr.Cmd, 0x800); break; case CdlGetlocP: cdr.Ctrl|= 0x80; cdr.Stat = NoIntr; AddIrqQueue(cdr.Cmd, 0x800); break; case CdlGetTN: cdr.Ctrl|= 0x80; cdr.Stat = NoIntr; AddIrqQueue(cdr.Cmd, 0x800); break; case CdlGetTD: cdr.Ctrl|= 0x80; cdr.Stat = NoIntr; AddIrqQueue(cdr.Cmd, 0x800); break; case CdlSeekL: // ((u32 *)cdr.SetSectorSeek)[0] = ((u32 *)cdr.SetSector)[0]; cdr.Ctrl|= 0x80; cdr.Stat = NoIntr; AddIrqQueue(cdr.Cmd, 0x800); break; case CdlSeekP: // ((u32 *)cdr.SetSectorSeek)[0] = ((u32 *)cdr.SetSector)[0]; cdr.Ctrl|= 0x80; cdr.Stat = NoIntr; AddIrqQueue(cdr.Cmd, 0x800); break; case CdlTest: cdr.Ctrl|= 0x80; cdr.Stat = NoIntr; AddIrqQueue(cdr.Cmd, 0x800); break; case CdlID: cdr.Ctrl|= 0x80; cdr.Stat = NoIntr; AddIrqQueue(cdr.Cmd, 0x800); break; case CdlReadS: cdr.Irq = 0; StopReading(); cdr.Ctrl|= 0x80; cdr.Stat = NoIntr; StartReading(2); break; case CdlReadToc: cdr.Ctrl|= 0x80; cdr.Stat = NoIntr; AddIrqQueue(cdr.Cmd, 0x800); break; default: #ifdef CDR_LOG CDR_LOG("cdrWrite1() Log: Unknown command: %x\n", cdr.Cmd); #endif return; } if (cdr.Stat != NoIntr) { psxHu32ref(0x1070)|= SWAP32((u32)0x4); psxRegs.interrupt|= 0x80000000; } }
char* getpaddr(int level, int recordbit, int pagebit, char* logiaddr) { ///生成页表 int numppage = pow(2, pagebit-recordbit); //一级页表存储数目 int level1len = ADDRSPACEBIT - pagebit - (level - 1) * recordbit; double level1num = 0; int i = 0, j = 0, k = 0; for (i = 0; i < level1len; i++) { level1num += pow(2, i); } //总页表存储数目 //每一级页表数 long int* numplevel = (long int*)malloc(level * sizeof(long int)); long int totalnum = level1num; numplevel[0] = level1num; for (i = 1; i < level; i++) { totalnum += numplevel[i - 1] * 1024; numplevel[i] = totalnum - numplevel[i - 1]; } int logiclen = ADDRSPACEBIT - pagebit; int MAX = 0; for (i = 0; i < logiclen; i++) { MAX += pow(2, i); } //生成页表 srand((unsigned)time(NULL)); int* page = (int *)malloc(totalnum * sizeof(int)); int p = 0;//填入指针 i = 0; while(i < level) { if (i == 0) { for (j = 0; j < numplevel[0]; j++) { page[p] = level1num + (j - 1) * numppage; p++; } } else if (i == level - 1) { for (j = 0; j < numplevel[i]; j++) { page[p] = rand()%MAX; ///question p++; } } else { for (j = 0; j < numplevel[i]; j++) { int offset = 0; for (k = 0; k < i - 1; k++) { offset += numplevel[k]; } page[p] = offset; ///question p++; } } i++; } ///查询 int ptr = 0;//查询指针 char* bits = bmapo(logiaddr, "b"); int endlevel1 = ADDRSPACEBIT - pagebit - (level - 1) * recordbit; char* level1 = (char*)malloc((endlevel1 - 0 + 1) * sizeof(char)); memcpy(level1, bits, endlevel1 - 0); level1[endlevel1 - 0] = '\0'; ptr = page[btoi(level1)];//查表 for (i = 0; i < level - 1; i++) { char* level = substring(bits, i * pagebit + endlevel1, (i + 1) * pagebit + endlevel1); ptr = page[btoi(level) + ptr];//查表 } char *temp = itob(ptr); temp = bmapo(temp, "x"); char result[64] = "0x"; strncat(result, temp, strlen(temp)); return result; }