direct.cpp

DGen源码最后版本

// DGen Old DirectX Interface v1.14+
#define WIN32_LEAN_AND_MEAN

#include <stdio.h>
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
#include <windows.h>
#include <windowsx.h>
#include <commdlg.h>
#include <mmsystem.h>
#include "dxdisp.h"
#include <dsound.h>
#include "../md/md.h"

#include <math.h>

static char temp[0x8000];
HWND hWnd=0; // Main window handle.
static FILE *debug_log=NULL;
extern "C" int dprintf(char *format, ...)
{
  if (debug_log!=NULL)
  {
    va_list arg;
    va_start(arg,format);

    vfprintf (debug_log,format,arg);
    va_end(arg);
  }
  return 0;
}

#define KEY_DOWN(vk_code) ((GetAsyncKeyState(vk_code) & 0x8000) ? 1 : 0)

HINSTANCE main_inst=0;
static md megad;
static int ret;
static int crap_tv=0,tog_fs_req=0,md_res_req=0;
static char rom_path[0x800]="";
static char state_path[0x800]="";

static char rom_name[0x800]="";
static char save_name[0x800]=""; // Can be State or SRAM
static char config_name[0x800]="";
static char curr_path[0x800]="";

static int auto_saveload=0,sram_saveload=1,no_sound=0;
FILE *sound_log=NULL;

static unsigned char md_pal[1024]={0,0,0,0,255,255,255,0};
static dxdisp *mddisp=0;

static int fullscreen=0,width=320,height=240,depth=16;
static int force_depth=0;
static int we_are_active=1;
//static PALETTEENTRY ape[256]={0};
//static IDirectDrawPalette *ddpal=0;
static float umul=1.2,vmul=1.2,brightness=0.1,contrast=0.8;
static int virtual_fps=60,any_size=0;

static signed short *fmbuf[2]={NULL};
static int snd_size=367*1,snd_rate=22050*1,snd_segs=4,stereo16=1;
static float snd_distort=1.00;
static IDirectSound *lpds=NULL;
static IDirectSoundBuffer *lpBufPrim,*lpBuf;
int sound_is_okay=0;
extern "C" int fm_chan_on,dave_fb_val;
static int dgen_display_on=1;

static int medley=0,medley_beep=0,medley_keys[60*10*2]={0},medley_record=-1;
static int medley_countdown=0,medley_press_mark=0,medley_silence=-2*60;
static int medley_nothing_after=0,medley_had_fire=0;

// Note: if medley>0
//            medley_record>=0 RECORDING keypresses
//            medley_record<0 playing songs
// otherwise, medley is off

static int pad_code[32]=
{
  0xc8,0xd0,0xcb,0xcd,
  0x1e,0x1f,0x20,0x1c,
  0x10,0x11,0x12,0x13,
  0x00,0x00,0x00,0x00,
  0x10001,0x10002,0x10003,0x10004,
  0x10010,0x10012,0x10013,0x10011,
  0x10014,0x10015,0x10016,0x10017,
  0x00,0x00,0x00,0x00
};

