game.c

来自「ESS3890+SL原代码（1*16内存）」· C语言 代码 · 共 1,099 行 · 第 1/3 页

   copy_gm_data(gm_rom);
    
   gm_text_start = dram_cached(GMBY_CODE_start);
   gm_r22_seg=(gm_text_start+256*1024)>>2;
     /* R22 segment */
   asm("nop");
   asm("ld _gm_r22_seg[r0],r22");
   asm("nop");

#if 0  /*Call game main function */
   kkk= (gm_text_start)>>2;
   asm("ld _kkk[r0],r1");
   asm("nop");
   asm("jspci r1,#0,r31");
   asm("nop");
   asm("nop");
#endif
}

unsigned int scramble(unsigned int d)
{
    unsigned int r, t1, t2;

    r  = d & 0x56565656;        /* no change for bit 1, 2, 4, 6 of each byte */
    t1 = d & 0x55555555;        /* get bit 0, 2, 4, 6 of each byte */
    t2 = d & 0xaaaaaaaa;        /* get bit 1, 3, 5, 7 of each byte */
    d = t2 ^ (t1 << 1);
    /* set bit 0, 3, 5, 7 of each byte */
    r |= (d & 0xfcfcfcfc) | ((d >> 1) & 0x1010101);

    return r;
}

extern volatile int glbTimer;
int gbl_timer()
{
   return glbTimer;
}
int mvd_timer()
{
   return mvd[riface_timer2];
}

