ShuriZma
/
desmume
mirror of https://github.com/TASEmulators/desmume.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

vio2sf: integrate patch #3026630 (vio2sf instrument selection). additionally, add the sound view from desmume.

This commit is contained in:
zeromus 2010-07-08 04:58:34 +00:00
parent 97d601d2cd
commit 98546fb57c
17 changed files with 1636 additions and 78 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
tools/vio2sf/foo_xsf8.vcproj
View File

@ -4,6 +4,7 @@
Version="9.00"
Name="foo_xsf8"
ProjectGUID="{02361C60-7E8A-4002-890A-E2B0AC2C91D8}"
RootNamespace="foo_xsf8"
TargetFrameworkVersion="0"
>
<Platforms>
@ -363,5 +364,11 @@
RelativePath="src\pversion.h"
>
</File>
<File
RelativePath=".\src\xsfc\xsfui.rh"
>
</File>
</Files>
<Globals>
</Globals>
</VisualStudioProject>

2
tools/vio2sf/in_xsfu.vcproj
View File

@ -48,6 +48,7 @@
/>
<Tool
Name="VCCLCompilerTool"
AdditionalOptions="/MP"
Optimization="2"
InlineFunctionExpansion="1"
AdditionalIncludeDirectories="src/aosdk,src/aosdk/zlib,src"
@ -141,6 +142,7 @@
/>
<Tool
Name="VCCLCompilerTool"
AdditionalOptions="/MP"
Optimization="0"
AdditionalIncludeDirectories="src/aosdk,src/aosdk/zlib,src"
PreprocessorDefinitions="ENABLE_UNICODE_PLUGIN=1;LSB_FIRST;WIN32;_DEBUG;_WINDOWS;_USRDLL;IN_XSF_EXPORTS"

1
tools/vio2sf/src/vio2sf/desmume/NDSSystem.c
View File

@ -25,6 +25,7 @@
#include "NDSSystem.h"
#include "MMU.h"
//#include "cflash.h"
#include "spu_exports.h"
//#include "ROMReader.h"

1
tools/vio2sf/src/vio2sf/desmume/NDSSystem.h
View File

@ -26,7 +26,6 @@
#include "MMU.h"
#include "GPU.h"
#include "SPU_exports.h"
#include "mem.h"
//#include "wifi.h"

131
tools/vio2sf/src/vio2sf/desmume/SPU.cpp
View File