static int sound_init()
{
  if (no_sound) { sound_is_okay=0; return 1; }
  if (hWnd==0) return 1;

  snd_size=snd_rate/virtual_fps; if (snd_size<16) snd_size=16;


  ret=DirectSoundCreate(NULL, &lpds, NULL);
  if (ret!=DS_OK)
	{
    sound_is_okay=0; return 1; // turn off sound
	}

//  ret=lpds->SetCooperativeLevel(hWnd, DSSCL_PRIORITY);
  ret=lpds->SetCooperativeLevel(hWnd, DSSCL_EXCLUSIVE);
  if (ret!=DS_OK)
  {
    sprintf (temp,"returned %.8x (+%d)\n",ret,ret-MAKE_DSHRESULT(0));
    MessageBox(hWnd,temp,"lpds->SetCooperativeLevel()",MB_OK);
    if (ret!=DS_OK) goto snd_fail;
  }

	PCMWAVEFORMAT	pcmwf;
	WAVEFORMATEX	wf;

	memset(&pcmwf, 0, sizeof(PCMWAVEFORMAT)); 
	memset(&wf,0,sizeof(WAVEFORMATEX));
  pcmwf.wBitsPerSample = stereo16? 16:8; 
	pcmwf.wf.wFormatTag = WAVE_FORMAT_PCM; 
  pcmwf.wf.nChannels = stereo16? 2:1 ; 
  pcmwf.wf.nSamplesPerSec = snd_rate;
	pcmwf.wf.nBlockAlign = pcmwf.wf.nChannels * (pcmwf.wBitsPerSample/8); 
	pcmwf.wf.nAvgBytesPerSec = pcmwf.wf.nSamplesPerSec * pcmwf.wf.nBlockAlign; 
	//
	wf.wFormatTag = WAVE_FORMAT_PCM;
	wf.nChannels = pcmwf.wf.nChannels;
	wf.nSamplesPerSec = pcmwf.wf.nSamplesPerSec;
	wf.wBitsPerSample = pcmwf.wBitsPerSample;
	wf.nBlockAlign = pcmwf.wf.nBlockAlign;
	wf.nAvgBytesPerSec = pcmwf.wf.nAvgBytesPerSec;
	wf.cbSize = sizeof(WAVEFORMATEX);

	//--PrimaryBuffer make
	DSBUFFERDESC dsbdesc;
  memset(&dsbdesc, 0, sizeof(DSBUFFERDESC));
  dsbdesc.dwSize = sizeof(DSBUFFERDESC);
  dsbdesc.dwFlags = DSBCAPS_PRIMARYBUFFER;
  ret=lpds->CreateSoundBuffer(&dsbdesc,&lpBufPrim,NULL);
  if (ret!=DS_OK)
  {
    sprintf (temp,"returned %.8x (+%d)\n",ret,ret-MAKE_DSHRESULT(0));
    MessageBox(hWnd,temp,"create primary buffer",MB_OK);
    if (ret!=DS_OK) goto snd_fail;
  }
  ret=lpBufPrim->SetFormat(&wf);
  if (ret!=DS_OK)
  {
    sprintf (temp,"returned %.8x (+%d)\n",ret,ret-MAKE_DSHRESULT(0));
    MessageBox(hWnd,temp,"primary buffer set format",MB_OK);
    if (ret!=DS_OK) goto snd_fail;
  }
  ret=lpBufPrim->Play(0,0,DSBPLAY_LOOPING);
  if (ret!=DS_OK)
  {
    sprintf (temp,"returned %.8x (+%d)\n",ret,ret-MAKE_DSHRESULT(0));
    MessageBox(hWnd,temp,"primary buffer play",MB_OK);
    if (ret!=DS_OK) goto snd_fail;
  }

	//--SecondaryBuffer Make
  memset(&dsbdesc, 0, sizeof(DSBUFFERDESC));
  dsbdesc.dwSize = sizeof(DSBUFFERDESC);
  dsbdesc.dwFlags = DSBCAPS_CTRLDEFAULT  | DSBCAPS_GETCURRENTPOSITION2 | DSBCAPS_STICKYFOCUS;
  dsbdesc.dwBufferBytes = snd_size*snd_segs*(stereo16?4:1); 
  dsbdesc.lpwfxFormat = (LPWAVEFORMATEX)&pcmwf;

  ret=lpds->CreateSoundBuffer(&dsbdesc,&lpBuf,NULL);
  if (ret!=DS_OK)
  {
    sprintf (temp,"returned %.8x (+%d)\n",ret,ret-MAKE_DSHRESULT(0));
    MessageBox(hWnd,temp,"create secondary sound buffer",MB_OK);
    if (ret!=DS_OK) goto snd_fail;
  }

/*
	LPVOID ptr1, ptr2;
	DWORD  size1, size2;
  ret=lpBuf->Lock(0,snd_size,&ptr1, &size1, &ptr2, &size2, 0);
  if (ret == DS_OK)
  {
    lpBuf->Unlock(ptr1, size1, ptr2, size2);
  }
*/

  ret=lpBuf->Play(0,0,DSBPLAY_LOOPING);
  if (ret!=DS_OK)
  {
    sprintf (temp,"returned %.8x (+%d)\n",ret,ret-MAKE_DSHRESULT(0));
    MessageBox(hWnd,temp,"play secondary sound buffer",MB_OK);
    sound_is_okay=0;
  }

  fmbuf[0]=(signed short *)malloc(snd_size*sizeof(signed short));
  if (fmbuf[0]==NULL) goto snd_fail;
  fmbuf[1]=(signed short *)malloc(snd_size*sizeof(signed short));
  if (fmbuf[1]==NULL) goto snd_fail;

  memset(fmbuf[0],0,snd_size*sizeof(signed short));
  memset(fmbuf[1],0,snd_size*sizeof(signed short));

// Dave fiddling - mjazz
  // meant to be 53693100L/8 ? (int)(8000000L*94/100) sounds right
  ret=YM2612Init(3,8000000L*94/100,(int)((double)snd_rate/snd_distort),NULL,NULL);
  if (ret!=0)
  {
    sprintf (temp,"YM2612Init returned %d\n",ret);
    MessageBox(hWnd,temp,"YM2612Init",MB_OK);
    if (ret!=0) goto snd_fail;
  }

  // Meant to be 53693100L/11?
  ret=SN76496_init(0,3750000L*94/100,(int)((double)snd_rate/snd_distort),16);
  if (ret!=0)
  {
    sprintf (temp,"SN76496_init returned %d\n",ret);
    MessageBox(hWnd,temp,"SN76496_init",MB_OK);
//    if (ret!=0) goto snd_fail;
  }

  sound_is_okay=1;
  megad.flush_fm_to_mame();


  return 0;
snd_fail:
  return 1;
}

