自学教程：C++ MDFN_printf函数代码示例

// Return FALSE on fatal error(IPS file found but couldn't be applied),// or TRUE on success(IPS patching succeeded, or IPS file not found).static bool LoadIPS(MDFNFILE &GameFile, const char *path){    FILE *IPSFile;    MDFN_printf(_("Applying IPS file /"%s/".../n"), path);    IPSFile = fopen(path, "rb");    if(!IPSFile)    {        ErrnoHolder ene(errno);        MDFN_printf(_("Failed: %s/n"), ene.StrError());        if(ene.Errno() == ENOENT)            return(1);        else        {            MDFN_PrintError(_("Error opening IPS file: %s/n"), ene.StrError());            return(0);        }    }    if(!GameFile.ApplyIPS(IPSFile))    {        fclose(IPSFile);        return(0);    }    fclose(IPSFile);    return(1);}

static int Load(const char *name, MDFNFILE *fp){   lynxie = new CSystem(GET_FDATA_PTR(fp), GET_FSIZE_PTR(fp)); int rot = lynxie->CartGetRotate(); if(rot == CART_ROTATE_LEFT) MDFNGameInfo->rotated = MDFN_ROTATE270; else if(rot == CART_ROTATE_RIGHT) MDFNGameInfo->rotated = MDFN_ROTATE90; gAudioEnabled = 1; memcpy(MDFNGameInfo->MD5, lynxie->mCart->MD5, 16); MDFNGameInfo->GameSetMD5Valid = FALSE; MDFN_printf(_("ROM:       %dKiB/n"), (lynxie->mCart->InfoROMSize + 1023) / 1024); MDFN_printf(_("ROM CRC32: 0x%08x/n"), lynxie->mCart->CRC32()); MDFN_printf(_("ROM MD5:   0x%s/n"), md5_context::asciistr(MDFNGameInfo->MD5, 0).c_str()); MDFNGameInfo->fps = (uint32)(59.8 * 65536 * 256); if(MDFN_GetSettingB("lynx.lowpass")) {  lynxie->mMikie->miksynth.treble_eq(-35); } else {  lynxie->mMikie->miksynth.treble_eq(0); } return(1);}

static void LoadCPalette(const char *syspalname, uint8 **ptr, uint32 num_entries){ std::string colormap_fn = MDFN_MakeFName(MDFNMKF_PALETTE, 0, syspalname).c_str(); MDFN_printf(_("Loading custom palette from /"%s/".../n"),  colormap_fn.c_str()); MDFN_indent(1); try {  FileStream fp(colormap_fn.c_str(), FileStream::MODE_READ);  *ptr = new uint8[num_entries * 3];  fp.read(*ptr, num_entries * 3); } catch(MDFN_Error &e) {  MDFN_printf(_("Error: %s/n"), e.what());  MDFN_indent(-1);  if(e.GetErrno() != ENOENT)   throw;  return; } catch(std::exception &e) {  MDFN_printf(_("Error: %s/n"), e.what());  MDFN_indent(-1);  throw; } MDFN_indent(-1);}

static void DINF(Stream *fp){ union {  struct  {   char name[100];   uint8 raw_date[4];   char method[100];  };  uint8 raw[100 + 4 + 100]; } dinf; uint8 d, m; uint16 y; fp->read(dinf.raw, sizeof(dinf.raw)); d = dinf.raw_date[0]; m = dinf.raw_date[1]; y = MDFN_de16lsb(&dinf.raw_date[2]); dinf.name[99] = dinf.method[99] = 0; MDFN_RemoveControlChars(dinf.name); MDFN_RemoveControlChars(dinf.method); MDFN_printf(_("Dumped by: %s/n"), dinf.name); MDFN_printf(_("Dumped with: %s/n"), dinf.method); {  const char* months[12]={_("January"),_("February"),_("March"),_("April"),_("May"),_("June"),_("July"),		    _("August"),_("September"),_("October"),_("November"),_("December")};  MDFN_printf(_("Dumped on: %s %d, %d/n"),months[(m-1)%12],d,y); }}