@ -48,40 +48,8 @@
#include "NDSSystem.h"
#include "matrix.h"
FORCEINLINE u32 u32floor(float f)
{
#ifdef ENABLE_SSE2
return (u32)_mm_cvtt_ss2si(_mm_set_ss(f));
#else
return (u32)f;
#endif
}
FORCEINLINE u32 u32floor(double d)
{
#ifdef ENABLE_SSE2
return (u32)_mm_cvttsd_si32(_mm_set_sd(d));
#else
return (u32)d;
#endif
}
//same as above but works for negative values too.
//be sure that the results are the same thing as floorf!
FORCEINLINE s32 s32floor(float f)
{
#ifdef ENABLE_SSE2
return _mm_cvtss_si32( _mm_add_ss(_mm_set_ss(-0.5f),_mm_add_ss(_mm_set_ss(f), _mm_set_ss(f))) ) >> 1;
#else
return (s32)floorf(f);
#endif
}
static FORCEINLINE u32 sputrunc(float f) { return u32floor(f); }
static FORCEINLINE u32 sputrunc(double d) { return u32floor(d); }
static FORCEINLINE s32 spumuldiv7(s32 val, u8 multiplier) {
assert(multiplier <= 127);
return (multiplier == 127) ? val : ((val * multiplier) >> 7);
}
//===================CONFIGURATION========================
#include "src/xsfc/drvimpl.h"
@ -234,6 +202,9 @@ extern "C" void SPU_Reset(void)
//static double cos_lut[256];
static long tot_samples;
static long update_trunc;
extern "C" int SPU_Init(int coreid, int buffersize)
{
int i, j;
@ -263,6 +234,9 @@ extern "C" int SPU_Init(int coreid, int buffersize)
}
}
tot_samples = 0;
update_trunc = 0;
//return SPU_ChangeSoundCore(coreid, buffersize);
return 0;
}
@ -549,7 +523,6 @@ extern "C" void SPU_WriteLong(u32 addr, u32 val)
}
//////////////////////////////////////////////////////////////////////////////
static FORCEINLINE s32 Interpolate(SPUInterpolationMode INTERPOLATE_MODE, s32 a, s32 b, double _ratio)
{
float ratio = (float)_ratio;
@ -570,8 +543,19 @@ static FORCEINLINE s32 Interpolate(SPUInterpolationMode INTERPOLATE_MODE, s32 a,
}
//////////////////////////////////////////////////////////////////////////////
typedef void (*TYPE_EXTEND_PARAM_IMMEDIATE_ADDINSTRUMENT)(unsigned long addr, int type);
typedef BOOL (*TYPE_EXTEND_PARAM_IMMEDIATE_ISINSTRUMENTMUTED)(unsigned long addr);
typedef unsigned long (*TYPE_EXTEND_PARAM_IMMEDIATE_GETINSTRUMENTVOLUME)(unsigned long addr);
double round(double r)
{
return (r > 0.0) ? floor(r + 0.5) : ceil(r - 0.5);
}
static FORCEINLINE void Fetch8BitData(SPUInterpolationMode INTERPOLATE_MODE, channel_struct *chan, s32 *data)
extern "C" TYPE_EXTEND_PARAM_IMMEDIATE_ADDINSTRUMENT addInstrument;
extern "C" TYPE_EXTEND_PARAM_IMMEDIATE_ISINSTRUMENTMUTED isInstrumentMuted;
extern "C" TYPE_EXTEND_PARAM_IMMEDIATE_GETINSTRUMENTVOLUME getInstrumentVolume;
static FORCEINLINE void Fetch8BitData(SPUInterpolationMode INTERPOLATE_MODE, channel_struct *chan, s32 *data, bool INSTRUMENT_EDIT)
{
u32 loc = sputrunc(chan->sampcnt);
if(INTERPOLATE_MODE != SPUInterpolation_None)
@ -585,9 +569,17 @@ static FORCEINLINE void Fetch8BitData(SPUInterpolationMode INTERPOLATE_MODE, cha
}
else
*data = (s32)chan->buf8[loc] << 8;
//if (addInstrument && isInstrumentMuted && getInstrumentVolume)
if(INSTRUMENT_EDIT)
{
addInstrument(chan->addr, 0);
if (isInstrumentMuted(chan->addr)) *data = 0;
else *data = (s32)(round((double)(*data) * (double)getInstrumentVolume(chan->addr)*(double)getInstrumentVolume(chan->addr) / 10000.0));
}
}
static FORCEINLINE void Fetch16BitData(SPUInterpolationMode INTERPOLATE_MODE, const channel_struct * const chan, s32 *data)
static FORCEINLINE void Fetch16BitData(SPUInterpolationMode INTERPOLATE_MODE, const channel_struct * const chan, s32 *data, bool INSTRUMENT_EDIT)
{
const s16* const buf16 = chan->buf16;
const int shift = 1;
@ -604,9 +596,17 @@ static FORCEINLINE void Fetch16BitData(SPUInterpolationMode INTERPOLATE_MODE, co
}
else
*data = (s32)buf16[sputrunc(chan->sampcnt)];
if(INSTRUMENT_EDIT)
//if (addInstrument && isInstrumentMuted && getInstrumentVolume)
{
addInstrument(chan->addr, 1);
if (isInstrumentMuted(chan->addr)) *data = 0;
else *data = (s32)(round((double)(*data) * (double)getInstrumentVolume(chan->addr)*(double)getInstrumentVolume(chan->addr) / 10000.0));
}
}
static FORCEINLINE void FetchADPCMData(SPUInterpolationMode INTERPOLATE_MODE, channel_struct * const chan, s32 * const data)
static FORCEINLINE void FetchADPCMData(SPUInterpolationMode INTERPOLATE_MODE, channel_struct * const chan, s32 * const data, bool INSTRUMENT_EDIT)
{
// No sense decoding, just return the last sample
if (chan->lastsampcnt != sputrunc(chan->sampcnt)){
@ -637,9 +637,17 @@ static FORCEINLINE void FetchADPCMData(SPUInterpolationMode INTERPOLATE_MODE, ch
*data = Interpolate(INTERPOLATE_MODE,(s32)chan->pcm16b_last,(s32)chan->pcm16b,chan->sampcnt);
else
*data = (s32)chan->pcm16b;
if(INSTRUMENT_EDIT)
//if (addInstrument && isInstrumentMuted && getInstrumentVolume)
{
addInstrument(chan->addr, 2);
if (isInstrumentMuted(chan->addr)) *data = 0;
else *data = (s32)(round((double)(*data) * (double)getInstrumentVolume(chan->addr)*(double)getInstrumentVolume(chan->addr) / 10000.0));
}
}
static FORCEINLINE void FetchPSGData(channel_struct *chan, s32 *data)
static FORCEINLINE void FetchPSGData(channel_struct *chan, s32 *data, bool INSTRUMENT_EDIT)
{
if(chan->num < 8)
{
@ -676,6 +684,15 @@ static FORCEINLINE void FetchPSGData(channel_struct *chan, s32 *data)
*data = (s32)chan->psgnoise_last;
}
if(INSTRUMENT_EDIT)
//if (addInstrument && isInstrumentMuted && getInstrumentVolume)
{
addInstrument(0, 3);
if (isInstrumentMuted(0)) *data = 0;
else *data = (s32)(round((double)(*data) * (double)getInstrumentVolume(0)*(double)getInstrumentVolume(0) / 10000.0));
}
}
//////////////////////////////////////////////////////////////////////////////
@ -772,7 +789,7 @@ FORCEINLINE static void SPU_Mix(int CHANNELS, SPU_struct* SPU, channel_struct *c
}
}
FORCEINLINE static void ____SPU_ChanUpdate(int CHANNELS, int FORMAT, SPUInterpolationMode INTERPOLATE_MODE, SPU_struct* const SPU, channel_struct* const chan)
FORCEINLINE static void ____SPU_ChanUpdate(int CHANNELS, int FORMAT, SPUInterpolationMode INTERPOLATE_MODE, SPU_struct* const SPU, channel_struct* const chan, bool INSTRUMENT_EDIT)
{
for (; SPU->bufpos < SPU->buflength; SPU->bufpos++)
{
@ -781,10 +798,10 @@ FORCEINLINE static void ____SPU_ChanUpdate(int CHANNELS, int FORMAT, SPUInterpol
s32 data;
switch(FORMAT)
{
case 0: Fetch8BitData(INTERPOLATE_MODE, chan, &data); break;
case 1: Fetch16BitData(INTERPOLATE_MODE, chan, &data); break;
case 2: FetchADPCMData(INTERPOLATE_MODE, chan, &data); break;
case 3: FetchPSGData(chan, &data); break;
case 0: Fetch8BitData(INTERPOLATE_MODE, chan, &data, INSTRUMENT_EDIT); break;
case 1: Fetch16BitData(INTERPOLATE_MODE, chan, &data, INSTRUMENT_EDIT); break;
case 2: FetchADPCMData(INTERPOLATE_MODE, chan, &data, INSTRUMENT_EDIT); break;
case 3: FetchPSGData(chan, &data, INSTRUMENT_EDIT); break;
}
SPU_Mix(CHANNELS, SPU, chan, data);
}
@ -797,26 +814,26 @@ FORCEINLINE static void ____SPU_ChanUpdate(int CHANNELS, int FORMAT, SPUInterpol
}
}
FORCEINLINE static void ___SPU_ChanUpdate(int FORMAT, SPUInterpolationMode INTERPOLATE_MODE, const bool actuallyMix, SPU_struct* const SPU, channel_struct* const chan)
FORCEINLINE static void ___SPU_ChanUpdate(int FORMAT, SPUInterpolationMode INTERPOLATE_MODE, const bool actuallyMix, SPU_struct* const SPU, channel_struct* const chan, bool INSTRUMENT_EDIT)
{
if(!actuallyMix)
____SPU_ChanUpdate(-1,FORMAT,INTERPOLATE_MODE,SPU,chan);
____SPU_ChanUpdate(-1,FORMAT,INTERPOLATE_MODE,SPU,chan,INSTRUMENT_EDIT);
else if (chan->pan == 0)
____SPU_ChanUpdate(0,FORMAT,INTERPOLATE_MODE,SPU,chan);
____SPU_ChanUpdate(0,FORMAT,INTERPOLATE_MODE,SPU,chan,INSTRUMENT_EDIT);
else if (chan->pan == 127)
____SPU_ChanUpdate(2,FORMAT,INTERPOLATE_MODE,SPU,chan);
____SPU_ChanUpdate(2,FORMAT,INTERPOLATE_MODE,SPU,chan,INSTRUMENT_EDIT);
else
____SPU_ChanUpdate(1,FORMAT,INTERPOLATE_MODE,SPU,chan);
____SPU_ChanUpdate(1,FORMAT,INTERPOLATE_MODE,SPU,chan,INSTRUMENT_EDIT);
}
FORCEINLINE static void __SPU_ChanUpdate(SPUInterpolationMode INTERPOLATE_MODE, const bool actuallyMix, SPU_struct* const SPU, channel_struct* const chan)
FORCEINLINE static void __SPU_ChanUpdate(SPUInterpolationMode INTERPOLATE_MODE, const bool actuallyMix, SPU_struct* const SPU, channel_struct* const chan, bool INSTRUMENT_EDIT)
{
___SPU_ChanUpdate(chan->format,INTERPOLATE_MODE,actuallyMix, SPU, chan);
___SPU_ChanUpdate(chan->format,INTERPOLATE_MODE,actuallyMix, SPU, chan, INSTRUMENT_EDIT);
}
FORCEINLINE static void _SPU_ChanUpdate(const bool actuallyMix, SPU_struct* const SPU, channel_struct* const chan)
FORCEINLINE static void _SPU_ChanUpdate(const bool actuallyMix, SPU_struct* const SPU, channel_struct* const chan, bool INSTRUMENT_EDIT)
{
__SPU_ChanUpdate(spuInterpolationMode(),actuallyMix, SPU, chan);
__SPU_ChanUpdate(spuInterpolationMode(),actuallyMix, SPU, chan,INSTRUMENT_EDIT);
}
@ -853,7 +870,9 @@ static void SPU_MixAudio(bool actuallyMix, SPU_struct *SPU, int length)
SPU->buflength = length;
// Mix audio
_SPU_ChanUpdate(!isChannelMuted(i) && actuallyMix, SPU, chan);
if (addInstrument && isInstrumentMuted && getInstrumentVolume)
_SPU_ChanUpdate(!isChannelMuted(i) && actuallyMix, SPU, chan, true);
else _SPU_ChanUpdate(!isChannelMuted(i) && actuallyMix, SPU, chan, false);
}
// convert from 32-bit->16-bit
@ -898,6 +917,14 @@ void SPU_Emulate_core()
extern "C" void SPU_EmulateSamples(int numsamples)
{
tot_samples += numsamples;
long temp = tot_samples&~1023;
if(update_trunc != temp)
{
void SoundView_Refresh();
SoundView_Refresh();
update_trunc = temp;
}
SPU_MixAudio(true,SPU_core,numsamples);
SNDCoreList[0]->UpdateAudio(SPU_core->outbuf,numsamples);
}

36
tools/vio2sf/src/vio2sf/desmume/SPU.h
View File

@ -25,10 +25,46 @@
#include <string>
#include "types.h"
#include <math.h>
#include <assert.h>
#define FORCEINLINE __forceinline
FORCEINLINE u32 u32floor(float f)
{
#ifdef ENABLE_SSE2
return (u32)_mm_cvtt_ss2si(_mm_set_ss(f));
#else
return (u32)f;
#endif
}
FORCEINLINE u32 u32floor(double d)
{
#ifdef ENABLE_SSE2
return (u32)_mm_cvttsd_si32(_mm_set_sd(d));
#else
return (u32)d;
#endif
}
//same as above but works for negative values too.
//be sure that the results are the same thing as floorf!
FORCEINLINE s32 s32floor(float f)
{
#ifdef ENABLE_SSE2
return _mm_cvtss_si32( _mm_add_ss(_mm_set_ss(-0.5f),_mm_add_ss(_mm_set_ss(f), _mm_set_ss(f))) ) >> 1;
#else
return (s32)floorf(f);
#endif
}
static FORCEINLINE u32 sputrunc(float f) { return u32floor(f); }
static FORCEINLINE u32 sputrunc(double d) { return u32floor(d); }
static FORCEINLINE s32 spumuldiv7(s32 val, u8 multiplier) {
assert(multiplier <= 127);
return (multiplier == 127) ? val : ((val * multiplier) >> 7);
}
#define SNDCORE_DEFAULT -1
#define SNDCORE_DUMMY 0

484
tools/vio2sf/src/vio2sf/desmume/soundView.cpp Normal file
View File

@ -0,0 +1,484 @@
/* soundView.cpp
Copyright (C) 2009-2010 DeSmuME team
This file is part of DeSmuME
DeSmuME is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
DeSmuME is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with DeSmuME; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include "SPU.h"
#include "xsfui.rh"
#include "NDSSystem.h"
#include <algorithm>
#include <windows.h>
#include <windowsx.h>
#include <commctrl.h>
#include "soundView.h"
#include <assert.h>
using namespace std;
struct TCommonSettings {
TCommonSettings()
: spu_captureMuted(false)
, spu_advanced(false)
{
for(int i=0;i<16;i++)
spu_muteChannels[i] = false;
}
bool spu_muteChannels[16];
bool spu_advanced, spu_captureMuted;
} CommonSettings;
//////////////////////////////////////////////////////////////////////////////
typedef struct SoundView_DataStruct
{
SoundView_DataStruct()
: viewFirst8Channels(TRUE)
, volModeAlternate(FALSE)
, destroyed(false)
{
}
volatile bool destroyed;
HWND hDlg;
BOOL viewFirst8Channels;
BOOL volModeAlternate;
} SoundView_DataStruct;
SoundView_DataStruct * SoundView_Data = NULL;
bool IsDlgCheckboxChecked(HWND hDlg, int id)
{
return IsDlgButtonChecked(hDlg,id) == BST_CHECKED;
}
void CheckDlgItem(HWND hDlg, int id, bool checked)
{
CheckDlgButton(hDlg, id, checked ? BST_CHECKED : BST_UNCHECKED);
}
//////////////////////////////////////////////////////////////////////////////
BOOL SoundView_Init()
{
return 1;
}
void SoundView_DeInit()
{
}
//////////////////////////////////////////////////////////////////////////////
inline int chanOfs()
{
return SoundView_Data->viewFirst8Channels ? 0 : 8;
}
extern "C" int SoundView_DlgOpen(HINSTANCE hAppInst)
{
HWND hDlg;
SoundView_Data = new SoundView_DataStruct();
if(SoundView_Data == NULL)
return 0;
hDlg = CreateDialogParamW(hAppInst, MAKEINTRESOURCEW(IDD_SOUND_VIEW), GetDesktopWindow(), SoundView_DlgProc, (LPARAM)SoundView_Data);
if(hDlg == NULL)
{
delete SoundView_Data;
SoundView_Data = NULL;
return 0;
}
SoundView_Data->hDlg = hDlg;
ShowWindow(hDlg, SW_SHOW);
UpdateWindow(hDlg);
return 1;
}
extern "C" void SoundView_DlgClose()
{
if(SoundView_Data != NULL )
{
SendMessage(SoundView_Data->hDlg,WM_APP,0,0);
while(!SoundView_Data->destroyed)
Sleep(1);
delete SoundView_Data;
SoundView_Data = NULL;
}
}
BOOL SoundView_IsOpened()
{
return (SoundView_Data != NULL);
}
HWND SoundView_GetHWnd()
{
return SoundView_Data ? SoundView_Data->hDlg : NULL;
}
extern "C" void SoundView_Refresh()
{
if(SoundView_Data == NULL || SPU_core == NULL)
return;
HWND hDlg = SoundView_Data->hDlg;
PostMessage(hDlg,WM_APP+1,0,0);
}
void DoRefresh()
{
if(SoundView_Data == NULL || SPU_core == NULL)
return;
HWND hDlg = SoundView_Data->hDlg;
char buf[256];
static const int format_shift[] = { 2, 1, 3, 0 };
static const double ARM7_CLOCK = 33513982;
for(int chanId = 0; chanId < 8; chanId++) {
int chan = chanId + chanOfs();
channel_struct &thischan = SPU_core->channels[chan];
SendDlgItemMessage(hDlg, IDC_SOUND0PANBAR+chanId, PBM_SETPOS, (WPARAM)spumuldiv7(128, thischan.pan), (LPARAM)0);
if(thischan.status != CHANSTAT_STOPPED)
{
s32 vol = spumuldiv7(128, thischan.vol) >> thischan.datashift;
SendDlgItemMessage(hDlg, IDC_SOUND0VOLBAR+chanId, PBM_SETPOS,
(WPARAM)vol, (LPARAM)0);
if(SoundView_Data->volModeAlternate)
sprintf(buf, "%d/%d", thischan.vol, 1 << thischan.datashift);
else
sprintf(buf, "%d", vol);
SetDlgItemText(hDlg, IDC_SOUND0VOL+chanId, buf);
if (thischan.pan == 0)
strcpy(buf, "L");
else if (thischan.pan == 64)
strcpy(buf, "C");
else if (thischan.pan == 127)
strcpy(buf, "R");
else if (thischan.pan < 64)
sprintf(buf, "L%d", 64 - thischan.pan);
else //if (thischan.pan > 64)
sprintf(buf, "R%d", thischan.pan - 64);
SetDlgItemText(hDlg, IDC_SOUND0PAN+chanId, buf);
sprintf(buf, "%d", thischan.hold);
SetDlgItemText(hDlg, IDC_SOUND0HOLD+chanId, buf);
sprintf(buf, "%d", thischan.status);
SetDlgItemText(hDlg, IDC_SOUND0BUSY+chanId, buf);
const char* modes[] = { "Manual", "Loop Infinite", "One-Shot", "Prohibited" };
sprintf(buf, "%d (%s)", thischan.repeat, modes[thischan.repeat]);
SetDlgItemText(hDlg, IDC_SOUND0REPEATMODE+chanId, buf);
if(thischan.format != 3) {
const char* formats[] = { "PCM8", "PCM16", "IMA-ADPCM" };
sprintf(buf, "%d (%s)", thischan.format, formats[thischan.format]);
SetDlgItemText(hDlg, IDC_SOUND0FORMAT+chanId, buf);
}
else {
if (chan < 8)
sprintf(buf, "%d (PSG/Noise?)", thischan.format);
else if (chan < 14)
sprintf(buf, "%d (%.1f% Square)", thischan.format, (float)thischan.waveduty/8);
else
sprintf(buf, "%d (Noise)", thischan.format);
}
sprintf(buf, "$%07X", thischan.addr);
SetDlgItemText(hDlg, IDC_SOUND0SAD+chanId, buf);
sprintf(buf, "samp #%d", thischan.loopstart << format_shift[thischan.format]);
SetDlgItemText(hDlg, IDC_SOUND0PNT+chanId, buf);
sprintf(buf, "$%04X (%.1f Hz)", thischan.timer, (ARM7_CLOCK/2) / (double)(0x10000 - thischan.timer));
SetDlgItemText(hDlg, IDC_SOUND0TMR+chanId, buf);
sprintf(buf, "samp #%d / #%d", sputrunc(thischan.sampcnt), thischan.totlength << format_shift[thischan.format]);
SetDlgItemText(hDlg, IDC_SOUND0POSLEN+chanId, buf);
}
else {
SendDlgItemMessage(hDlg, IDC_SOUND0VOLBAR+chanId, PBM_SETPOS, (WPARAM)0, (LPARAM)0);
strcpy(buf, "---");
SetDlgItemText(hDlg, IDC_SOUND0VOL+chanId, buf);
SetDlgItemText(hDlg, IDC_SOUND0PAN+chanId, buf);
SetDlgItemText(hDlg, IDC_SOUND0HOLD+chanId, buf);
SetDlgItemText(hDlg, IDC_SOUND0BUSY+chanId, buf);
SetDlgItemText(hDlg, IDC_SOUND0REPEATMODE+chanId, buf);
SetDlgItemText(hDlg, IDC_SOUND0FORMAT+chanId, buf);
SetDlgItemText(hDlg, IDC_SOUND0SAD+chanId, buf);
SetDlgItemText(hDlg, IDC_SOUND0PNT+chanId, buf);
SetDlgItemText(hDlg, IDC_SOUND0TMR+chanId, buf);
SetDlgItemText(hDlg, IDC_SOUND0POSLEN+chanId, buf);
}
} //chan loop
//TODO - CAP REGS
////ctrl
//{
// CheckDlgItem(hDlg,IDC_SNDCTRL_ENABLE,SPU_core->regs.masteren!=0);
// CheckDlgItem(hDlg,IDC_SNDCTRL_CH1NOMIX,SPU_core->regs.ctl_ch1bypass!=0);
// CheckDlgItem(hDlg,IDC_SNDCTRL_CH3NOMIX,SPU_core->regs.ctl_ch3bypass!=0);
// sprintf(buf,"%04X",_MMU_ARM7_read16(0x04000500));
// SetDlgItemText(hDlg,IDC_SNDCTRL_CTRL,buf);
// sprintf(buf,"%04X",_MMU_ARM7_read16(0x04000504));
// SetDlgItemText(hDlg,IDC_SNDCTRL_BIAS,buf);
// sprintf(buf,"%02X",SPU_core->regs.mastervol);
// SetDlgItemText(hDlg,IDC_SNDCTRL_VOL,buf);
// sprintf(buf,"%01X",SPU_core->regs.ctl_left);
// SetDlgItemText(hDlg,IDC_SNDCTRL_LEFTOUT,buf);
// sprintf(buf,"%01X",SPU_core->regs.ctl_right);
// SetDlgItemText(hDlg,IDC_SNDCTRL_RIGHTOUT,buf);
// static const char* leftouttext[] = {"L-Mix","Ch1","Ch3","Ch1+3"};
// static const char* rightouttext[] = {"R-Mix","Ch1","Ch3","Ch1+3"};
// SetDlgItemText(hDlg,IDC_SNDCTRL_LEFTOUTTEXT,leftouttext[SPU_core->regs.ctl_left]);
// SetDlgItemText(hDlg,IDC_SNDCTRL_RIGHTOUTTEXT,rightouttext[SPU_core->regs.ctl_right]);
//}
////cap0
//{
// SPU_struct::REGS::CAP& cap = SPU_core->regs.cap[0];
// CheckDlgItem(hDlg,IDC_CAP0_ADD,cap.add!=0);
// CheckDlgItem(hDlg,IDC_CAP0_SRC,cap.source!=0);
// CheckDlgItem(hDlg,IDC_CAP0_ONESHOT,cap.oneshot!=0);
// CheckDlgItem(hDlg,IDC_CAP0_TYPE,cap.bits8!=0);
// CheckDlgItem(hDlg,IDC_CAP0_ACTIVE,cap.active!=0);
// CheckDlgItem(hDlg,IDC_CAP0_RUNNING,cap.runtime.running!=0);
// if(cap.source) SetDlgItemText(hDlg,IDC_CAP0_SRCTEXT,"Ch2");
// else SetDlgItemText(hDlg,IDC_CAP0_SRCTEXT,"L-Mix");
// if(cap.bits8) SetDlgItemText(hDlg,IDC_CAP0_TYPETEXT,"Pcm8");
// else SetDlgItemText(hDlg,IDC_CAP0_TYPETEXT,"Pcm16");
// sprintf(buf,"%02X",_MMU_ARM7_read08(0x04000508));
// SetDlgItemText(hDlg,IDC_CAP0_CTRL,buf);
// sprintf(buf,"%08X",cap.dad);
// SetDlgItemText(hDlg,IDC_CAP0_DAD,buf);
// sprintf(buf,"%08X",cap.len);
// SetDlgItemText(hDlg,IDC_CAP0_LEN,buf);
// sprintf(buf,"%08X",cap.runtime.curdad);
// SetDlgItemText(hDlg,IDC_CAP0_CURDAD,buf);
//}
////cap1
//{
// SPU_struct::REGS::CAP& cap = SPU_core->regs.cap[1];
// CheckDlgItem(hDlg,IDC_CAP1_ADD,cap.add!=0);
// CheckDlgItem(hDlg,IDC_CAP1_SRC,cap.source!=0);
// CheckDlgItem(hDlg,IDC_CAP1_ONESHOT,cap.oneshot!=0);
// CheckDlgItem(hDlg,IDC_CAP1_TYPE,cap.bits8!=0);
// CheckDlgItem(hDlg,IDC_CAP1_ACTIVE,cap.active!=0);
// CheckDlgItem(hDlg,IDC_CAP1_RUNNING,cap.runtime.running!=0);
// if(cap.source) SetDlgItemText(hDlg,IDC_CAP1_SRCTEXT,"Ch3"); //maybe call it "Ch3(+2)" if it fits
// else SetDlgItemText(hDlg,IDC_CAP1_SRCTEXT,"R-Mix");
// if(cap.bits8) SetDlgItemText(hDlg,IDC_CAP1_TYPETEXT,"Pcm8");
// else SetDlgItemText(hDlg,IDC_CAP1_TYPETEXT,"Pcm16");
// sprintf(buf,"%02X",_MMU_ARM7_read08(0x04000509));
// SetDlgItemText(hDlg,IDC_CAP1_CTRL,buf);
// sprintf(buf,"%08X",cap.dad);
// SetDlgItemText(hDlg,IDC_CAP1_DAD,buf);
// sprintf(buf,"%08X",cap.len);
// SetDlgItemText(hDlg,IDC_CAP1_LEN,buf);
// sprintf(buf,"%08X",cap.runtime.curdad);
// SetDlgItemText(hDlg,IDC_CAP1_CURDAD,buf);
//}
}
//////////////////////////////////////////////////////////////////////////////
static void updateMute_toSettings(HWND hDlg, int chan)
{
//for(int chanId = 0; chanId < 8; chanId++)
// CommonSettings.spu_muteChannels[chanId+chanOfs()] = IsDlgButtonChecked(hDlg, IDC_SOUND0MUTE+chanId) == BST_CHECKED;
}
static void updateMute_allFromSettings(HWND hDlg)
{
//for(int chanId = 0; chanId < 16; chanId++)
// CheckDlgItem(hDlg,IDC_SOUND0MUTE+chanId,CommonSettings.spu_muteChannels[chanId]);
}
static void updateMute_fromSettings(HWND hDlg)
{
//for(int chanId = 0; chanId < 8; chanId++)
// CheckDlgItem(hDlg,IDC_SOUND0MUTE+chanId,CommonSettings.spu_muteChannels[chanId+chanOfs()]);
}
static void SoundView_SwitchChanOfs(SoundView_DataStruct *data)
{
if (data == NULL)
return;
HWND hDlg = data->hDlg;
data->viewFirst8Channels = !data->viewFirst8Channels;
SetWindowText(GetDlgItem(hDlg, IDC_SOUNDVIEW_CHANSWITCH),
data->viewFirst8Channels ? "V" : "^");
char buf[256];
for(int chanId = 0; chanId < 8; chanId++) {
int chan = chanId + chanOfs();
sprintf(buf, "#%02d", chan);
SetDlgItemText(hDlg, IDC_SOUND0ID+chanId, buf);
}
updateMute_fromSettings(hDlg);
CheckDlgItem(hDlg,IDC_SOUND_CAPTURE_MUTED,CommonSettings.spu_captureMuted);
SoundView_Refresh();
}
static INT_PTR CALLBACK SoundView_DlgProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
//SoundView_DataStruct *data = (SoundView_DataStruct*)GetWindowLongPtr(hDlg, DWLP_USER);
//if((data == NULL) && (uMsg != WM_INITDIALOG))
// return 0;
SoundView_DataStruct *data = SoundView_Data;
switch(uMsg)
{
case WM_NCDESTROY:
data->destroyed = true;
break;
case WM_APP+0:
DestroyWindow(hDlg);
break;
case WM_APP+1:
DoRefresh();
break;
case WM_INITDIALOG:
{
//for(int chanId = 0; chanId < 8; chanId++) {
// SendDlgItemMessage(hDlg, IDC_SOUND0VOLBAR+chanId, PBM_SETRANGE, (WPARAM)0, MAKELPARAM(0, 128));
// SendDlgItemMessage(hDlg, IDC_SOUND0PANBAR+chanId, PBM_SETRANGE, (WPARAM)0, MAKELPARAM(0, 128));
//}
//for(int chanId = 0; chanId < 8; chanId++) {
// if(CommonSettings.spu_muteChannels[chanId])
// SendDlgItemMessage(hDlg, IDC_SOUND0MUTE+chanId, BM_SETCHECK, TRUE, 0);
//}
//if(data == NULL)
//{
// data = (SoundView_DataStruct*)lParam;
// SetWindowLongPtr(hDlg, DWLP_USER, (LONG)data);
//}
//data->hDlg = hDlg;
//data->viewFirst8Channels = !data->viewFirst8Channels;
//SoundView_SwitchChanOfs(data);
////SoundView_Refresh();
////InvalidateRect(hDlg, NULL, FALSE); UpdateWindow(hDlg);
}
return 1;
case WM_CLOSE:
SoundView_DlgClose();
return 1;
case WM_COMMAND:
switch(LOWORD(wParam))
{
case IDOK:
case IDCANCEL:
SoundView_DlgClose();
return 1;
case IDC_BUTTON_VOLMODE:
data->volModeAlternate = IsDlgButtonChecked(hDlg, IDC_BUTTON_VOLMODE);
return 1;
case IDC_SOUND0MUTE+0:
case IDC_SOUND0MUTE+1:
case IDC_SOUND0MUTE+2:
case IDC_SOUND0MUTE+3:
case IDC_SOUND0MUTE+4:
case IDC_SOUND0MUTE+5:
case IDC_SOUND0MUTE+6:
case IDC_SOUND0MUTE+7:
updateMute_toSettings(hDlg,LOWORD(wParam)-IDC_SOUND0MUTE);
return 1;
case IDC_SOUND_CAPTURE_MUTED:
CommonSettings.spu_captureMuted = IsDlgButtonChecked(hDlg,IDC_SOUND_CAPTURE_MUTED) != 0;
return 1;
case IDC_SOUND_UNMUTE_ALL:
for(int i=0;i<16;i++) CommonSettings.spu_muteChannels[i] = false;
updateMute_allFromSettings(hDlg);
return 1;
case IDC_SOUND_ANALYZE_CAP:
printf("WTF\n");
for(int i=0;i<16;i++) CommonSettings.spu_muteChannels[i] = true;
CommonSettings.spu_muteChannels[1] = false;
CommonSettings.spu_muteChannels[3] = false;
CommonSettings.spu_captureMuted = true;
updateMute_allFromSettings(hDlg);
CheckDlgItem(hDlg,IDC_SOUND_CAPTURE_MUTED,CommonSettings.spu_captureMuted);
return 1;
case IDC_SOUNDVIEW_CHANSWITCH:
{
SoundView_SwitchChanOfs(data);
}
return 1;
}
return 0;
}
return 0;
}
//////////////////////////////////////////////////////////////////////////////

34
tools/vio2sf/src/vio2sf/desmume/soundView.h Normal file
View File

@ -0,0 +1,34 @@
/* Copyright (C) 2006 yopyop
yopyop156@ifrance.com
yopyop156.ifrance.com
This file is part of DeSmuME
DeSmuME is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
DeSmuME is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with DeSmuME; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef SOUND_VIEW_H
#define SOUND_VIEW_H
BOOL SoundView_Init();
void SoundView_DeInit();
BOOL SoundView_DlgOpen(HWND hParentWnd);
BOOL SoundView_IsOpened();
HWND SoundView_GetHWnd();
INT_PTR CALLBACK SoundView_DlgProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam);
#endif

23
tools/vio2sf/src/xsfc/in_xsf.cpp
View File

@ -267,6 +267,12 @@ public:
Free();
return false;
}
lpif->SetExtendParamImmediate(EXTEND_PARAM_IMMEDIATE_ADDINSTRUMENT, addInstrument);
lpif->SetExtendParamImmediate(EXTEND_PARAM_IMMEDIATE_ISINSTRUMENTMUTED, isInstrumentMuted);
lpif->SetExtendParamImmediate(EXTEND_PARAM_IMMEDIATE_GETINSTRUMENTVOLUME, getInstrumentVolume);
lpif->SetExtendParamImmediate(EXTEND_PARAM_IMMEDIATE_OPENSOUNDVIEW, openSoundView);
return true;
}
@ -333,7 +339,7 @@ public:
}
if (lpif->dwInterfaceVersion >= 4)
{
lpif->SetExtendParamImmediate(EXTEND_PARAM_IMMEDIATE_INTERPOLATION,&dwInterpolation);
lpif->SetExtendParamImmediate(EXTEND_PARAM_IMMEDIATE_INTERPOLATION, &dwInterpolation);
}
while (pos < bufsize)
{
@ -900,7 +906,7 @@ public:
};
class WinampPlugin
{
{
protected:
static XSFDriver xsfdrv;
static HMODULE m_hDLL;
@ -1018,7 +1024,7 @@ protected:
int request2 = ::InterlockedExchange((LPLONG)&m_lRequest, 0);
if (request2 & (1 << REQUEST_STOP))
{
request1 |= (1 << REQUEST_STOP);
request1 |= (1 << REQUEST_STOP);
break;
}
}
@ -1026,6 +1032,8 @@ protected:
} while (mod.outMod->IsPlaying());
}
void killSoundView();
killSoundView();
xsfdrv.Free();
if (!(request1 & (1 << REQUEST_STOP)))
@ -1115,6 +1123,14 @@ protected:
{
xsfdrv.seek_kil = 1;
Request(REQUEST_STOP);
MSG msg;
while( PeekMessage( &msg, 0, 0, 0, PM_NOREMOVE ) )
if( GetMessage( &msg, 0, 0, 0)>0 ) {
TranslateMessage(&msg);
DispatchMessage(&msg);
}
} while (::WaitForSingleObject(m_hThread, 20) == WAIT_TIMEOUT);
::CloseHandle(m_hThread);
m_hThread = NULL;
@ -1962,3 +1978,4 @@ BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
}
return TRUE;
}

423
tools/vio2sf/src/xsfc/in_xsfcfg.cpp
View File

@ -3,6 +3,8 @@
#include <windows.h>
#include <windowsx.h>
#include <strsafe.h>
#include <commctrl.h>
/* Winamp SDK headers */
#include <winamp/wa_ipc.h>
@ -158,14 +160,433 @@ static BOOL CALLBACK DialogProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM l
return FALSE;
}
int msgBox(TCHAR* stringFormat, ...)
{
va_list valist;
va_start( valist, stringFormat);
TCHAR msgPassed[2000];
StringCbVPrintf(msgPassed, sizeof(msgPassed), stringFormat, valist);
return MessageBox(NULL, msgPassed, "msgBox", MB_OK | MB_SYSTEMMODAL);
}
BOOL vsSetDlgItemText(HWND hDlg, int nIDDlgItem, TCHAR* stringFormat, ...)
{
va_list valist;
va_start( valist, stringFormat);
TCHAR msgPassed[2000];
StringCbVPrintf(msgPassed, sizeof(msgPassed), stringFormat, valist);
return SetDlgItemText(hDlg, nIDDlgItem, msgPassed);
}
unsigned long GetDlgItemHex(HWND wnd, UINT wndMsg)
{
TCHAR read[20]; unsigned long res;
GetDlgItemText(wnd, wndMsg, read, sizeof(read)/sizeof(TCHAR));
size_t len; StringCbLength(read, sizeof(read), &len);
if (len>=1) sscanf_s(read, "%X", &res); else res=0;
return res;
}
HWND dlgInstrumentSelection=0;
HWND dlgMixerInstrument[50];
class Instrument
{
public:
unsigned long addr;
int type;
BOOL selectedStatus;
BOOL muteStatus;
unsigned long volume;
TCHAR name[100];
};
Instrument instrument[50];
int nbInstruments=0;
TCHAR* getInstrumentName(unsigned long addr)
{
for (int i=0; i<nbInstruments; i++)
if (instrument[i].addr == addr) return instrument[i].name;
return "[Instrument address not in the list]";
}
void setInstrumentName(unsigned long addr, TCHAR* stringFormat, ...)
{
va_list valist;
va_start( valist, stringFormat);
for (int i=0; i<nbInstruments; i++)
if (instrument[i].addr == addr) StringCbVPrintf(instrument[i].name, sizeof(instrument[i].name), stringFormat, valist);
}
int semaphore = 0;
typedef void (*TOpenSoundView)(void* hinst);
struct CallbackSet
{
TOpenSoundView doOpenSoundView;
TOpenSoundView killSoundView;
} soundViewCallbacks = {NULL,NULL};
void openSoundView(void* callback)
{
soundViewCallbacks = *(CallbackSet*)callback;
}
void killSoundView()
{
soundViewCallbacks.killSoundView(NULL);
soundViewCallbacks.doOpenSoundView = NULL;
soundViewCallbacks.killSoundView = NULL;
}
void addInstrument(unsigned long addr, int type)
{
if (nbInstruments >= 50) return;
while (semaphore != 0) Sleep(0); /* thread safety (exchangeInstruments) */
for (int i=0; i<nbInstruments; i++)
if (instrument[i].addr == addr) return;
instrument[nbInstruments].addr = addr;
instrument[nbInstruments].type = type;
instrument[nbInstruments].selectedStatus = FALSE;
instrument[nbInstruments].muteStatus = FALSE;
instrument[nbInstruments].volume = 100;
StringCbPrintf(instrument[nbInstruments].name, sizeof(instrument[nbInstruments].name), "Instrument %i", nbInstruments+1);
nbInstruments++;
if (dlgInstrumentSelection)
PostMessage(dlgInstrumentSelection, WM_APP, 0, 0);
}
int getNbInstruments() { return nbInstruments; }
unsigned long getInstrumentAddr(int i)
{
if (i<nbInstruments) return instrument[i].addr; else return 0;
}
int getInstrumentIndex(unsigned long addr)
{
for (int i=0; i<nbInstruments; i++)
if (instrument[i].addr == addr) return i;
return -1;
}
int getInstrumentType(unsigned long addr)
{
for (int i=0; i<nbInstruments; i++)
if (instrument[i].addr == addr) return instrument[i].type;
return -1;
}
BOOL isInstrumentSelected(unsigned long addr)
{
for (int i=0; i<nbInstruments; i++)
if (instrument[i].addr == addr) return instrument[i].selectedStatus;
return FALSE;
}
BOOL isInstrumentMuted(unsigned long addr)
{
for (int i=0; i<nbInstruments; i++)
if (instrument[i].addr == addr)
return instrument[i].muteStatus;
return FALSE;
}
unsigned long getInstrumentVolume(unsigned long addr)
{
for (int i=0; i<nbInstruments; i++)
if (instrument[i].addr == addr)
return instrument[i].volume;
return 100;
}
void clearInstrumentList() { nbInstruments = 0; }
void setInstrumentSelectedStatus(unsigned long addr, BOOL selected)
{
for (int i=0; i<nbInstruments; i++)
if (instrument[i].addr == addr) instrument[i].selectedStatus = selected;
}
void setInstrumentMuteStatus(unsigned long addr, BOOL muted)
{
for (int i=0; i<nbInstruments; i++)
if (instrument[i].addr == addr) instrument[i].muteStatus = muted;
}
void setInstrumentVolume(unsigned long addr, unsigned long volume)
{
for (int i=0; i<nbInstruments; i++)
if (instrument[i].addr == addr) instrument[i].volume = volume;
}
void exchangeInstruments(unsigned long addr1, unsigned long addr2)
{
int a,b;
for (a=0; a<nbInstruments; a++) if (instrument[a].addr == addr1) break;
for (b=0; b<nbInstruments; b++) if (instrument[b].addr == addr2) break;
if (a == nbInstruments || b == nbInstruments || a==b)
{
MessageBeep(MB_ICONEXCLAMATION);
return;
}
semaphore++;
Instrument tmp;
CopyMemory(&tmp, &instrument[a], sizeof(Instrument));
CopyMemory(&instrument[a], &instrument[b], sizeof(Instrument));
CopyMemory(&instrument[b], &tmp, sizeof(Instrument));
semaphore--;
}
void updateInstrumentsSelectedStatus(HWND dlg)
{
unsigned long trackBarVolume = SendDlgItemMessage(dlg, IDC_SLIDER_VOLUME, TBM_GETPOS , TRUE, 0);
for (int i=0; i<SendDlgItemMessage(dlg, IDC_LISTINSTRUMENTS, LB_GETCOUNT , 0, 0); i++)
{
unsigned long addr = SendDlgItemMessage(dlg, IDC_LISTINSTRUMENTS, LB_GETITEMDATA, i, 0);
setInstrumentSelectedStatus(addr, !(SendDlgItemMessage(dlg, IDC_LISTINSTRUMENTS, LB_GETSEL, i, 0) == 0));
setInstrumentVolume(addr, (SendDlgItemMessage(dlg, IDC_LISTINSTRUMENTS, LB_GETSEL, i, 0) == 0 ? 100 : trackBarVolume));
}
}
void updateInstrumentListbox(HWND dlg)
{
SendDlgItemMessage(dlg, IDC_LISTINSTRUMENTS, LB_RESETCONTENT, 0, 0);
/*SendDlgItemMessage(dlg, IDC_LISTVIEWINSTRUMENTS, LVM_DELETEALLITEMS, 0, 0);*/
for (int i=0; i<getNbInstruments(); i++)
{
/*LVITEM lvi; lvi.mask = LVIF_TEXT | LVIF_IMAGE | LVIF_PARAM | LVIF_STATE; lvi.state = 0; lvi.stateMask = 0;
lvi.iItem = lvi.iImage = i; lvi.iSubItem =0; lvi.pszText = getInstrumentName(getInstrumentAddr(i)); lvi.lParam = getInstrumentAddr(i);
SendDlgItemMessage(dlg, IDC_LISTVIEWINSTRUMENTS, LVM_INSERTITEM, 0, (LPARAM)&lvi);*/
SendDlgItemMessage(dlg, IDC_LISTINSTRUMENTS, LB_ADDSTRING, 0, (LPARAM)getInstrumentName(getInstrumentAddr(i)));
SendDlgItemMessage(dlg, IDC_LISTINSTRUMENTS, LB_SETITEMDATA , i, getInstrumentAddr(i));
SendDlgItemMessage(dlg, IDC_LISTINSTRUMENTS, LB_SELITEMRANGE, isInstrumentSelected(getInstrumentAddr(i)), MAKELPARAM(i, i));
}
vsSetDlgItemText(dlg, IDC_STATICNBINSTRUMENTSDISPLAYED, "%i instruments found", getNbInstruments());
}
int searchInstrument(HWND dlg, unsigned long addr)
{
for (int i=0; i<SendDlgItemMessage(dlg, IDC_LISTINSTRUMENTS, LB_GETCOUNT , 0, 0); i++)
if (addr == SendDlgItemMessage(dlg, IDC_LISTINSTRUMENTS, LB_GETITEMDATA, i, 0)) return i;
return -1;
}
BOOL CALLBACK dlgProcEnterInstrumentName(HWND dlg, UINT message, WPARAM wParam, LPARAM lParam)
{
static unsigned long doubleClickedInstrumentAddr = 0;
switch (message)
{
case WM_INITDIALOG:
{
doubleClickedInstrumentAddr = lParam;
SetDlgItemText(dlg, IDC_EDIT_ENTERINSTRUMENTNAME, getInstrumentName(doubleClickedInstrumentAddr));
int type = getInstrumentType(doubleClickedInstrumentAddr);
int index = getInstrumentIndex(doubleClickedInstrumentAddr);
vsSetDlgItemText(dlg, IDC_EDIT_ENTERINSTRUMENTNAMEADDRESS, "Address of instrument (%s): %X", (type == 0? "8 bit data" : (type == 1? "16 bit data" : (type == 2? "ADPCM" : "PSG"))), doubleClickedInstrumentAddr);
SendDlgItemMessage(dlg, IDC_EDIT_ENTERINSTRUMENTNAME, EM_SETSEL, 0, -1);
SetFocus(GetDlgItem(dlg, IDC_EDIT_ENTERINSTRUMENTNAME));
return FALSE ;
}
case WM_COMMAND:
switch (LOWORD(wParam))
{
case IDOK:
TCHAR name[sizeof(instrument[0].name)];
GetDlgItemText(dlg, IDC_EDIT_ENTERINSTRUMENTNAME, name, sizeof(name));
setInstrumentName(doubleClickedInstrumentAddr, name);
EndDialog(dlg, IDOK);
break;
case IDCANCEL:
EndDialog(dlg, IDCANCEL);
break;
default: return FALSE;
}
break;
}
return FALSE;
}
BOOL CALLBACK dlgProcMixerInstrument(HWND dlg, UINT message, WPARAM wParam, LPARAM lParam)
{
switch (message)
{
case WM_COMMAND:
switch (LOWORD(wParam))
{
case IDC_STATIC_INSTRUMENTNAME:
if (HIWORD(wParam)==STN_DBLCLK)
{
unsigned long addr;
int i;
for (i=0; i<getNbInstruments(); i++)
if (dlg == dlgMixerInstrument[i]) break;
addr = getInstrumentAddr(i);
DialogBoxParam(hDLL, MAKEINTRESOURCE(IDD_DIALOGENTERINSTRUMENTNAME), dlg, (DLGPROC)dlgProcEnterInstrumentName, addr);
}
break;
default: return FALSE;
}
}
return FALSE;
}
BOOL CALLBACK dlgProcInstrumentSelection(HWND dlg, UINT message, WPARAM wParam, LPARAM lParam)
{
switch (message)
{
case WM_INITDIALOG:
{
updateInstrumentListbox(dlg);
SendDlgItemMessage(dlg, IDC_SLIDER_VOLUME, TBM_SETRANGE , TRUE, MAKELONG(0,100));
SendDlgItemMessage(dlg, IDC_SLIDER_VOLUME, TBM_SETTICFREQ , 10, 0);
SendDlgItemMessage(dlg, IDC_SLIDER_VOLUME, TBM_SETPOS , TRUE, 20);
/*
//SendDlgItemMessage(dlg, IDC_TREE_INSTRUMENTNAMES, TVM_SETBKCOLOR, 0, RGB(240,240,240));
//RECT treeViewScreenRect; GetWindowRect(GetDlgItem(dlg, IDC_TREE_INSTRUMENTNAMES), &treeViewScreenRect);
//POINT treeViewClientPosTopLeft = {treeViewScreenRect.left, treeViewScreenRect.top};
//POINT treeViewClientPosBottomRight = {treeViewScreenRect.right, treeViewScreenRect.bottom};
//ScreenToClient(dlg, &treeViewClientPosTopLeft);
//ScreenToClient(dlg, &treeViewClientPosBottomRight);
int positionShift=0;
for (int i=0; i<getNbInstruments();i++)
{
unsigned long addr = getInstrumentAddr(i);
dlgMixerInstrument[i] = CreateDialogParam(hDLL, MAKEINTRESOURCE(IDD_DIALOG_MIXERINSTRUMENT), dlg, (DLGPROC)dlgProcMixerInstrument, (LPARAM)addr);
SetWindowPos(dlgMixerInstrument[i], HWND_TOP, 550, positionShift, 0,0,SWP_SHOWWINDOW | SWP_NOSIZE);
RECT rectMixerInstrument; GetClientRect(dlgMixerInstrument[i], &rectMixerInstrument);
positionShift += rectMixerInstrument.bottom;
//SetWindowLong(GetDlgItem(dlgMixerInstrument[i], IDC_SLIDER_INSTRUMENTVOLUME), GWL_STYLE, TBS_DOWNISLEFT);
SendDlgItemMessage(dlgMixerInstrument[i], IDC_SLIDER_INSTRUMENTVOLUME, TBM_SETRANGE , TRUE, MAKELONG(0,130));
SendDlgItemMessage(dlgMixerInstrument[i], IDC_SLIDER_INSTRUMENTVOLUME, TBM_SETTICFREQ , 10, 0);
SendDlgItemMessage(dlgMixerInstrument[i], IDC_SLIDER_INSTRUMENTVOLUME, TBM_SETPOS , TRUE, getInstrumentVolume(addr));
if (!isInstrumentMuted(addr)) CheckDlgButton(dlgMixerInstrument[i], IDC_CHECK_INSTRUMENTMUTE, BST_UNCHECKED);
else CheckDlgButton(dlgMixerInstrument[i], IDC_CHECK_INSTRUMENTMUTE, BST_CHECKED);
SetDlgItemText(dlgMixerInstrument[i], IDC_STATIC_INSTRUMENTNAME, getInstrumentName(addr));
//TVINSERTSTRUCT tvinsert; tvinsert.hParent = TVI_ROOT; tvinsert.hInsertAfter = TVI_LAST;
//tvinsert.item.mask = TVIF_TEXT | TVIF_PARAM; tvinsert.item.pszText = getInstrumentName(addr); tvinsert.item.lParam = addr;
//SendDlgItemMessage(dlg, IDC_TREE_INSTRUMENTNAMES, TVM_INSERTITEM, 0, (LPARAM)&tvinsert);
}*/
return TRUE;
}
case WM_HSCROLL:
if (lParam == (LPARAM)GetDlgItem(dlg, IDC_SLIDER_VOLUME)) updateInstrumentsSelectedStatus(dlg);
break;
case WM_APP:
updateInstrumentListbox(dlg);
break;
case WM_COMMAND:
switch (LOWORD(wParam))
{
case IDC_BUTTONCLEARLIST:
if (HIWORD(wParam)==BN_CLICKED)
{
clearInstrumentList();
SendDlgItemMessage(dlg, IDC_LISTINSTRUMENTS, LB_RESETCONTENT, 0, 0);
}
break;
case IDC_BUTTONSELECTALL:
if (HIWORD(wParam)==BN_CLICKED)
{
SendDlgItemMessage(dlg, IDC_LISTINSTRUMENTS, LB_SELITEMRANGE, 1, SendDlgItemMessage(dlg, IDC_LISTINSTRUMENTS, LB_GETCOUNT , 0, 0));
updateInstrumentsSelectedStatus(dlg);
}
break;
case IDC_BUTTONSELECTNONE:
if (HIWORD(wParam)==BN_CLICKED)
{
SendDlgItemMessage(dlg, IDC_LISTINSTRUMENTS, LB_SELITEMRANGE, 0, SendDlgItemMessage(dlg, IDC_LISTINSTRUMENTS, LB_GETCOUNT , 0, 0));
updateInstrumentsSelectedStatus(dlg);
}
break;
case IDC_LISTINSTRUMENTS:
if (HIWORD(wParam)==LBN_SELCHANGE) updateInstrumentsSelectedStatus(dlg);
if (HIWORD(wParam)==LBN_DBLCLK)
{
int doubleClickedInstrumentIndex = SendDlgItemMessage(dlg, IDC_LISTINSTRUMENTS, LB_GETCARETINDEX, 0, 0);
SendDlgItemMessage(dlg, IDC_LISTINSTRUMENTS, LB_SETSEL, FALSE, doubleClickedInstrumentIndex);
updateInstrumentsSelectedStatus(dlg);
unsigned long doubleClickedInstrumentAddr = SendDlgItemMessage(dlg, IDC_LISTINSTRUMENTS, LB_GETITEMDATA, doubleClickedInstrumentIndex, 0);
DialogBoxParam(hDLL, MAKEINTRESOURCE(IDD_DIALOGENTERINSTRUMENTNAME), dlg, (DLGPROC)dlgProcEnterInstrumentName, (LPARAM)doubleClickedInstrumentAddr);
updateInstrumentListbox(dlg);
SendDlgItemMessage(dlg, IDC_LISTINSTRUMENTS, LB_SETCARETINDEX, doubleClickedInstrumentIndex, TRUE);
}
break;
case IDC_BUTTONMOVEINSTRUMENTUP:
{
int currentInstrumentIndex = SendDlgItemMessage(dlg, IDC_LISTINSTRUMENTS, LB_GETCARETINDEX, 0, 0);
if (currentInstrumentIndex==0) break;
unsigned long addr1 = SendDlgItemMessage(dlg, IDC_LISTINSTRUMENTS, LB_GETITEMDATA, currentInstrumentIndex, 0);
unsigned long addr2 = SendDlgItemMessage(dlg, IDC_LISTINSTRUMENTS, LB_GETITEMDATA, currentInstrumentIndex-1, 0);
exchangeInstruments(addr1, addr2);
updateInstrumentListbox(dlg);
SendDlgItemMessage(dlg, IDC_LISTINSTRUMENTS, LB_SETCARETINDEX, currentInstrumentIndex-1, TRUE);
}
break;
case IDC_BUTTONMOVEINSTRUMENTDOWN:
{
int currentInstrumentIndex = SendDlgItemMessage(dlg, IDC_LISTINSTRUMENTS, LB_GETCARETINDEX, 0, 0);
if (currentInstrumentIndex >= SendDlgItemMessage(dlg, IDC_LISTINSTRUMENTS, LB_GETCOUNT , 0, 0)-1) break;
unsigned long addr1 = SendDlgItemMessage(dlg, IDC_LISTINSTRUMENTS, LB_GETITEMDATA, currentInstrumentIndex, 0);
unsigned long addr2 = SendDlgItemMessage(dlg, IDC_LISTINSTRUMENTS, LB_GETITEMDATA, currentInstrumentIndex+1, 0);
exchangeInstruments(addr1, addr2);
updateInstrumentListbox(dlg);
SendDlgItemMessage(dlg, IDC_LISTINSTRUMENTS, LB_SETCARETINDEX, currentInstrumentIndex+1, TRUE);
}
break;
case IDOK:
{
updateInstrumentListbox(dlg);
int index = searchInstrument(dlg, GetDlgItemHex(dlg, IDC_EDIT_ADDRESSSEARCH));
if (index != -1)
{
SendDlgItemMessage(dlg, IDC_LISTINSTRUMENTS, LB_SETCARETINDEX, index, TRUE);
SendMessage(dlg, WM_COMMAND, MAKEWPARAM(IDC_LISTINSTRUMENTS, LBN_DBLCLK), (LPARAM)GetDlgItem(dlg, IDC_LISTINSTRUMENTS));
}
else MessageBeep(MB_ICONEXCLAMATION);
}
break;
default: return FALSE;
}
break;
case WM_CLOSE: DestroyWindow(dlg);
return TRUE;
case WM_DESTROY: dlgInstrumentSelection = 0;
return TRUE;
}
return FALSE;
}
static BOOL CALLBACK DialogProcPref(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
static bool initialized = false;
switch (uMsg)
{
case WM_COMMAND:
switch (GET_WM_COMMAND_ID(wParam, LpARAM))
switch (GET_WM_COMMAND_ID(wParam, lParam))
{
case IDC_BUTTON_VIEWSPU:
if(soundViewCallbacks.doOpenSoundView) soundViewCallbacks.doOpenSoundView(hDLL);
break;
case IDC_BUTTON_INSTRUMENTSELECTION:
if (HIWORD(wParam)==BN_CLICKED)
{
if (dlgInstrumentSelection == 0)
{
dlgInstrumentSelection=CreateDialog(hDLL, MAKEINTRESOURCE(IDD_INSTRUMENTDLG), hwndDlg, (DLGPROC)dlgProcInstrumentSelection);
if (dlgInstrumentSelection==0) MessageBeep(MB_ICONEXCLAMATION);
ShowWindow(dlgInstrumentSelection, SW_SHOW);
}
else
{
HWND tmp=dlgInstrumentSelection; /* thread safety (PostMessage in addInstrument) */
dlgInstrumentSelection=0;
DestroyWindow(tmp);
}
}
break;
case IDC_COMBO_INTERPOLATION:
if (GET_WM_COMMAND_CMD(wParam, lParam) == CBN_SELCHANGE)
{

6
tools/vio2sf/src/xsfc/in_xsfcfg.h
View File

@ -11,6 +11,12 @@ void winamp_config_add_prefs(HWND hwndWinamp);
void winamp_config_remove_prefs(HWND hwndWinamp);
void winamp_config_dialog(HWND hwndWinamp, HWND hwndParent);
void addInstrument(unsigned long addr, int type);
BOOL isInstrumentMuted(unsigned long addr);
unsigned long getInstrumentVolume(unsigned long addr);
void openSoundView(void* callback);
#ifdef __cplusplus
}
#endif

37
tools/vio2sf/src/xsfc/xsfdrv.c
View File

@ -57,6 +57,34 @@ static void PASCAL XSFSetExtendParam(DWORD dwId, LPCWSTR lpPtr)
}
#endif
TYPE_EXTEND_PARAM_IMMEDIATE_ADDINSTRUMENT addInstrument=0;
TYPE_EXTEND_PARAM_IMMEDIATE_ISINSTRUMENTMUTED isInstrumentMuted=0;
TYPE_EXTEND_PARAM_IMMEDIATE_GETINSTRUMENTVOLUME getInstrumentVolume=0;
TYPE_EXTEND_PARAM_IMMEDIATE_OPENSOUNDVIEW openSoundView=0;
int SoundView_DlgOpen(HINSTANCE hAppIndst);
void SoundView_DlgClose();
void doOpenSoundView(void* hinst)
{
SoundView_DlgOpen(hinst);
}
void killSoundView(void* hinst)
{
SoundView_DlgClose();
}
typedef void (*TOpenSoundView)(void* hinst);
typedef struct CallbackSet
{
TOpenSoundView doOpenSoundView;
TOpenSoundView killSoundView;
};
struct CallbackSet soundViewCallbacks = { &doOpenSoundView, &killSoundView };
static void PASCAL XSFSetExtendParamImmediate(DWORD dwId, LPVOID lpPtr)
{
switch(dwId)
@ -64,6 +92,13 @@ static void PASCAL XSFSetExtendParamImmediate(DWORD dwId, LPVOID lpPtr)
case EXTEND_PARAM_IMMEDIATE_INTERPOLATION:
dwInterpolation = *(unsigned long*)lpPtr;
break;
case EXTEND_PARAM_IMMEDIATE_ADDINSTRUMENT: addInstrument = (TYPE_EXTEND_PARAM_IMMEDIATE_ADDINSTRUMENT) lpPtr; break;
case EXTEND_PARAM_IMMEDIATE_ISINSTRUMENTMUTED: isInstrumentMuted = (TYPE_EXTEND_PARAM_IMMEDIATE_ISINSTRUMENTMUTED) lpPtr; break;
case EXTEND_PARAM_IMMEDIATE_GETINSTRUMENTVOLUME: getInstrumentVolume = (TYPE_EXTEND_PARAM_IMMEDIATE_GETINSTRUMENTVOLUME) lpPtr; break;
case EXTEND_PARAM_IMMEDIATE_OPENSOUNDVIEW: openSoundView = (TYPE_EXTEND_PARAM_IMMEDIATE_OPENSOUNDVIEW) lpPtr;
openSoundView(&soundViewCallbacks);
break;
}
}
@ -108,5 +143,3 @@ BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
}
return TRUE;
}