static int fill_snd_seg(int fillseg)
{
  LPVOID ptr1, ptr2;
	DWORD  size1, size2;

  if (fillseg<0) return 1;
  if (fillseg>=snd_segs) return 1;

  ret=lpBuf->Lock(fillseg*snd_size*(stereo16?4:1),snd_size*(stereo16?4:1),&ptr1,&size1,&ptr2,&size2,0);
/*
  if (ret!=DS_OK || ptr2 || size2 || size1!=snd_size*(stereo16?4:1))
  {
    sprintf (temp,"returned %.8x (+%d) WANTED seg %d ptr1=%p,%x ptr2=%p,%x\n",ret,ret-MAKE_DSHRESULT(0),
      fillseg,ptr1,size1,ptr2,size2);
    MessageBox(hWnd,temp,"lpBuf->Lock",MB_OK);
    //if (ret!=DS_OK)
    sound_is_okay=0;
  }
*/
  if (ret == DS_OK)
  {
    signed short *newsnd16; unsigned char *newsnd8;
    newsnd16=(signed short *)ptr1;
    newsnd8=(unsigned char *)ptr1;
    if (ptr1!=NULL)
    {
      signed short *sound_buf[2];
      int j;
      int fade=0x100;
      int something=0;

      if (medley>0 && medley_record<0)
      {
        if (medley_press_mark>0)
        {
          if (medley_countdown<medley_press_mark) fade=0;
          else if (medley_countdown<medley_press_mark+0x100)
            fade=medley_countdown-medley_press_mark;
            // fade out
        }
      }

      sound_buf[0]=fmbuf[0];
      sound_buf[1]=fmbuf[1];
      for (j=0;j<snd_size;j++)
      {
        int disp;
        if (stereo16)
        {
          newsnd16[j*2+0]=sound_buf[0][j];
          newsnd16[j*2+1]=sound_buf[1][j];
          if (fade!=0x100)
          {
            newsnd16[j*2+0]=((int)newsnd16[j*2+0]*fade)>>8;
            newsnd16[j*2+1]=((int)newsnd16[j*2+1]*fade)>>8;
          }
          newsnd16[j*2+0]+=((medley_beep>0)? (j&8?-0x2000:+0x2000):0);

          if (j>0)
          {
            if (newsnd16[j*2+0]!=newsnd16[(j-1)*2+0]) something=1;
            if (newsnd16[j*2+1]!=newsnd16[(j-1)*2+1]) something=1;
          }
        }
        else
        {
          disp=0;
          disp+=((int)sound_buf[0][j]);
          disp+=((int)sound_buf[1][j]);
          disp>>=9;
          if (disp>+0x02 || disp<-0x02) something=1;

          disp=((int)disp*fade)>>8;

          disp+=((medley_beep>0)? (j&8?-0x20:+0x20):0);
          newsnd8[j]=disp+0x80;

          if (j>0)
          {
            if (newsnd8[j]!=newsnd8[j-1]) something=1;
          }
        }
      }

      if (something) medley_silence=0; else medley_silence++;

      if (medley>0 && medley_record<0)
      {
        if (medley_silence>30 && medley_countdown>60*10 )
        { medley_countdown=60*10; medley_silence=-2*60; }
      }

      if (sound_log!=NULL)
        fwrite(ptr1,1,snd_size*(stereo16?4:1),sound_log);

    }
    lpBuf->Unlock(ptr1, size1, ptr2, size2);
    if (medley_beep>0) medley_beep--;
  }

  return 0;
}