void GM_init_gbl()
{
  int i, *tmp, chksum,chksum1, h_l;
  int *data_rom, *gm_rom, *data_addr;
  GBL P_gbl;
  

#if (defined VGB_CD || defined INES_CD) 
  data_rom = (int *)dram_cached(GMBY_ROM_start);
  
  if(*(data_rom) == 0x3C080808){
#ifdef INES_CD
      if(*(data_rom+1) == 0x2508FFFF){
         gmby_name_id = 0x60; h_l = 12032;
      } else
#endif /*INES_CD*/
#ifdef VGB_CD
      if (*(data_rom+1) == 0x2509FFFF) {
         gmby_name_id = 0x20; h_l = 16128;
         data_addr = data_rom + 0x3A20;
      } else if (*(data_rom+1) == 0x250AFFFF) {
         gmby_name_id = 0x30; h_l = 12032;
         data_addr = data_rom + 0x2A20;
      } else 
#endif /*VGB_CD*/
      return;
      gm_rom = data_rom + 256;

      chksum = chksum1 = 0; tmp = gm_rom;
      for(i=0; i<h_l; i++){
          chksum += gm_rom[i];
          tmp[i] = scramble(gm_rom[i]);
          chksum1 += tmp[i];
      }
      if(chksum != data_rom[4] || chksum1 != data_rom[3]) return;

#ifdef VGB_CD
      if(gmby_name_id == 0x30 || gmby_name_id == 0x20){
        RISC_to_dram(VGB_CyclesCB_start, (int *)data_addr, 64);
        data_addr += 64;
        RISC_to_dram(VGB_GBtoZ80_start, (int *)data_addr, 64);
        data_addr += 64;
        RISC_to_dram(VGB_Z80toGB_start, (int *)data_addr, 64);
        data_addr += 64;
        RISC_to_dram(VGB_HFlip_start, (int *)data_addr, 64);
        data_addr += 64;
        RISC_to_dram(VGB_DAATable_start, (int *)data_addr, 1024);
      }
#endif

      GM_copy_rom(gm_rom);
   } else return;
#endif /*VGB_CD || INES_CD*/


     tmp = (int *)dram_cached(GMBY_GBL_start);
     *tmp = (dram_cached(GMBY_CODE_start))>>2;
     dram_clear(GMBY_GBL_start, GMBY_GBL_size);
     P_gbl = (GBL) dram_cached(GMBY_GBL_start);
     P_gbl->gbl_start = GMBY_GBL_start;
  
     /*function pointer */
     P_gbl->dram_clear = dram_clear;
     P_gbl->risc_copy = RISC_to_dram;
     P_gbl->flush_cache = UTIL_flushcache;
     P_gbl->vcx_service = VCX_service;
     P_gbl->echo_main = ECHO_main;
     P_gbl->micro_engine = microEngine;

     P_gbl->init_pad = CDGM_init_pad;
     P_gbl->key_process = CDGM_key_process;
     P_gbl->init_disp = CDGM_init_disp;
     P_gbl->ld_yuvpal = CDGM_ld_yuvpal;
     P_gbl->hscale = CDGM_hscale;
     P_gbl->hscale_recover = CDGM_hscale_recover;
     P_gbl->trash_snd = CD_TrashSound;
     P_gbl->init_sound = CD_InitSound; 

     /*Const data */
     P_gbl->gbl_start = GMBY_GBL_start;
     P_gbl->rom_start = GMBY_ROM_start;
     P_gbl->snddp_start  = GMBY_SNDDP_start;
     P_gbl->snddp_size   = GMBY_SNDDP_size;

     /*global variables */
     /*Seem that we cannot pass the cached pointer*/
     P_gbl->name_id     = gmby_name_id;
     P_gbl->game_width  = 276;
     P_gbl->u_period    = NES_U_Period;

#ifdef INES_CD
  if(gmby_name_id == 0x60){
     P_gbl->game_misc   = game_list_misc_def;
     P_gbl->game_buff_size = game_list_buffer_size;
     P_gbl->is_game     = is_ess_game;
     P_gbl->file_size   = gmby_file_size;
     P_gbl->play_item   = gmby_play_item;
     P_gbl->is_scrambled = gmby_is_scrambled;
     P_gbl->is_v        = gmby_is_v;
     P_gbl->snd_lengths = INES_SNDLength_start;
     P_gbl->noise_freq  = (INES_SNDLength_start + 32);
     P_gbl->put_image = VGAPutImage;
     P_gbl->sound_loop = SoundLoop;
     P_gbl->sync_snd = NSyncSND;
     P_gbl->get_timer = GM_get_timer;

     P_gbl->rgb_start = GMBY_RGB_start;
     P_gbl->rgb_size  = GMBY_RGB_size;
     P_gbl->ram_start = INES_RAM_start;
     P_gbl->ram_size  = GMBY_RAM_size;
     P_gbl->stack_start  = INES_STACK_start;
     P_gbl->stack_size   = GMBY_STACK_size;
     P_gbl->sndstk_start = GMBY_SNDSTK_start;
     P_gbl->sndstk_size  = GMBY_SNDSTK_size;
     P_gbl->conv_tbl    = NES_Conv;
     P_gbl->palette_start = INES_Palette_start;
     P_gbl->zntable_start = INES_ZNTable_start;
     P_gbl->sram_start    = INES_SRAM_start;
     P_gbl->sprites_start = INES_Sprites_start;
     P_gbl->conv_start    = INES_Conv_start;

     P_gbl->palette_tbl = INES_Palette;
     P_gbl->sunplus_tbl = NES_sunplus;
   }
#endif
#ifdef VGB_CD
  if(gmby_name_id == 0x20){
     P_gbl->vput_image = VGB_PutImage;
     P_gbl->sync_snd = SyncSND;
     P_gbl->gbl_timer   = gbl_timer;
     P_gbl->mvd_timer   = mvd_timer;

     P_gbl->rgb_start = VGB_RGB_start;
     P_gbl->rgb_size  = VGB_RGB_size;
     P_gbl->stack_start  = VGB_STACK_start;
     P_gbl->stack_size   = VGB_STACK_size;
     P_gbl->ram_start = VGB_RAM_start;
     P_gbl->ram_size  = VGB_RAM_size;
     P_gbl->sgb_start = VGB_SGB_start;
     P_gbl->sgb_size  = VGB_SGB_size;
     P_gbl->sndstk_start = VGB_SNDSTK_start;
     P_gbl->sndstk_size  = VGB_SNDSTK_size;
     P_gbl->io_start     = VGB_IO_start;
     P_gbl->io_size      = VGB_IO_size;
     P_gbl->cycles_start = VGB_Cycles_start;
     P_gbl->cyclescb_start = VGB_CyclesCB_start;
     P_gbl->gb2z80_start = VGB_GBtoZ80_start;
     P_gbl->z802gb_start = VGB_Z80toGB_start;
     P_gbl->hflip_start  = VGB_HFlip_start;
     P_gbl->daatable_start = VGB_DAATable_start;
     P_gbl->t2_period   = timer2_period;
   
#if 0
     P_gbl->p_cyclescb  = CyclesCB;
     P_gbl->p_gb2z80    = GBtoZ80;
     P_gbl->p_z802gb    = Z80toGB;
     P_gbl->p_hflip     = HFlip;
     P_gbl->p_daatable  = DAATable; 
#endif
  }
#endif

     LOW_reset_audio_port();
     system_audio_partial_reset(0);

     P_gbl->main(GMBY_GBL_start);

#ifdef INES_CD 
     gmby_name_id = 0;
#endif
}