10
tools/vio2sf/src/xsfc/xsfdrv.h
View File

@ -28,6 +28,16 @@ typedef struct
#define EXTEND_PARAM_IMMEDIATE_INTERPOLATION_LINEAR 1
#define EXTEND_PARAM_IMMEDIATE_INTERPOLATION_COSINE 2
#define EXTEND_PARAM_IMMEDIATE_ADDINSTRUMENT 1
#define EXTEND_PARAM_IMMEDIATE_ISINSTRUMENTMUTED 2
#define EXTEND_PARAM_IMMEDIATE_GETINSTRUMENTVOLUME 3
#define EXTEND_PARAM_IMMEDIATE_OPENSOUNDVIEW 4
typedef void (*TYPE_EXTEND_PARAM_IMMEDIATE_ADDINSTRUMENT)(unsigned long addr, int type);
typedef BOOL (*TYPE_EXTEND_PARAM_IMMEDIATE_ISINSTRUMENTMUTED)(unsigned long addr);
typedef unsigned long (*TYPE_EXTEND_PARAM_IMMEDIATE_GETINSTRUMENTVOLUME)(unsigned long addr);
typedef unsigned long (*TYPE_EXTEND_PARAM_IMMEDIATE_OPENSOUNDVIEW)(void* callback);
typedef IXSFDRV * (PASCAL * LPFNXSFDRVSETUP)(LPFNGETLIB_XSFDRV lpfn, void *lpWork);
/* IXSFDRV * PASCAL XSFDRVSetup(LPFNGETLIB_XSFDRV lpfn, void *lpWork); */