bool CDIF_DumpCD(const char *fn){ FILE *fp; if(!(fp = fopen(fn, "wb"))) {  ErrnoHolder ene(errno);  MDFN_printf("File open error: %s/n", ene.StrError());  return(0); } for(long long i = 0; i < toc.tracks[100].lba; i++) {  uint8 buf[2352 + 96];  CDIF_ReadRawSector(buf, i);  if(fwrite(buf, 1, 2352 + 96, fp) != 2352 + 96)  {   ErrnoHolder ene(errno);   MDFN_printf("File write error: %s/n", ene.StrError());  } } if(fclose(fp)) {  ErrnoHolder ene(errno);  MDFN_printf("fclose error: %s/n", ene.StrError()); } return(1);}

void MDFNFILE::ApplyIPS(Stream *ips){//// If the stream is not a MemoryStream, turn it into one.////if(!(str->attributes() & Stream::ATTRIBUTE_WRITEABLE))    if(dynamic_cast<MemoryStream*>(str.get()) == nullptr)    {        str.reset(new MemoryStream(str.release(), MaxROMImageSize));    }    {        MDFN_AutoIndent aind(1);        uint32 count;        count = IPSPatcher::Apply(ips, str.get());        MDFN_printf(_("IPS EOF:  Did %u patches/n/n"), count);        if(ips->tell() < ips->size())        {            MDFN_AutoIndent aindw(1);            MDFN_printf(_("Warning:  trailing unused data in IPS file./n"));        }    }}

//=============================================================================static void rom_hack(void){	//=============================	// SPECIFIC ROM HACKS !	//=============================	//"Neo-Neo! V1.0 (PD)"	if (MATCH_CATALOG(0, 16))	{		ngpc_rom.data[0x23] = 0x10;	// Fix rom header		MDFN_printf("HACK: /"Neo-Neo! V1.0 (PD)/"/n");	}	//"Cool Cool Jam SAMPLE (U)"	if (MATCH_CATALOG(4660, 161))	{		ngpc_rom.data[0x23] = 0x10;	// Fix rom header		MDFN_printf("HACK: /"Cool Cool Jam SAMPLE (U)/"/n");	}	//"Dokodemo Mahjong (J)"	if (MATCH_CATALOG(51, 33))	{		ngpc_rom.data[0x23] = 0x00;	// Fix rom header		MDFN_printf("HACK: /"Dokodemo Mahjong (J)/"/n");	}}

static bool cdif_open_sub(const char *device_name){ MDFN_printf(_("Loading %s.../n/n"), device_name ? device_name : _("PHYSICAL CDROM DISC")); MDFN_indent(1); if(!(p_cdrfile = cdrfile_open(device_name))) {  MDFN_indent(-1);  return(0); } CD_Info.NumTracks = cdrfile_get_num_tracks(p_cdrfile); if(CD_Info.NumTracks < 1 || CD_Info.NumTracks > 100) {  MDFN_indent(-1);  return(0); } CD_Info.FirstTrack = cdrfile_get_first_track_num(p_cdrfile); for(track_t track = CD_Info.FirstTrack; track < CD_Info.FirstTrack + CD_Info.NumTracks; track++) {  CD_Info.Tracks[track].LSN = cdrfile_get_track_lsn(p_cdrfile, track);  CD_Info.Tracks[track].Format = cdrfile_get_track_format(p_cdrfile, track);  MDFN_printf(_("Track %2d, LSN: %6d %s/n"), track, CD_Info.Tracks[track].LSN, track_format2str[CD_Info.Tracks[track].Format]); } MDFN_indent(-1); return(1);}

static bool LoadCPalette(const char *syspalname, uint8 **ptr, uint32 num_entries){ std::string colormap_fn = MDFN_MakeFName(MDFNMKF_PALETTE, 0, syspalname).c_str(); MDFN_printf(_("Loading custom palette from /"%s/".../n"),  colormap_fn.c_str()); MDFN_indent(1); *ptr = NULL; try {  FileStream fp(colormap_fn.c_str(), FileStream::MODE_READ);  if(!(*ptr = (uint8 *)MDFN_malloc(num_entries * 3, _("custom color map"))))  {   MDFN_indent(-1);   return(false);  }  fp.read(*ptr, num_entries * 3); } catch(MDFN_Error &e) {  if(*ptr)  {   MDFN_free(*ptr);   *ptr = NULL;  }  MDFN_printf(_("Error: %s/n"), e.what());  MDFN_indent(-1);  return(e.GetErrno() == ENOENT);        // Return fatal error if it's an error other than the file not being found. } catch(std::exception &e) {  if(*ptr)  {   MDFN_free(*ptr);   *ptr = NULL;  }  MDFN_printf(_("Error: %s/n"), e.what());  MDFN_indent(-1);  return(false); } MDFN_indent(-1); return(true);}

static void Load(MDFNFILE *fp){ try {  const uint64 fp_size = fp->size();  if(fp_size > 1024 * 1024 * 8) // 4MiB maximum ROM size, 2* to be a little tolerant of garbage.   throw MDFN_Error(0, _("NGP/NGPC ROM image is too large."));  ngpc_rom.length = fp_size;  ngpc_rom.data = new uint8[ngpc_rom.length];  fp->read(ngpc_rom.data, ngpc_rom.length);  md5_context md5;  md5.starts();  md5.update(ngpc_rom.data, ngpc_rom.length);  md5.finish(MDFNGameInfo->MD5);  rom_loaded();  MDFN_printf(_("ROM:       %uKiB/n"), (ngpc_rom.length + 1023) / 1024);  MDFN_printf(_("ROM MD5:   0x%s/n"), md5_context::asciistr(MDFNGameInfo->MD5, 0).c_str());  FLASH_LoadNV();  MDFNMP_Init(1024, 1024 * 1024 * 16 / 1024);  NGPGfx = new NGPGFX_CLASS();  MDFNGameInfo->fps = (uint32)((uint64)6144000 * 65536 * 256 / 515 / 198); // 3072000 * 2 * 10000 / 515 / 198  MDFNGameInfo->GameSetMD5Valid = FALSE;  MDFNNGPCSOUND_Init();  MDFNMP_AddRAM(16384, 0x4000, CPUExRAM);  SetFRM(); // Set up fast read memory mapping  bios_install();  //main_timeaccum = 0;  z80_runtime = 0;  reset(); } catch(...) {  Cleanup();  throw; }}

static void Load(MDFNFILE *fp){ try {  lynxie = new CSystem(fp);  switch(lynxie->CartGetRotate())  {   case CART_ROTATE_LEFT:	MDFNGameInfo->rotated = MDFN_ROTATE270;	break;   case CART_ROTATE_RIGHT:	MDFNGameInfo->rotated = MDFN_ROTATE90;	break;  }  MDFNGameInfo->GameSetMD5Valid = false;  if(lynxie->mRam->InfoRAMSize)  {   memcpy(MDFNGameInfo->MD5, lynxie->mRam->MD5, 16);   MDFN_printf(_("RAM:       %u bytes/n"), lynxie->mRam->InfoRAMSize);   MDFN_printf(_("RAM MD5:   0x%s/n"), md5_context::asciistr(MDFNGameInfo->MD5, 0).c_str());  }  else  {   memcpy(MDFNGameInfo->MD5, lynxie->mCart->MD5, 16);   MDFN_printf(_("ROM:       %dKiB/n"), (lynxie->mCart->InfoROMSize + 1023) / 1024);   MDFN_printf(_("ROM MD5:   0x%s/n"), md5_context::asciistr(MDFNGameInfo->MD5, 0).c_str());  }  MDFNGameInfo->fps = (uint32)(59.8 * 65536 * 256);  if(MDFN_GetSettingB("lynx.lowpass"))  {   lynxie->mMikie->miksynth.treble_eq(-35);  }  else  {   lynxie->mMikie->miksynth.treble_eq(0);  } } catch(std::exception &e) {  Cleanup();  throw; }}

 MPCReader(FILE *fp) {	fseek(fp, 0, SEEK_SET);	lseek(fileno(fp), 0, SEEK_SET);	memset(&MPCReaderFile, 0, sizeof(MPCReaderFile));	memset(&MPCStreamInfo, 0, sizeof(MPCStreamInfo));	memset(&MPCDecoder, 0, sizeof(MPCDecoder));	memset(MPCBuffer, 0, sizeof(MPCBuffer));	mpc_streaminfo_init(&MPCStreamInfo);	mpc_reader_setup_file_reader(&MPCReaderFile, fp);        if(mpc_streaminfo_read(&MPCStreamInfo, &MPCReaderFile.reader) != ERROR_CODE_OK)        {         throw(0);        }        mpc_decoder_setup(&MPCDecoder, &MPCReaderFile.reader);        if(!mpc_decoder_initialize(&MPCDecoder, &MPCStreamInfo))        {         MDFN_printf(_("Error initializing MusePack decoder!/n"));         throw(0);        } }

int32 PCECD_Init(){	if (!CDIF_Init())		return -1;	CDDAVolumeSetting = (double)MDFN_GetSettingUI("pce.cddavolume");	if(CDDAVolumeSetting != 100)	{	 MDFN_printf(_("CD-DA Volume: %d%%/n"), (int)CDDAVolumeSetting);	}	CDDAVolumeSetting /= 100;        CurrentCDVolume = InitialCdVolume = 65536;        VolumeStep      = InitialCdVolume / 100;        bFadeOut = FALSE;        bFadeIn  = FALSE;	ADPCM_SetNotificationFunction(adpcm_state_notification_callback_function);	SCSICD_Init(SCSICD_PCE, 1 * pce_overclocked, &sbuf[0], &sbuf[1], 126000 * MDFN_GetSettingUI("pce.cdspeed"), 7159091 * pce_overclocked, CDIRQ, StuffSubchannel);	SyncCDVolume();	#ifdef WANT_DEBUGGER	MDFNDBG_AddRegGroup(&PCECDRegsGroup);	#endif	return 0;}

static void LoadPRG(Stream *fp){ uint32 t; unsigned z; z = uchead.ID[3] - '0';	// FIXME hex if(z > 15)  throw MDFN_Error(0, "Invalid PRG ROM index '%c'./n", uchead.ID[3]); MDFN_printf(_("PRG ROM %u size: %u/n"), z, uchead.info); if(malloced[z])  free(malloced[z]); t = FixRomSize(uchead.info, 2048); malloced[z] = (uint8 *)MDFN_malloc_T(t, _("PRG ROM")); mallocedsizes[z] = t; memset(malloced[z] + uchead.info, 0xFF, t - uchead.info); fp->read(malloced[z], uchead.info); SetupCartPRGMapping(z,malloced[z],t,0); }

static void MakeSFMap(SFORMAT *sf, SFMap_t &sfmap){ while(sf->size || sf->name) // Size can sometimes be zero, so also check for the text name.  These two should both be zero only at the end of a struct. {  if(!sf->size || !sf->v)  {   sf++;   continue;  }  if(sf->size == (uint32)~0)            /* Link to another SFORMAT structure. */   MakeSFMap((SFORMAT *)sf->v, sfmap);  else  {   assert(sf->name);   if(sfmap.find(sf->name) != sfmap.end())	   MDFN_printf("Duplicate save state variable in internal emulator structures(CLUB THE PROGRAMMERS WITH BREADSTICKS): %s/n", sf->name);   sfmap[sf->name] = sf;  }  sf++; }}

bool MDFNI_StartAVRecord(const char *path, double SoundRate){ try {  QTRecord::VideoSpec spec;  memset(&spec, 0, sizeof(spec));  spec.SoundRate = SoundRate;  spec.SoundChan = MDFNGameInfo->soundchan;  spec.VideoWidth = MDFNGameInfo->lcm_width;  spec.VideoHeight = MDFNGameInfo->lcm_height;  spec.VideoCodec = MDFN_GetSettingI("qtrecord.vcodec");  spec.MasterClock = MDFNGameInfo->MasterClock;  if(spec.VideoWidth < MDFN_GetSettingUI("qtrecord.w_double_threshold"))   spec.VideoWidth *= 2;  if(spec.VideoHeight < MDFN_GetSettingUI("qtrecord.h_double_threshold"))   spec.VideoHeight *= 2;  spec.AspectXAdjust = ((double)MDFNGameInfo->nominal_width * 2) / spec.VideoWidth;  spec.AspectYAdjust = ((double)MDFNGameInfo->nominal_height * 2) / spec.VideoHeight;  MDFN_printf("/n");  MDFN_printf(_("Starting QuickTime recording to file /"%s/":/n"), path);  MDFN_indent(1);  MDFN_printf(_("Video width: %u/n"), spec.VideoWidth);  MDFN_printf(_("Video height: %u/n"), spec.VideoHeight);  MDFN_printf(_("Video codec: %s/n"), MDFN_GetSettingS("qtrecord.vcodec").c_str());  if(spec.SoundRate && spec.SoundChan)  {   MDFN_printf(_("Sound rate: %u/n"), std::min<uint32>(spec.SoundRate, 64000));   MDFN_printf(_("Sound channels: %u/n"), spec.SoundChan);  }  else   MDFN_printf(_("Sound: Disabled/n"));  MDFN_indent(-1);  MDFN_printf("/n");  qtrecorder = new QTRecord(path, spec); } catch(std::exception &e) {  MDFND_PrintError(e.what());  return(false); } return(true);}

static int Load(const char *name, MDFNFILE *fp){ try {  lynxie = new CSystem(fp->data, fp->size);  switch(lynxie->CartGetRotate())  {   case CART_ROTATE_LEFT:	MDFNGameInfo->rotated = MDFN_ROTATE270;	break;   case CART_ROTATE_RIGHT:	MDFNGameInfo->rotated = MDFN_ROTATE90;	break;  }  memcpy(MDFNGameInfo->MD5, lynxie->mCart->MD5, 16);  MDFNGameInfo->GameSetMD5Valid = FALSE;  MDFN_printf(_("ROM:       %dKiB/n"), (lynxie->mCart->InfoROMSize + 1023) / 1024);  MDFN_printf(_("ROM CRC32: 0x%08x/n"), lynxie->mCart->CRC32());  MDFN_printf(_("ROM MD5:   0x%s/n"), md5_context::asciistr(MDFNGameInfo->MD5, 0).c_str());  MDFNGameInfo->fps = (uint32)(59.8 * 65536 * 256);  if(MDFN_GetSettingB("lynx.lowpass"))  {   lynxie->mMikie->miksynth.treble_eq(-35);  }  else  {   lynxie->mMikie->miksynth.treble_eq(0);  } } catch(std::exception &e) {  MDFN_PrintError("%s", e.what());  Cleanup();  return(0); } return(1);}

MCGenjin::MCGenjin(Blip_Buffer *bb, const uint8 *rr, uint32 rr_size){ uint8 revision, num256_pages, region, cs_di[2]; if(rr_size < 8192)  throw MDFN_Error(0, _("MCGenjin ROM size is too small!")); if(memcmp(rr + 0x1FD0, "MCGENJIN", 8))  throw MDFN_Error(0, _("MC Genjin header magic missing!")); rom.resize(round_up_pow2(rr_size)); memcpy(&rom[0], rr, rr_size); revision = rom[0x1FD8]; num256_pages = rom[0x1FD9]; region = rom[0x1FDA]; cs_di[0] = rom[0x1FDB]; cs_di[1] = rom[0x1FDC]; for(unsigned i = 0; i < 2; i++) {  switch(cs_di[i])  {   default:	for(unsigned si = 0; si < i; si++) // FIXME: auto ptr to make this not necessary         delete cs[si];	throw MDFN_Error(0, _("Unsupported MCGENJIN device on CS%d: 0x%02x"), i, cs_di[i]);	break;   case 0x00:	MDFN_printf(_("CS%d: Unused/n"), i);	cs[i] = new MCGenjin_CS_Device();	break;   case 0x10 ... 0x18:   case 0x20 ... 0x28:	MDFN_printf(_("CS%d: %uKiB %sRAM/n"), i, 8 << (cs_di[i] & 0xF), (cs_di[i] & 0x20) ? "Nonvolatile " : "");	cs[i] = new MCGenjin_CS_Device_RAM(8192 << (cs_di[i] & 0xF), (bool)(cs_di[i] & 0x20));	break;  } }}

static void EnableBattery(Stream *fp){ uint8 t; fp->read(&t, 1); MDFN_printf(_("Battery-backed./n")); UNIFCart.battery = 1;}

void PCE_InitCD(void){ PCECD_Settings cd_settings; memset(&cd_settings, 0, sizeof(PCECD_Settings)); cd_settings.CDDA_Volume = (double)MDFN_GetSettingUI("pce_fast.cddavolume") / 100; cd_settings.CD_Speed = MDFN_GetSettingUI("pce_fast.cdspeed"); cd_settings.ADPCM_Volume = (double)MDFN_GetSettingUI("pce_fast.adpcmvolume") / 100; cd_settings.ADPCM_LPF = MDFN_GetSettingB("pce_fast.adpcmlp"); if(cd_settings.CDDA_Volume != 1.0)  MDFN_printf(_("CD-DA Volume: %d%%/n"), (int)(100 * cd_settings.CDDA_Volume)); if(cd_settings.ADPCM_Volume != 1.0)  MDFN_printf(_("ADPCM Volume: %d%%/n"), (int)(100 * cd_settings.ADPCM_Volume)); PCECD_Init(&cd_settings, PCECDIRQCB, PCE_MASTER_CLOCK, pce_overclocked, sbuf);}

static void NAME(Stream *fp){ assert(uchead.info <= (SIZE_MAX - 1)); MDFNGameInfo->name.resize((size_t)uchead.info); fp->read(&MDFNGameInfo->name[0], (size_t)uchead.info); MDFN_zapctrlchars(MDFNGameInfo->name); MDFN_printf(_("Name: %s/n"), MDFNGameInfo->name.c_str());}

static MDFN_COLD void Load(MDFNFILE *fp){ try {  uint8 hes_header[4];  const bool IsHES = false;  IsSGX = false;  fp->read(hes_header, 4);  fp->seek(0, SEEK_SET);  /*if(!memcmp(hes_header, "HESM", 4))   IsHES = true;*/  LoadCommonPre();  for(int x = 0; x < 0x100; x++)  {   HuCPU.PCERead[x] = PCEBusRead;   HuCPU.PCEWrite[x] = PCENullWrite;  }  if(IsHES)   HES_Load(fp);  else  {   uint32 crc;   crc = HuC_Load(fp);   if(fp->ext == "sgx")    IsSGX = true;   else   {    for(auto const& e : sgx_table)    {     if(e.crc == crc)     {      IsSGX = true;      MDFN_printf(_("SuperGrafx: %s/n"), e.name);      break;     }    }   }  }  LoadCommon(); } catch(...) {  Cleanup();  throw; }}

void  instruction_error(char* vaMessage,...){	char message[1000];	va_list vl;	va_start(vl, vaMessage);	vsprintf(message, vaMessage, vl);	va_end(vl);	MDFN_printf("[PC %06X] %s/n", pc, message);}

bool CDIF_ReadSector(uint8* pBuf, uint32 lba, uint32 nSectors){ while(nSectors--) {  uint8 tmpbuf[2352 + 96];  if(!CDIF_ReadRawSector(tmpbuf, lba))  {	  MDFN_printf("CDIF Raw Read error");   return(FALSE);  }  if(!CDIF_ValidateRawSector(tmpbuf))  {   MDFN_DispMessage(_("Uncorrectable data at sector %d"), lba);   MDFN_PrintError(_("Uncorrectable data at sector %d"), lba);   return(false);  }  const int mode = tmpbuf[12 + 3];  if(mode == 1)  {   memcpy(pBuf, &tmpbuf[12 + 4], 2048);  }  else if(mode == 2)  {   memcpy(pBuf, &tmpbuf[12 + 4 + 8], 2048);  }  else  {	  MDFN_printf("CDIF_ReadSector() invalid sector type at LBA=%u/n", (unsigned int)lba);   return(false);  }  pBuf += 2048;  lba++; } return(true);}

static void LoadCommonPre(void){ // FIXME:  Make these globals less global! pce_overclocked = MDFN_GetSettingUI("pce_fast.ocmultiplier"); PCE_ACEnabled = MDFN_GetSettingB("pce_fast.arcadecard"); if(pce_overclocked > 1)  MDFN_printf(_("CPU overclock: %dx/n"), pce_overclocked); if(MDFN_GetSettingUI("pce_fast.cdspeed") > 1)  MDFN_printf(_("CD-ROM speed:  %ux/n"), (unsigned int)MDFN_GetSettingUI("pce_fast.cdspeed")); memset(HuCPUFastMap, 0, sizeof(HuCPUFastMap)); for(int x = 0; x < 0x100; x++) {  PCERead[x] = PCEBusRead;  PCEWrite[x] = PCENullWrite; } MDFNMP_Init(1024, (1 << 21) / 1024);}

void VBlur_Init(void){        std::string sn = MDFNGameInfo->shortname;        if(MDFN_GetSettingB(std::string(sn + "." + std::string("vblur")).c_str()))        {         AccumBlurAmount = (uint32)(16384 * MDFN_GetSettingF(std::string(sn + "." + std::string("vblur.accum.amount")).c_str()) / 100);         if(MDFN_GetSettingB(std::string(sn + "." + std::string("vblur.accum")).c_str()))         {          AccumBlurBuf = (HQPixelEntry *)calloc(sizeof(HQPixelEntry), (MDFNGameInfo->pitch >> 2) * 256);          MDFN_printf(_("Video frame blur enabled with accumulation: %f./n"), (double)AccumBlurAmount * 100 / 16384);         }

int DetectMMC5WRAMSize(uint32 crc32){ int x; for(x=0;x<MMC5_NOCARTS;x++)  if(crc32==MMC5CartList[x].crc32)  {    MDFN_printf(_(">8KB external WRAM present.  Use UNIF if you hack the ROM image./n"));    return(MMC5CartList[x].size*8);  } return(8);}

static int Load(const char *name, MDFNFILE *fp){ if(!(ngpc_rom.data = (uint8 *)MDFN_malloc(GET_FSIZE_PTR(fp), _("Cart ROM"))))  return(0); ngpc_rom.length = GET_FSIZE_PTR(fp); memcpy(ngpc_rom.data, GET_FDATA_PTR(fp), GET_FSIZE_PTR(fp)); md5_context md5; md5.starts(); md5.update(ngpc_rom.data, ngpc_rom.length); md5.finish(MDFNGameInfo->MD5); rom_loaded(); MDFN_printf(_("ROM:       %dKiB/n"), (ngpc_rom.length + 1023) / 1024); MDFN_printf(_("ROM MD5:   0x%s/n"), md5_context::asciistr(MDFNGameInfo->MD5, 0).c_str()); MDFNMP_Init(1024, 1024 * 1024 * 16 / 1024); NGPGfx = new NGPGFX_CLASS(); MDFNGameInfo->fps = (uint32)((uint64)6144000 * 65536 * 256 / 515 / 198); // 3072000 * 2 * 10000 / 515 / 198 MDFNGameInfo->GameSetMD5Valid = FALSE; MDFNNGPCSOUND_Init(); MDFNMP_AddRAM(16384, 0x4000, CPUExRAM); SetFRM(); // Set up fast read memory mapping bios_install(); //main_timeaccum = 0; z80_runtime = 0; reset(); return(1);}

static void SetBoardName(Stream *fp){ assert(uchead.info <= (SIZE_MAX - 1)); boardname = (uint8*)MDFN_malloc_T((size_t)uchead.info + 1, _("Board Name")); fp->read(boardname, uchead.info); boardname[uchead.info] = 0; MDFN_RemoveControlChars((char*)boardname); MDFN_printf(_("Board name: %s/n"), boardname); sboardname=boardname; if(!memcmp(boardname,"NES-",4) || !memcmp(boardname,"UNL-",4) || !memcmp(boardname,"HVC-",4) || !memcmp(boardname,"BTL-",4) || !memcmp(boardname,"BMC-",4))  sboardname+=4;}

static int DetectMMC1WRAMSize(uint32 crc32){        switch(crc32)        {         default:return(8);	 case 0xc6182024:	/* Romance of the 3 Kingdoms */         case 0x2225c20f:       /* Genghis Khan */         case 0x4642dda6:       /* Nobunaga's Ambition */	 case 0x29449ba9:	/* ""	"" (J) */	 case 0x2b11e0b0:	/* ""	"" (J) */		MDFN_printf(_(">8KB external WRAM present.  Use UNIF if you hack the ROM image./n"));		return(16);        }}