#ifdef VGB_CD
void VGB_PutImage(V_Image *Img,int X,int Y,int W,int H)
{

    /*divide the rgb buffer to be 32*144 block*/
    register int j, k, dram_blkw, dramAddr, y_blkdw, uv_blkdw;
    int *pU0, *pV0, *pY0, *pY1;
    register int pU0_bb, pV0_bb, pY0_bb, pY1_bb;
    unsigned char *Source;
    int blkw_cnt, D_Source, game_id;

    DISP_frame = 0;

    pY0 = CD_gm_startY + ((H==224)?716:4248);
    pY1 = pY0 + 88;
    pU0 = CD_gm_startU + ((H==224)?358:2124);
    pV0 = CD_gm_startV + ((H==224)?358:2124);
    Source = Img->Data+((Y==0)?0:10240)+X;
 
    D_Source = ((int)Source|0x10000000)>>2;

    blkw_cnt = (W==160)?3:4;
    y_blkdw = 16;
    uv_blkdw = 8;
    dram_blkw = Img->W>>2;
    H >>= 1;

    UTIL_flushcache(0x30, 8192);
    for(j=0;j<blkw_cnt; j++) {
    /*Transfer color pallete to VP*/
       VP_xfer(NCMDQ_VP_xfer, VPCMD_W_DP, 0, 0, ((int)CD_yuv_pal >> 2), 256, 1);
       pY0_bb = (int)pY0>>2;
       pY1_bb = (int)pY1>>2;
       pU0_bb = (int)pU0>>2;
       pV0_bb = (int)pV0>>2;
       dramAddr = D_Source;

       if(j == 2 && W == 160){/*for 160= 64+64+32*/
             y_blkdw = 8;
             uv_blkdw = 4;
       }

       for(k=0; k<H; k++){/*process two lines for each time*/
          VP_cmdq_wait(13);
          VP_xfer(0,VPCMD_W_DPCM,GM_RGB4_START,0,(int)dramAddr,y_blkdw,1);
          dramAddr += dram_blkw;
          VP_xfer(0,VPCMD_W_DPCM,GM_RGB5_START,0,(int)dramAddr,y_blkdw,1);
          dramAddr += dram_blkw;
          VP_data(0, gmby_no_deflicker);
          VP_ucode(0, deflicker);
          wait4l_only; wait4l_only;

          /* Read YUV data from DM */
          VP_cmdq_wait(16);
          VP_xfer(0,VPCMD_R_DPCM,GM_Y1_START,0,pY0_bb,y_blkdw,1);
          VP_xfer(0,VPCMD_R_DPCM,GM_Y2_START,0,pY1_bb,y_blkdw,1);
          VP_xfer(0,VPCMD_R_DPCM,GM_U420_START,0,pU0_bb,uv_blkdw,1);
          VP_xfer(0,VPCMD_R_DPCM,GM_V420_START,0,pV0_bb,uv_blkdw,1);

          pY0_bb += 176;/*jump two lines for Y*/
          pY1_bb += 176;
          pU0_bb += 88;
          pV0_bb += 88;
         }

      pY0 += y_blkdw;
      pY1 += y_blkdw;
      pU0 += uv_blkdw;
      pV0 += uv_blkdw;
      D_Source += 16;
      MIC_service();
    }
}