313
tools/vio2sf/src/xsfc/xsfui.rc
View File

@ -1,4 +1,4 @@
//Microsoft Developer Studio generated resource script.
// Microsoft Visual C++ generated resource script.
//
#include "xsfui.rh"
@ -27,18 +27,18 @@ LANGUAGE LANG_JAPANESE, SUBLANG_DEFAULT
// TEXTINCLUDE
//
1 TEXTINCLUDE MOVEABLE PURE
1 TEXTINCLUDE
BEGIN
"xsfui.rh\0"
END
2 TEXTINCLUDE MOVEABLE PURE
2 TEXTINCLUDE
BEGIN
"#include ""winresx.h""\r\n"
"\0"
END
3 TEXTINCLUDE MOVEABLE PURE
3 TEXTINCLUDE
BEGIN
"\r\n"
"\0"
@ -64,13 +64,12 @@ LANGUAGE LANG_NEUTRAL, SUBLANG_NEUTRAL
// Dialog
//
1 DIALOG DISCARDABLE 0, 0, 172, 202
STYLE WS_CHILD
FONT 9, "MS UI Gothic"
1 DIALOGEX 0, 0, 172, 202
STYLE DS_SETFONT | WS_CHILD
FONT 9, "MS UI Gothic", 0, 0, 0x0
BEGIN
GROUPBOX "General",IDC_STATIC,5,5,160,90
CONTROL "Play infinitely",512,"Button",BS_AUTOCHECKBOX |
WS_TABSTOP,10,15,60,10
CONTROL "Play infinitely",512,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,10,15,60,10
EDITTEXT 513,100,30,25,12,ES_RIGHT | ES_AUTOHSCROLL
LTEXT "Default play length (m:s)",IDC_STATIC,10,30,85,9
EDITTEXT 514,100,45,25,12,ES_RIGHT | ES_AUTOHSCROLL
@ -86,13 +85,13 @@ BEGIN
EDITTEXT 520,65,125,25,12,ES_RIGHT | ES_AUTOHSCROLL | WS_DISABLED
LTEXT "",521,10,140,50,9
EDITTEXT 522,65,140,25,12,ES_RIGHT | ES_AUTOHSCROLL | WS_DISABLED
LISTBOX 518,100,105,60,45,LBS_MULTIPLESEL | LBS_NOINTEGRALHEIGHT |
WS_VSCROLL | WS_TABSTOP
LISTBOX 518,100,105,60,45,LBS_MULTIPLESEL | LBS_NOINTEGRALHEIGHT | WS_VSCROLL | WS_TABSTOP
LTEXT "Mute",IDC_STATIC,80,110,20,9
DEFPUSHBUTTON "OK",IDOK,84,181,35,15,NOT WS_VISIBLE
PUSHBUTTON "Cancel",IDCANCEL,129,181,35,15,NOT WS_VISIBLE
COMBOBOX IDC_COMBO_INTERPOLATION,10,156,78,55,CBS_DROPDOWNLIST |
WS_VSCROLL | WS_TABSTOP
COMBOBOX IDC_COMBO_INTERPOLATION,10,156,78,55,CBS_DROPDOWNLIST | WS_VSCROLL | WS_TABSTOP
PUSHBUTTON "Instruments",IDC_BUTTON_INSTRUMENTSELECTION,70,12,50,14
PUSHBUTTON "View SPU",IDC_BUTTON_VIEWSPU,125,12,37,14
END
@ -102,7 +101,7 @@ END
//
#ifdef APSTUDIO_INVOKED
GUIDELINES DESIGNINFO MOVEABLE PURE
GUIDELINES DESIGNINFO
BEGIN
1, DIALOG
BEGIN
@ -115,6 +114,292 @@ END
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
// English (U.S.) resources
#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU)
#ifdef _WIN32
LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
#pragma code_page(1252)
#endif //_WIN32
/////////////////////////////////////////////////////////////////////////////
//
// Dialog
//
IDD_INSTRUMENTDLG DIALOGEX 0, 0, 352, 215
STYLE DS_SETFONT | DS_MODALFRAME | DS_FIXEDSYS | WS_POPUP | WS_CAPTION | WS_SYSMENU
EXSTYLE WS_EX_TOOLWINDOW
CAPTION "Instrument Selection"
FONT 8, "MS Shell Dlg", 400, 0, 0x1
BEGIN
LISTBOX IDC_LISTINSTRUMENTS,144,24,204,186,LBS_MULTIPLESEL | LBS_NOINTEGRALHEIGHT | WS_VSCROLL | WS_TABSTOP
PUSHBUTTON "Clear List",IDC_BUTTONCLEARLIST,6,6,72,14
LTEXT "0 instruments displayed",IDC_STATICNBINSTRUMENTSDISPLAYED,6,196,84,8
PUSHBUTTON "All",IDC_BUTTONSELECTALL,300,6,24,14
PUSHBUTTON "None",IDC_BUTTONSELECTNONE,324,6,24,14
LTEXT "Volume of selected instruments (0% - 100%):",IDC_STATICHELP,6,138,90,18
PUSHBUTTON "Up",IDC_BUTTONMOVEINSTRUMENTUP,114,78,24,14
PUSHBUTTON "Down",IDC_BUTTONMOVEINSTRUMENTDOWN,114,96,24,14
LTEXT "Search Address:",IDC_STATICNBINSTRUMENTSDISPLAYED3,145,8,56,12
EDITTEXT IDC_EDIT_ADDRESSSEARCH,200,6,58,12,ES_AUTOHSCROLL | ES_WANTRETURN
CONTROL "",IDC_SLIDER_VOLUME,"msctls_trackbar32",TBS_AUTOTICKS | TBS_BOTH | TBS_TOOLTIPS | WS_TABSTOP,0,156,138,30
LTEXT "Select to mute (or reduce volume).\n\nDouble click to change instrument name.\n\nInstruments are added to the list as they are played.",IDC_STATICHELP2,6,36,90,72
END
IDD_DIALOGENTERINSTRUMENTNAME DIALOGEX 0, 0, 280, 87
STYLE DS_SETFONT | DS_MODALFRAME | DS_FIXEDSYS | WS_POPUP | WS_CAPTION | WS_SYSMENU
CAPTION "Enter Instrument Name"
FONT 8, "MS Shell Dlg", 400, 0, 0x1
BEGIN
DEFPUSHBUTTON "OK",IDOK,84,60,50,14
PUSHBUTTON "Cancel",IDCANCEL,144,60,50,14
EDITTEXT IDC_EDIT_ENTERINSTRUMENTNAME,12,12,252,14,ES_AUTOHSCROLL
EDITTEXT IDC_EDIT_ENTERINSTRUMENTNAMEADDRESS,12,36,252,14,ES_CENTER | ES_AUTOHSCROLL | ES_READONLY
END
IDD_DIALOG_MIXERINSTRUMENT DIALOGEX 0, 0, 452, 17
STYLE DS_SETFONT | DS_FIXEDSYS | DS_CONTROL | WS_CHILD
EXSTYLE WS_EX_TRANSPARENT
FONT 8, "MS Shell Dlg", 400, 0, 0x1
BEGIN
CONTROL "",IDC_SLIDER_INSTRUMENTVOLUME,"msctls_trackbar32",TBS_BOTH | TBS_NOTICKS | TBS_TOOLTIPS | WS_TABSTOP,185,0,192,17
CONTROL "Mute",IDC_CHECK_INSTRUMENTMUTE,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,379,2,32,11
CONTROL "",IDC_RADIO1,"Button",BS_AUTORADIOBUTTON,0,3,12,10
LTEXT "Instrument Name",IDC_STATIC_INSTRUMENTNAME,12,4,131,8,SS_ENDELLIPSIS
CONTROL "Low Level",IDC_CHECK_INSTRUMENTLOWLEVEL,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,131,3,47,11
END
IDD_SOUND_VIEW DIALOGEX 0, 0, 550, 268
STYLE DS_SETFONT | DS_MODALFRAME | DS_3DLOOK | DS_CENTER | WS_POPUP | WS_VISIBLE | WS_CAPTION | WS_SYSMENU
CAPTION "Sound View"
FONT 8, "Ms Shell Dlg 2", 0, 0, 0x0
BEGIN
CTEXT "Volume",IDC_STATIC,30,22,100,11,0,WS_EX_STATICEDGE
CTEXT "Pan",IDC_STATIC,30,34,100,11,0,WS_EX_STATICEDGE
CTEXT "Hold",IDC_STATIC,131,22,22,11,0,WS_EX_STATICEDGE
CTEXT "Busy",IDC_STATIC,131,34,22,11,0,WS_EX_STATICEDGE
CTEXT "Repeat Mode",IDC_STATIC,154,22,72,11,0,WS_EX_STATICEDGE
CTEXT "Format",IDC_STATIC,154,34,72,11,0,WS_EX_STATICEDGE
CTEXT "Source Addr",IDC_STATIC,227,22,60,11,0,WS_EX_STATICEDGE
CTEXT "Loop Start",IDC_STATIC,227,34,60,11,0,WS_EX_STATICEDGE
CTEXT "Timer Value",IDC_STATIC,288,22,88,11,0,WS_EX_STATICEDGE
CTEXT "Sound Pos / Len",IDC_STATIC,288,34,88,11,0,WS_EX_STATICEDGE
RTEXT "#00",IDC_SOUND0ID,4,50,23,10
CONTROL "",IDC_SOUND0VOLBAR,"msctls_progress32",PBS_SMOOTH,30,49,68,11
CTEXT "",IDC_SOUND0VOL,100,49,30,11,0,WS_EX_STATICEDGE
CONTROL "",IDC_SOUND0PANBAR,"msctls_progress32",PBS_SMOOTH,30,62,68,10
CTEXT "",IDC_SOUND0PAN,100,61,30,11,0,WS_EX_STATICEDGE
CTEXT "",IDC_SOUND0HOLD,131,49,22,11,0,WS_EX_STATICEDGE
CTEXT "",IDC_SOUND0BUSY,131,61,22,11,0,WS_EX_STATICEDGE
CTEXT "",IDC_SOUND0REPEATMODE,154,49,72,11,0,WS_EX_STATICEDGE
CTEXT "",IDC_SOUND0FORMAT,154,61,72,11,0,WS_EX_STATICEDGE
CTEXT "",IDC_SOUND0SAD,227,49,60,11,0,WS_EX_STATICEDGE
CTEXT "",IDC_SOUND0PNT,227,61,60,11,0,WS_EX_STATICEDGE
CTEXT "",IDC_SOUND0TMR,288,49,88,11,0,WS_EX_STATICEDGE
CTEXT "",IDC_SOUND0POSLEN,288,61,88,11,0,WS_EX_STATICEDGE
RTEXT "#01",IDC_SOUND1ID,4,75,23,10
CONTROL "",IDC_SOUND1VOLBAR,"msctls_progress32",PBS_SMOOTH,30,74,68,11
CTEXT "",IDC_SOUND1VOL,100,74,30,11,0,WS_EX_STATICEDGE
CONTROL "",IDC_SOUND1PANBAR,"msctls_progress32",PBS_SMOOTH,30,87,68,11
CTEXT "",IDC_SOUND1PAN,100,87,30,11,0,WS_EX_STATICEDGE
CTEXT "",IDC_SOUND1HOLD,131,74,22,11,0,WS_EX_STATICEDGE
CTEXT "",IDC_SOUND1BUSY,131,87,22,11,0,WS_EX_STATICEDGE
CTEXT "",IDC_SOUND1REPEATMODE,154,74,72,11,0,WS_EX_STATICEDGE
CTEXT "",IDC_SOUND1FORMAT,154,87,72,11,0,WS_EX_STATICEDGE
CTEXT "",IDC_SOUND1SAD,227,74,60,11,0,WS_EX_STATICEDGE
CTEXT "",IDC_SOUND1PNT,227,87,60,11,0,WS_EX_STATICEDGE
CTEXT "",IDC_SOUND1TMR,288,74,88,11,0,WS_EX_STATICEDGE
CTEXT "",IDC_SOUND1POSLEN,288,87,88,11,0,WS_EX_STATICEDGE
RTEXT "#02",IDC_SOUND2ID,4,101,23,10
CONTROL "",IDC_SOUND2VOLBAR,"msctls_progress32",PBS_SMOOTH,30,100,68,11
CTEXT "",IDC_SOUND2VOL,100,100,30,11,0,WS_EX_STATICEDGE
CONTROL "",IDC_SOUND2PANBAR,"msctls_progress32",PBS_SMOOTH,30,113,68,11
CTEXT "",IDC_SOUND2PAN,100,113,30,11,0,WS_EX_STATICEDGE
CTEXT "",IDC_SOUND2HOLD,131,100,22,11,0,WS_EX_STATICEDGE
CTEXT "",IDC_SOUND2BUSY,131,113,22,11,0,WS_EX_STATICEDGE
CTEXT "",IDC_SOUND2REPEATMODE,154,100,72,11,0,WS_EX_STATICEDGE
CTEXT "",IDC_SOUND2FORMAT,154,113,72,11,0,WS_EX_STATICEDGE
CTEXT "",IDC_SOUND2SAD,227,100,60,11,0,WS_EX_STATICEDGE
CTEXT "",IDC_SOUND2PNT,227,113,60,11,0,WS_EX_STATICEDGE
CTEXT "",IDC_SOUND2TMR,288,100,88,11,0,WS_EX_STATICEDGE
CTEXT "",IDC_SOUND2POSLEN,288,113,88,11,0,WS_EX_STATICEDGE
RTEXT "#03",IDC_SOUND3ID,4,127,23,10
CONTROL "",IDC_SOUND3VOLBAR,"msctls_progress32",PBS_SMOOTH,30,126,68,11
CTEXT "",IDC_SOUND3VOL,100,126,30,11,0,WS_EX_STATICEDGE
CONTROL "",IDC_SOUND3PANBAR,"msctls_progress32",PBS_SMOOTH,30,139,68,11
CTEXT "",IDC_SOUND3PAN,100,139,30,11,0,WS_EX_STATICEDGE
CTEXT "",IDC_SOUND3HOLD,131,126,22,11,0,WS_EX_STATICEDGE
CTEXT "",IDC_SOUND3BUSY,131,139,22,11,0,WS_EX_STATICEDGE
CTEXT "",IDC_SOUND3REPEATMODE,154,126,72,11,0,WS_EX_STATICEDGE
CTEXT "",IDC_SOUND3FORMAT,154,139,72,11,0,WS_EX_STATICEDGE
CTEXT "",IDC_SOUND3SAD,227,126,60,11,0,WS_EX_STATICEDGE
CTEXT "",IDC_SOUND3PNT,227,139,60,11,0,WS_EX_STATICEDGE
CTEXT "",IDC_SOUND3TMR,288,126,88,11,0,WS_EX_STATICEDGE
CTEXT "",IDC_SOUND3POSLEN,288,139,88,11,0,WS_EX_STATICEDGE
RTEXT "#04",IDC_SOUND4ID,4,153,23,10
CONTROL "",IDC_SOUND4VOLBAR,"msctls_progress32",PBS_SMOOTH,30,152,68,11
CTEXT "",IDC_SOUND4VOL,100,152,30,11,0,WS_EX_STATICEDGE
CONTROL "",IDC_SOUND4PANBAR,"msctls_progress32",PBS_SMOOTH,30,165,68,11
CTEXT "",IDC_SOUND4PAN,100,165,30,11,0,WS_EX_STATICEDGE
CTEXT "",IDC_SOUND4HOLD,131,152,22,11,0,WS_EX_STATICEDGE
CTEXT "",IDC_SOUND4BUSY,131,165,22,11,0,WS_EX_STATICEDGE
CTEXT "",IDC_SOUND4REPEATMODE,154,152,72,11,0,WS_EX_STATICEDGE
CTEXT "",IDC_SOUND4FORMAT,154,165,72,11,0,WS_EX_STATICEDGE
CTEXT "",IDC_SOUND4SAD,227,152,60,11,0,WS_EX_STATICEDGE
CTEXT "",IDC_SOUND4PNT,227,165,60,11,0,WS_EX_STATICEDGE
CTEXT "",IDC_SOUND4TMR,288,152,88,11,0,WS_EX_STATICEDGE
CTEXT "",IDC_SOUND4POSLEN,288,165,88,11,0,WS_EX_STATICEDGE
RTEXT "#05",IDC_SOUND5ID,4,179,23,10
CONTROL "",IDC_SOUND5VOLBAR,"msctls_progress32",PBS_SMOOTH,30,178,68,11
CTEXT "",IDC_SOUND5VOL,100,178,30,11,0,WS_EX_STATICEDGE
CONTROL "",IDC_SOUND5PANBAR,"msctls_progress32",PBS_SMOOTH,30,191,68,11
CTEXT "",IDC_SOUND5PAN,100,191,30,11,0,WS_EX_STATICEDGE
CTEXT "",IDC_SOUND5HOLD,131,178,22,11,0,WS_EX_STATICEDGE
CTEXT "",IDC_SOUND5BUSY,131,191,22,11,0,WS_EX_STATICEDGE
CTEXT "",IDC_SOUND5REPEATMODE,154,178,72,11,0,WS_EX_STATICEDGE
CTEXT "",IDC_SOUND5FORMAT,154,191,72,11,0,WS_EX_STATICEDGE
CTEXT "",IDC_SOUND5SAD,227,178,60,11,0,WS_EX_STATICEDGE
CTEXT "",IDC_SOUND5PNT,227,191,60,11,0,WS_EX_STATICEDGE
CTEXT "",IDC_SOUND5TMR,288,178,88,11,0,WS_EX_STATICEDGE
CTEXT "",IDC_SOUND5POSLEN,288,191,88,11,0,WS_EX_STATICEDGE
RTEXT "#06",IDC_SOUND6ID,4,205,23,10
CONTROL "",IDC_SOUND6VOLBAR,"msctls_progress32",PBS_SMOOTH,30,204,68,11
CTEXT "",IDC_SOUND6VOL,100,204,30,11,0,WS_EX_STATICEDGE
CONTROL "",IDC_SOUND6PANBAR,"msctls_progress32",PBS_SMOOTH,30,217,68,11
CTEXT "",IDC_SOUND6PAN,100,217,30,11,0,WS_EX_STATICEDGE
CTEXT "",IDC_SOUND6HOLD,131,204,22,11,0,WS_EX_STATICEDGE
CTEXT "",IDC_SOUND6BUSY,131,217,22,11,0,WS_EX_STATICEDGE
CTEXT "",IDC_SOUND6REPEATMODE,154,204,72,11,0,WS_EX_STATICEDGE
CTEXT "",IDC_SOUND6FORMAT,154,217,72,11,0,WS_EX_STATICEDGE
CTEXT "",IDC_SOUND6SAD,227,204,60,11,0,WS_EX_STATICEDGE
CTEXT "",IDC_SOUND6PNT,227,217,60,11,0,WS_EX_STATICEDGE
CTEXT "",IDC_SOUND6TMR,288,204,88,11,0,WS_EX_STATICEDGE
CTEXT "",IDC_SOUND6POSLEN,288,217,88,11,0,WS_EX_STATICEDGE
RTEXT "#07",IDC_SOUND7ID,4,231,23,10
CONTROL "",IDC_SOUND7VOLBAR,"msctls_progress32",PBS_SMOOTH,30,230,68,11
CTEXT "",IDC_SOUND7VOL,100,230,30,11,0,WS_EX_STATICEDGE
CONTROL "",IDC_SOUND7PANBAR,"msctls_progress32",PBS_SMOOTH,30,243,68,11
CTEXT "",IDC_SOUND7PAN,100,243,30,11,0,WS_EX_STATICEDGE
CTEXT "",IDC_SOUND7HOLD,131,230,22,11,0,WS_EX_STATICEDGE
CTEXT "",IDC_SOUND7BUSY,131,243,22,11,0,WS_EX_STATICEDGE
CTEXT "",IDC_SOUND7REPEATMODE,154,230,72,11,0,WS_EX_STATICEDGE
CTEXT "",IDC_SOUND7FORMAT,154,243,72,11,0,WS_EX_STATICEDGE
CTEXT "",IDC_SOUND7SAD,227,230,60,11,0,WS_EX_STATICEDGE
CTEXT "",IDC_SOUND7PNT,227,243,60,11,0,WS_EX_STATICEDGE
CTEXT "",IDC_SOUND7TMR,288,230,88,11,0,WS_EX_STATICEDGE
CTEXT "",IDC_SOUND7POSLEN,288,243,88,11,0,WS_EX_STATICEDGE
PUSHBUTTON "V",IDC_SOUNDVIEW_CHANSWITCH,16,33,12,12
CONTROL "Vol.Mode",IDC_BUTTON_VOLMODE,"Button",BS_AUTOCHECKBOX | BS_PUSHLIKE | WS_TABSTOP,13,7,45,10
CONTROL "Check1",IDC_SOUND0MUTE,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,18,62,10,10
CONTROL "Check1",IDC_SOUND1MUTE,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,18,87,10,10
CONTROL "Check1",IDC_SOUND2MUTE,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,18,114,10,10
CONTROL "Check1",IDC_SOUND3MUTE,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,18,140,10,10
CONTROL "Check1",IDC_SOUND4MUTE,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,18,164,10,10
CONTROL "Check1",IDC_SOUND5MUTE,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,18,192,10,10
CONTROL "Check1",IDC_SOUND6MUTE,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,18,217,10,10
CONTROL "Check1",IDC_SOUND7MUTE,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,18,243,10,10
GROUPBOX "Capture 0",IDC_STATIC,379,90,157,80
LTEXT "508 ctrl",IDC_STATIC,403,103,25,8
CHECKBOX "b0 AddCh1toCh0",IDC_CAP0_ADD,433,103,68,10
CHECKBOX "b1 Src",IDC_CAP0_SRC,383,116,36,10
CHECKBOX "b2 One-Shot",IDC_CAP0_ONESHOT,450,116,54,10
CHECKBOX "b3 Typ",IDC_CAP0_TYPE,383,127,36,10
CHECKBOX "b7 Active",IDC_CAP0_ACTIVE,450,127,49,10
LTEXT "",IDC_CAP0_DAD,383,141,37,11,0,WS_EX_STATICEDGE
LTEXT "",IDC_CAP0_CTRL,383,103,16,11,0,WS_EX_STATICEDGE
LTEXT "",IDC_CAP0_SRCTEXT,419,116,25,11,0,WS_EX_STATICEDGE
LTEXT "",IDC_CAP0_TYPETEXT,419,127,25,11,0,WS_EX_STATICEDGE
LTEXT "510 DAD",IDC_STATIC,423,143,29,8
LTEXT "514 LEN",IDC_STATIC,492,143,27,8
LTEXT "",IDC_CAP0_LEN,453,141,37,11,0,WS_EX_STATICEDGE
LTEXT "",IDC_CAP0_CURDAD,384,156,37,11,0,WS_EX_STATICEDGE
LTEXT "DAD CUR",IDC_STATIC,423,156,32,8
CHECKBOX "Running",IDC_CAP0_RUNNING,457,156,49,10
GROUPBOX "Capture 1",IDC_STATIC,379,174,157,80
LTEXT "509 ctrl",IDC_STATIC,403,187,25,8
CHECKBOX "b0 AddCh3toCh2",IDC_CAP1_ADD,433,187,68,10
CHECKBOX "b1 Src",IDC_CAP1_SRC,383,200,36,10
CHECKBOX "b2 One-Shot",IDC_CAP1_ONESHOT,449,200,54,10
CHECKBOX "b3 Typ",IDC_CAP1_TYPE,383,211,36,10
CHECKBOX "b7 Active",IDC_CAP1_ACTIVE,449,211,49,10
LTEXT "",IDC_CAP1_DAD,383,226,37,11,0,WS_EX_STATICEDGE
LTEXT "",IDC_CAP1_CTRL,383,187,16,11,0,WS_EX_STATICEDGE
LTEXT "",IDC_CAP1_SRCTEXT,419,200,25,11,0,WS_EX_STATICEDGE
LTEXT "",IDC_CAP1_TYPETEXT,419,211,25,11,0,WS_EX_STATICEDGE
LTEXT "518 DAD",IDC_STATIC,423,227,29,8
LTEXT "51C LEN",IDC_STATIC,492,227,28,8
LTEXT "",IDC_CAP1_LEN,453,226,37,11,0,WS_EX_STATICEDGE
LTEXT "",IDC_CAP1_CURDAD,383,240,37,11,0,WS_EX_STATICEDGE
LTEXT "DAD CUR",IDC_STATIC,423,240,32,8
CHECKBOX "Running",IDC_CAP1_RUNNING,457,240,49,10
GROUPBOX "Sound Control",IDC_STATIC,378,18,158,69
LTEXT "",IDC_SNDCTRL_CTRL,385,29,26,11,0,WS_EX_STATICEDGE
LTEXT "500 Ctrl",IDC_STATIC,416,31,26,8
LTEXT "",IDC_SNDCTRL_VOL,385,42,26,11,0,WS_EX_STATICEDGE
LTEXT "b0-6 Vol",IDC_STATIC,415,44,27,8
LTEXT "",IDC_SNDCTRL_BIAS,456,30,26,11,0,WS_EX_STATICEDGE
LTEXT "504 Bias",IDC_STATIC,485,32,28,8
CHECKBOX "b15 Enable",IDC_SNDCTRL_ENABLE,473,44,49,10
LTEXT "",IDC_SNDCTRL_LEFTOUT,385,57,12,11,0,WS_EX_STATICEDGE
LTEXT "b8-9 L-Out",IDC_STATIC,400,59,36,8
LTEXT "",IDC_SNDCTRL_LEFTOUTTEXT,445,57,25,11,0,WS_EX_STATICEDGE
CHECKBOX "b12 ch1 nomix",IDC_SNDCTRL_CH1NOMIX,473,57,59,10
LTEXT "",IDC_SNDCTRL_RIGHTOUT,385,70,12,11,0,WS_EX_STATICEDGE
LTEXT "b10-11 R-Out",IDC_STATIC,400,72,45,8
LTEXT "",IDC_SNDCTRL_RIGHTOUTTEXT,445,71,25,11,0,WS_EX_STATICEDGE
CHECKBOX "b13 ch3 nomix",IDC_SNDCTRL_CH3NOMIX,473,71,59,10
CONTROL "Capture muted channels",IDC_SOUND_CAPTURE_MUTED,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,435,5,94,10
PUSHBUTTON "Analyze Cap",IDC_SOUND_ANALYZE_CAP,379,3,50,14
PUSHBUTTON "Unmute All",IDC_SOUND_UNMUTE_ALL,325,3,50,14
END
/////////////////////////////////////////////////////////////////////////////
//
// DESIGNINFO
//
#ifdef APSTUDIO_INVOKED
GUIDELINES DESIGNINFO
BEGIN
IDD_INSTRUMENTDLG, DIALOG
BEGIN
LEFTMARGIN, 7
RIGHTMARGIN, 345
TOPMARGIN, 7
BOTTOMMARGIN, 208
END
IDD_DIALOGENTERINSTRUMENTNAME, DIALOG
BEGIN
LEFTMARGIN, 7
RIGHTMARGIN, 273
TOPMARGIN, 7
BOTTOMMARGIN, 80
END
IDD_DIALOG_MIXERINSTRUMENT, DIALOG
BEGIN
LEFTMARGIN, 7
RIGHTMARGIN, 445
TOPMARGIN, 7
BOTTOMMARGIN, 10
END
IDD_SOUND_VIEW, DIALOG
BEGIN
LEFTMARGIN, 7
TOPMARGIN, 7
END
END
#endif // APSTUDIO_INVOKED
#endif // English (U.S.) resources
/////////////////////////////////////////////////////////////////////////////
#ifndef APSTUDIO_INVOKED
/////////////////////////////////////////////////////////////////////////////