static int sound_exit()
{
  if (sound_is_okay)
  {
    //-- DirectSound Cleanup
    if(lpBuf)   lpBuf->Release(); lpBuf=NULL;
    if(lpBufPrim) lpBufPrim->Release(); lpBufPrim=NULL;
    if(lpds)    lpds->Release(); lpds=NULL;
    YM2612Shutdown();

    if (fmbuf[0]!=NULL) free(fmbuf[0]); fmbuf[0]=NULL;
    if (fmbuf[1]!=NULL) free(fmbuf[1]); fmbuf[1]=NULL;
  }

  sound_is_okay=0;
  return 0;
}

static char *gst_name(char *fn)
{
  char *pt,*st;
  int len;

  temp[0x200]=0;
  pt=fn+strlen(fn)-1;
  while (pt>fn)
  {
    if (*pt=='\\') {pt++; break; }
    pt--;
  }
  st=pt;
  len=0;
  while (*pt!=0)
  {
    if (*pt=='.') break; 
    pt++; len++;
  }
  memcpy(temp+0x200,st,len);
  temp[0x200+len]=0;

  return temp+0x200;
}

static inline int depth_to_bytes(int depth)
{
       if (depth<=8)  return 1;
  else if (depth<=16) return 2;
  else if (depth<=24) return 3;
  else                return 4;
}

static int mess_with_bm(struct bmap *bm)
{
  // Remember messy border - handy
  int x,y; unsigned char *line;

  if (crap_tv)
  {
    line=bm->data+8*bm->pitch+8*depth_to_bytes(bm->bpp);
#ifdef ASM_CTV
    for (y=0;y<224;y++)
    {
      // asm in ctv.asm
      if (bm->bpp==16) blur_bitmap_16(line,320-1);
      else if (bm->bpp==15) blur_bitmap_15(line,320-1);

//      if (y==medley_silence) memset(line,0xff,100);
//      if (y==medley_countdown/30) memset(line,0x80,100);

      line+=bm->pitch;
    }
#else
    if (bm->bpp==16)
    for (y=0;y<224;y++)
    {
      unsigned char *pix;
  
      pix=line;
      for (x=0;x<320-1;x++)
      {
        int tmp;
        int dot,dot2;
        dot= pix[0]|(pix[1]<<8);
        dot2=pix[2]|(pix[3]<<8);
  
        // Split g out from middle
        dot= ((dot &0x07e0)<<16) | (dot &0xf81f);
        dot2=((dot2&0x07e0)<<16) | (dot2&0xf81f);
  
        dot=(dot+dot2)>>1;
  
        // Put g back in middle
        dot= ((dot >>16) &0x07e0) | (dot &0xf81f);
  
        pix[0]=dot&255;
        pix[1]=(dot>>8)&255;
  
        pix+=2;
      }
      line+=bm->pitch;
    }
#endif
  }
  return 0;
}

static int mess_with_pal(unsigned char pal[256])
{
  int i;
  if (pal==NULL) return 1;
  for (i=0;i<64;i++)
  {
    int ir,ig,ib;
    float y,u,v,r,g,b;
    ir=pal[i*4+0]; ig=pal[i*4+1]; ib=pal[i*4+2];

    r=((float)ir)/255.0;
    g=((float)ig)/255.0;
    b=((float)ib)/255.0;

    y=0.30*r+0.59*g+0.11*b;
    u=0.49*(b-y);