void SyncSND()
{
  int nn, n;/*70224/4194304*F_LATCH*/
  int pcm_space,pcm_ptr;
  int *dp;
  VGB_SND *SNDChip;

  SNDChip = VSNDChip;
#ifdef ECHO
    MIC_service();
#endif
  /* Update changed channels */
  /* check PCM buffer has space  */
  PCM_update_space(pcm_space);
  if ( pcm_space >= 1536 ) {
      if ( NOTE_EMPTY(SNDChip) ) { return; }
      SNDChip->rp = (SNDChip->rp+1)&(RECORD_NOTES-1);
      /* generate the pcm value */
     dp = (int *)dram(GMBY_SNDVAL_start);
     dp[5] = (SNDChip->freq[SNDChip->rp][0]);
     dp[7] = (SNDChip->volume[SNDChip->rp][0]);
     dp[11] = (SNDChip->freq[SNDChip->rp][1]);
     dp[13] = (SNDChip->volume[SNDChip->rp][1]);
     dp[17] = (SNDChip->freq[SNDChip->rp][2]);
     dp[19] = (SNDChip->volume[SNDChip->rp][2]);
     dp[1] = 0; /* clear the noise channel */

     VP_xfer(6*NCMDQ_VP_xfer, VPCMD_W_DP, 0, VPDMA_INC1+VPDMA_USEDX,
             GMBY_SNDVAL_start, GMBY_SNDVAL_size+GMBY_SNDCOE_size, 1);

    for (nn = 0; nn < 4; nn++) {
         asm("nop"); asm("nop");
        if ( (nn==0) || (nn==2) ) {
            pcm_ptr = PCM_raw_wrptr;
        }

        VP_xfer(0, VPCMD_W_DPCM, 368, 0,
             GMBY_SNDHIS_start, GMBY_SNDHIS_size, 1);
        if ( nn==0 ) {
                VP_ucode(0, syncsnd);
        }
        else    {
                VP_ucode(0, rsyncsnd);
        }
        wait4l_only; wait4l_only;

        VP_xfer(0, VPCMD_R_DPCM, 560, 0,
             GMBY_SNDHIS_start, GMBY_SNDHIS_size, 1);

        VP_xfer(0, VPCMD_R_DP, 0, 0, pcm_ptr, 192, 1);
        VP_xfer_wait();

        if ( (nn==0) || (nn==2) ) {
            pcm_ptr += 192;
        } else {
            BUF_advance_ptr(PCM_raw_wrptr,384,PCM);
            BUF_advance_ptr(PCM_raw_rdptr,384,PCM);
#ifdef SPATIAL
            BUF_advance_ptr(SPA_wrptr,384,PCM);
#endif
            BUF_advance_ptr(PCM_wrptr,384,PCM);
        }
    }
    VP_xfer(0, VPCMD_R_DP, 384, VPDMA_INC1+VPDMA_USEDX,
             GMBY_SNDVAL_start, GMBY_SNDVAL_size, 1);
    VP_xfer_wait();
  }
}

#endif /*VGB_CD*/

#endif /*VGB_CD || INES_CD*/

#endif /* GAMEBOY */