187
tools/vio2sf/src/xsfc/xsfui.rh
View File

@ -2,15 +2,198 @@
// Microsoft Visual C++ generated include file.
// Used by xsfui.rc
//
#define IDD_INSTRUMENTDLG 101
#define IDD_DIALOGENTERINSTRUMENTNAME 102
#define IDD_DIALOG_MIXERINSTRUMENT 104
#define IDD_DIALOG1 105
#define IDD_SOUND_VIEW 105
#define IDC_COMBO_INTERPOLATION 1000
#define IDC_SOUNDVIEW_CHANSWITCH 1001
#define IDC_BUTTON_INSTRUMENTSELECTION 1001
#define IDC_LISTINSTRUMENTS 1002
#define IDC_BUTTON_SPU 1002
#define IDC_BUTTON_VIEWSPU 1002
#define IDC_BUTTONDISPLAYLIST 1003
#define IDC_BUTTON_VOLMODE 1004
#define IDC_BUTTONCLEARLIST 1004
#define IDC_STATICNBINSTRUMENTSDISPLAYED 1005
#define IDC_BUTTONSELECTALL 1006
#define IDC_EDIT_ENTERINSTRUMENTNAME 1006
#define IDC_BUTTONSELECTNONE 1007
#define IDC_EDIT_ENTERINSTRUMENTNAMEADDRESS 1007
#define IDC_STATICNBINSTRUMENTSDISPLAYED2 1008
#define IDC_STATICHELP 1008
#define IDC_BUTTONMOVEINSTRUMENTUP 1009
#define IDC_STATICNBINSTRUMENTSDISPLAYED3 1010
#define IDC_BUTTONMOVEINSTRUMENTDOWN 1011
#define IDC_STATICHELP2 1012
#define IDC_EDIT_ADDRESSSEARCH 1013
#define IDC_SLIDER_VOLUME 1016
#define IDC_SLIDER_INSTRUMENTVOLUME 1020
#define IDC_CHECK_INSTRUMENTMUTE 1021
#define IDC_CHECK_INSTRUMENTMUTE2 1022
#define IDC_CHECK_INSTRUMENTLOWLEVEL 1022
#define IDC_CAP0_ADD 1023
#define IDC_CAP0_CURDAD 1024
#define IDC_CAP1_ADD 1025
#define IDC_SPU_ADVANCED 1025
#define IDC_CAP1_CURDAD 1026
#define IDC_RADIO1 1027
#define IDC_SNDCTRL_ENABLE 1028
#define IDC_STATIC_INSTRUMENTNAME 1028
#define IDC_SNDCTRL_CH1NOMIX 1029
#define IDC_SNDCTRL_CH3NOMIX 1030
#define IDC_SOUND_CAPTURE_MUTED 1031
#define IDC_SOUND_ANALYZE_CAP 1032
#define IDC_SOUND_UNMUTE_ALL 1033
#define IDC_CAP0_SRC 1075
#define IDC_CAP0_ONESHOT 1076
#define IDC_CAP0_TYPE 1077
#define IDC_CAP0_ACTIVE 1078
#define IDC_CAP0_RUNNING 1079
#define IDC_CAP1_SRC 1080
#define IDC_CAP1_ONESHOT 1081
#define IDC_CAP1_TYPE 1082
#define IDC_CAP1_ACTIVE 1083
#define IDC_CAP1_RUNNING 1084
#define IDC_SOUND0ID 21350
#define IDC_SOUND1ID 21351
#define IDC_SOUND2ID 21352
#define IDC_SOUND3ID 21353
#define IDC_SOUND4ID 21354
#define IDC_SOUND5ID 21355
#define IDC_SOUND6ID 21356
#define IDC_SOUND7ID 21357
#define IDC_SOUND0VOL 21358
#define IDC_SOUND1VOL 21359
#define IDC_SOUND2VOL 21360
#define IDC_SOUND3VOL 21361
#define IDC_SOUND4VOL 21362
#define IDC_SOUND5VOL 21363
#define IDC_SOUND6VOL 21364
#define IDC_SOUND7VOL 21365
#define IDC_SOUND0VOLBAR 21366
#define IDC_SOUND1VOLBAR 21367
#define IDC_SOUND2VOLBAR 21368
#define IDC_SOUND3VOLBAR 21369
#define IDC_SOUND4VOLBAR 21370
#define IDC_SOUND5VOLBAR 21371
#define IDC_SOUND6VOLBAR 21372
#define IDC_SOUND7VOLBAR 21373
#define IDC_SOUND0PAN 21374
#define IDC_SOUND1PAN 21375
#define IDC_SOUND2PAN 21376
#define IDC_SOUND3PAN 21377
#define IDC_SOUND4PAN 21378
#define IDC_SOUND5PAN 21379
#define IDC_SOUND6PAN 21380
#define IDC_SOUND7PAN 21381
#define IDC_SOUND0PANBAR 21382
#define IDC_SOUND1PANBAR 21383
#define IDC_SOUND2PANBAR 21384
#define IDC_SOUND3PANBAR 21385
#define IDC_SOUND4PANBAR 21386
#define IDC_SOUND5PANBAR 21387
#define IDC_SOUND6PANBAR 21388
#define IDC_SOUND7PANBAR 21389
#define IDC_SOUND0HOLD 21390
#define IDC_SOUND1HOLD 21391
#define IDC_SOUND2HOLD 21392
#define IDC_SOUND3HOLD 21393
#define IDC_SOUND4HOLD 21394
#define IDC_SOUND5HOLD 21395
#define IDC_SOUND6HOLD 21396
#define IDC_SOUND7HOLD 21397
#define IDC_SOUND0BUSY 21398
#define IDC_SOUND1BUSY 21399
#define IDC_SOUND2BUSY 21400
#define IDC_SOUND3BUSY 21401
#define IDC_SOUND4BUSY 21402
#define IDC_SOUND5BUSY 21403
#define IDC_SOUND6BUSY 21404
#define IDC_SOUND7BUSY 21405
#define IDC_SOUND0REPEATMODE 21406
#define IDC_SOUND1REPEATMODE 21407
#define IDC_SOUND2REPEATMODE 21408
#define IDC_SOUND3REPEATMODE 21409
#define IDC_SOUND4REPEATMODE 21410
#define IDC_SOUND5REPEATMODE 21411
#define IDC_SOUND6REPEATMODE 21412
#define IDC_SOUND7REPEATMODE 21413
#define IDC_SOUND0FORMAT 21414
#define IDC_SOUND1FORMAT 21415
#define IDC_SOUND2FORMAT 21416
#define IDC_SOUND3FORMAT 21417
#define IDC_SOUND4FORMAT 21418
#define IDC_SOUND5FORMAT 21419
#define IDC_SOUND6FORMAT 21420
#define IDC_SOUND7FORMAT 21421
#define IDC_SOUND0SAD 21422
#define IDC_SOUND1SAD 21423
#define IDC_SOUND2SAD 21424
#define IDC_SOUND3SAD 21425
#define IDC_SOUND4SAD 21426
#define IDC_SOUND5SAD 21427
#define IDC_SOUND6SAD 21428
#define IDC_SOUND7SAD 21429
#define IDC_SOUND0PNT 21430
#define IDC_SOUND1PNT 21431
#define IDC_SOUND2PNT 21432
#define IDC_SOUND3PNT 21433
#define IDC_SOUND4PNT 21434
#define IDC_SOUND5PNT 21435
#define IDC_SOUND6PNT 21436
#define IDC_SOUND7PNT 21437
#define IDC_SOUND0TMR 21438
#define IDC_SOUND1TMR 21439
#define IDC_SOUND2TMR 21440
#define IDC_SOUND3TMR 21441
#define IDC_SOUND4TMR 21442
#define IDC_SOUND5TMR 21443
#define IDC_SOUND6TMR 21444
#define IDC_SOUND7TMR 21445
#define IDC_SOUND0POSLEN 21446
#define IDC_SOUND1POSLEN 21447
#define IDC_SOUND2POSLEN 21448
#define IDC_SOUND3POSLEN 21449
#define IDC_SOUND4POSLEN 21450
#define IDC_SOUND5POSLEN 21451
#define IDC_SOUND6POSLEN 21452
#define IDC_SOUND7POSLEN 21453
#define IDC_CAP0_DAD 21454
#define IDC_CAP0_CTRL 21455
#define IDC_CAP0_SRCTEXT 21456
#define IDC_CAP0_TYPETEXT 21457
#define IDC_CAP0_LEN 21458
#define IDC_SOUND0POSLEN7 21459
#define IDC_CAP1_DAD 21459
#define IDC_CAP1_CTRL 21460
#define IDC_CAP1_SRCTEXT 21461
#define IDC_CAP1_TYPETEXT 21462
#define IDC_CAP1_LEN 21463
#define IDC_SNDCTRL_CTRL 21464
#define IDC_SNDCTRL_VOL 21465
#define IDC_SNDCTRL_BIAS 21466
#define IDC_SNDCTRL_LEFTOUT 21467
#define IDC_SNDCTRL_LEFTOUTTEXT 21468
#define IDC_SNDCTRL_RIGHTOUT 21469
#define IDC_SNDCTRL_RIGHTOUTTEXT 21470
#define IDC_SOUND0MUTE 22001
#define IDC_SOUND1MUTE 22002
#define IDC_SOUND2MUTE 22003
#define IDC_SOUND3MUTE 22004
#define IDC_SOUND4MUTE 22005
#define IDC_SOUND5MUTE 22006
#define IDC_SOUND6MUTE 22007
#define IDC_SOUND7MUTE 22008
// Next default values for new objects
//
#ifdef APSTUDIO_INVOKED
#ifndef APSTUDIO_READONLY_SYMBOLS
#define _APS_NEXT_RESOURCE_VALUE 101
#define _APS_NEXT_RESOURCE_VALUE 106
#define _APS_NEXT_COMMAND_VALUE 40001
#define _APS_NEXT_CONTROL_VALUE 1001
#define _APS_NEXT_CONTROL_VALUE 1029
#define _APS_NEXT_SYMED_VALUE 101
#endif
#endif

3
tools/vio2sf/vio2sf.sln
View File

@ -111,4 +111,7 @@ Global
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
EndGlobalSection
GlobalSection(ExtensibilityGlobals) = postSolution
AMDCaProjectFile = D:\svn\desmume\trunk\tools\vio2sf\CodeAnalyst\vio2sf.caw
EndGlobalSection
EndGlobal

16
tools/vio2sf/vio2sf.vcproj
View File

@ -48,9 +48,10 @@
/>
<Tool
Name="VCCLCompilerTool"
AdditionalOptions="/MP"
Optimization="2"
InlineFunctionExpansion="1"
AdditionalIncludeDirectories="src/vio2sf/desmume,src/vio2sf/zlib,."
AdditionalIncludeDirectories="src/vio2sf/desmume;src/vio2sf/zlib;.;src/xsfc"
PreprocessorDefinitions="_CRT_SECURE_NO_WARNINGS;LSB_FIRST;WIN32;NDEBUG;_WINDOWS;_USRDLL;AOSSFDRV_EXPORTS;XSFDRIVER_EXTENDPARAM1NAME;"
StringPooling="true"
RuntimeLibrary="0"
@ -105,7 +106,7 @@
/>
<Tool
Name="VCPostBuildEventTool"
CommandLine="copy /y $(OutDir)\vio2sf.bin OUTPUT\winamp5\plugins&#x0D;&#x0A;copy /y $(OutDir)\vio2sf.bin OUTPUT\winamp2\plugins&#x0D;&#x0A;copy /y $(OutDir)\vio2sf.bin OUTPUT\kbmed\plugins&#x0D;&#x0A;copy /y $(OutDir)\vio2sf.bin OUTPUT\fb8&#x0D;&#x0A;copy /y $(OutDir)\vio2sf.bin OUTPUT\fb9\components"
CommandLine="copy /y $(OutDir)\vio2sf.bin OUTPUT\winamp5\plugins&#x0D;&#x0A;copy /y $(OutDir)\vio2sf.bin OUTPUT\winamp2\plugins&#x0D;&#x0A;copy /y $(OutDir)\vio2sf.bin OUTPUT\kbmed\plugins&#x0D;&#x0A;copy /y $(OutDir)\vio2sf.bin OUTPUT\fb8&#x0D;&#x0A;copy /y $(OutDir)\vio2sf.bin OUTPUT\fb9\components&#x0D;&#x0A;"
/>
</Configuration>
<Configuration
@ -141,8 +142,9 @@
/>
<Tool
Name="VCCLCompilerTool"
AdditionalOptions="/MP"
Optimization="0"
AdditionalIncludeDirectories="src/vio2sf/desmume,src/vio2sf/zlib,."
AdditionalIncludeDirectories="src/vio2sf/desmume;src/vio2sf/zlib;.;src/xsfc"
PreprocessorDefinitions="LSB_FIRST;WIN32;_DEBUG;_WINDOWS;_USRDLL;AOSSFDRV_EXPORTS;_CRT_SECURE_NO_WARNINGS;XSFDRIVER_EXTENDPARAM1NAME"
MinimalRebuild="true"
BasicRuntimeChecks="3"
@ -711,6 +713,14 @@
RelativePath="src\vio2sf\desmume\registers.h"
>
</File>
<File
RelativePath=".\src\vio2sf\desmume\soundView.cpp"
>
</File>
<File
RelativePath=".\src\vio2sf\desmume\soundView.h"
>
</File>
<File
RelativePath="src\vio2sf\desmume\SPU.cpp"
>