612 lines
13 KiB
C++
612 lines
13 KiB
C++
#include "../Agave/Language/api_language.h"
|
|
#include "main.h"
|
|
#include <math.h>
|
|
#include "resource.h"
|
|
#include "../Winamp/in2.h"
|
|
#include "../Winamp/wa_ipc.h"
|
|
|
|
extern In_Module mod;
|
|
void get_temp_file(char* fn)
|
|
{
|
|
static char tmp_path[MAX_PATH];
|
|
if (!tmp_path[0]) GetTempPathA(MAX_PATH,tmp_path);
|
|
static DWORD num;
|
|
if (num==0) num=GetTickCount();
|
|
wsprintfA(fn,"%sasdf%x.tmp",tmp_path,num++);
|
|
}
|
|
|
|
void file2title(const char* f,string& t)
|
|
{
|
|
const char* p1=strrchr(f,'\\'),*p2=strrchr(f,':'),*p3=strrchr(f,'/');
|
|
if (p2>p1) p1=p2;
|
|
if (p3>p1) p1=p3;
|
|
if (p1) p1++;
|
|
else p1=(char*)f;
|
|
t=p1;
|
|
p1=strrchr(t,'.');
|
|
if (p1) t.truncate(p1-(const char*)t);
|
|
}
|
|
|
|
static char* exts[]={"MID","MIDI","RMI","KAR","HMP","HMI","XMI","MSS","MUS","CMF","GMD","MIDS","MIZ","HMZ"};
|
|
#define N_EXTS tabsize(exts)
|
|
static char is_def[N_EXTS]={1,1,1,1,0,0,0,0,0,0,0,0,1,0};
|
|
|
|
static int get_def_exts()
|
|
{
|
|
int ret=0;
|
|
int n;
|
|
for(n=0;n<N_EXTS;n++)
|
|
{
|
|
if (is_def[n]) ret|=1<<n;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
cfg_int cfg_ext_mask("ext_mask",get_def_exts());
|
|
|
|
static char d_smf[128];
|
|
static char d_clo[128];
|
|
static char d_cmp[128];
|
|
|
|
int ext_descs[N_EXTS]={STRING_FILES_SMF,STRING_FILES_SMF,STRING_FILES_SMF,STRING_FILES_SMF,STRING_FILES_CLONE,STRING_FILES_CLONE,STRING_FILES_CLONE,STRING_FILES_CLONE,STRING_FILES_CLONE,STRING_FILES_CLONE,STRING_FILES_CLONE,STRING_FILES_CLONE,STRING_FILES_COMPRESSED,STRING_FILES_COMPRESSED};
|
|
|
|
int MIDI_core::FileTypes_GetNum() {return N_EXTS;}
|
|
const char * MIDI_core::FileTypes_GetExtension(int n) {return exts[n];}
|
|
char * MIDI_core::FileTypes_GetDescription(int n) {
|
|
char* s = d_smf;
|
|
if(ext_descs[n] == STRING_FILES_SMF) {
|
|
if(!d_smf[0]) {
|
|
WASABI_API_LNGSTRING_BUF(ext_descs[n],d_smf,128);
|
|
}
|
|
s = d_smf;
|
|
}
|
|
else if(ext_descs[n] == STRING_FILES_CLONE) {
|
|
if(!d_clo[0]) {
|
|
WASABI_API_LNGSTRING_BUF(ext_descs[n],d_clo,128);
|
|
}
|
|
s = d_clo;
|
|
}
|
|
else if(ext_descs[n] == STRING_FILES_COMPRESSED) {
|
|
if(!d_cmp[0]) {
|
|
WASABI_API_LNGSTRING_BUF(ext_descs[n],d_cmp,128);
|
|
}
|
|
s = d_cmp;
|
|
}
|
|
return s;
|
|
}
|
|
|
|
static int isourext(const char* ext)
|
|
{
|
|
UINT n;
|
|
for(n=0;n<N_EXTS;n++)
|
|
{
|
|
if ((cfg_ext_mask&(1<<n)) && !_stricmp(ext,exts[n])) return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int MIDI_core::IsOurFile(const char *fn)
|
|
{
|
|
const char* p=strrchr(fn,'.');
|
|
if (p)
|
|
{
|
|
if (isourext(p+1)) return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
extern UINT volmode_detect();
|
|
|
|
static BOOL CALLBACK KarProc(HWND wnd,UINT msg,WPARAM wp,LPARAM lp);
|
|
|
|
int MIDI_core::Init()
|
|
{
|
|
theFile=0;
|
|
data_src=0;
|
|
plr=0;
|
|
eof=0;
|
|
mix_dev=0;mix_idx=0;
|
|
kwnd=0;
|
|
kmap=0;
|
|
kmap_size=0;kmap_ptr=0;
|
|
kmap_data=0;
|
|
format_srate=0;format_nch=0;format_bps=0;
|
|
|
|
device=MIDI_driver::find_device(cfg_driver,cfg_device);
|
|
if (!device) return 0;
|
|
use_out=device->has_output() || (cfg_smp && cfg_sampout);
|
|
use_smp=cfg_smp && !device->has_output();
|
|
|
|
if (cfg_volmode>2) volmod=cfg_volmode-1;
|
|
else if (cfg_volmode==2) volmod = device->volctrl_happy() ? 1 : volmode_detect()+2;
|
|
else volmod=cfg_volmode;
|
|
|
|
if (volmod>1)
|
|
{
|
|
UINT idx=volmod-2;
|
|
UINT id=0;
|
|
UINT n_devz=mixerGetNumDevs();
|
|
UINT dev=0;
|
|
BOOL found=0;
|
|
MIXERLINE ml;
|
|
while(dev<n_devz)
|
|
{
|
|
mixerGetID((HMIXEROBJ)dev,&id,MIXER_OBJECTF_MIXER);
|
|
|
|
ZeroMemory(&ml,sizeof(ml));
|
|
ml.cbStruct=sizeof(ml);
|
|
ml.dwComponentType=MIXERLINE_COMPONENTTYPE_DST_SPEAKERS;
|
|
|
|
mixerGetLineInfo((HMIXEROBJ)id,&ml,MIXER_GETLINEINFOF_COMPONENTTYPE|MIXER_OBJECTF_MIXER);
|
|
|
|
if (idx<ml.cConnections)
|
|
{
|
|
found=1;
|
|
break;
|
|
}
|
|
idx-=ml.cConnections;
|
|
dev++;
|
|
}
|
|
if (found)
|
|
{
|
|
mix_dev=id;
|
|
mix_idx=idx;
|
|
}
|
|
else
|
|
{
|
|
volmod=0;
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
CStream * sampling_create(int srate,int nch,int bps);
|
|
|
|
cfg_int cfg_lyrics("lyrics",1);
|
|
|
|
int MIDI_core::OpenFile(MIDI_file * file)
|
|
{
|
|
|
|
#ifdef USE_LOG
|
|
log_write("MIDI_core::Open()");
|
|
#endif
|
|
|
|
if (!file) return 0;
|
|
|
|
format_srate=device->has_freq() ? cfg_freq : 44100;
|
|
format_bps=16;
|
|
format_nch=2;
|
|
|
|
|
|
|
|
theFile=file->AddRef();
|
|
#ifdef USE_LOG
|
|
log_write("file loaded");
|
|
#endif
|
|
plr=0;
|
|
|
|
|
|
if (use_smp)
|
|
{
|
|
#ifdef USE_LOG
|
|
log_write("starting sampling");
|
|
#endif
|
|
format_srate=cfg_wavein_sr;
|
|
format_bps=cfg_wavein_bps;
|
|
format_nch=cfg_wavein_ch;
|
|
data_src=sampling_create(format_srate,format_nch,format_bps);
|
|
}
|
|
|
|
plr=device->create();
|
|
|
|
if (plr)
|
|
{
|
|
#ifdef USE_LOG
|
|
if (data_src) log_write("got PCM data source");
|
|
|
|
log_write("playback started");
|
|
#endif
|
|
|
|
if (cfg_lyrics)
|
|
{
|
|
kmap=kmap_create(theFile,1,&kmap_size,&kmap_data);
|
|
if (kmap)
|
|
{
|
|
kwnd=WASABI_API_CREATEDIALOGPARAMW(IDD_LYRICS,MIDI_callback::GetMainWindow(),KarProc,0);
|
|
free(kmap_data); kmap_data=0;//not needed anymore, used only on initdialog to setdlgitemtext
|
|
}
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
else
|
|
{
|
|
if (data_src) {delete data_src;data_src=0;}
|
|
|
|
theFile->Free();
|
|
theFile=0;
|
|
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
int MIDI_core::GetSamples(void *sample_buffer, int bytes, char *killswitch)
|
|
{
|
|
#ifdef USE_LOG
|
|
log_write("GetSamples");
|
|
#endif
|
|
if (data_src)
|
|
{
|
|
return data_src->ReadData(sample_buffer,bytes,(bool*)killswitch);
|
|
}
|
|
else return 0;
|
|
}
|
|
|
|
void MIDI_core::update_vol()
|
|
{
|
|
MIXERLINE ml;
|
|
ZeroMemory(&ml,sizeof(ml));
|
|
ml.cbStruct=sizeof(ml);
|
|
ml.dwSource=mix_idx;
|
|
mixerGetLineInfo((HMIXEROBJ)mix_dev,&ml,MIXER_GETLINEINFOF_SOURCE|MIXER_OBJECTF_MIXER);
|
|
|
|
MIXERLINECONTROLS cs;
|
|
MIXERCONTROL c;
|
|
ZeroMemory(&cs,sizeof(cs));
|
|
cs.cbStruct=sizeof(cs);
|
|
cs.cControls=1;
|
|
cs.dwLineID=ml.dwLineID;
|
|
cs.dwControlType=MIXERCONTROL_CONTROLTYPE_VOLUME;
|
|
cs.cbmxctrl=sizeof(c);
|
|
cs.pamxctrl=&c;
|
|
ZeroMemory(&c,sizeof(c));
|
|
c.cbStruct=sizeof(c);
|
|
|
|
if (!mixerGetLineControls((HMIXEROBJ)mix_dev,&cs,MIXER_OBJECTF_MIXER|MIXER_GETLINECONTROLSF_ONEBYTYPE))
|
|
{
|
|
DWORD val;
|
|
if (cfg_logvol)
|
|
{
|
|
double _vol=volume>0 ? 20*log10((double)volume/255.0) : -60.0;//in negative db
|
|
_vol=_vol/60.0+1;
|
|
if (_vol<0) _vol=0;
|
|
val=c.Bounds.dwMinimum + (int)( _vol * (double)(c.Bounds.dwMaximum-c.Bounds.dwMinimum) );
|
|
}
|
|
else val=c.Bounds.dwMinimum + volume * (c.Bounds.dwMaximum-c.Bounds.dwMinimum) / 255;
|
|
if (ml.cChannels==1)
|
|
{
|
|
MIXERCONTROLDETAILS_UNSIGNED ds={val};
|
|
MIXERCONTROLDETAILS d;
|
|
d.cbStruct=sizeof(d);
|
|
d.dwControlID=c.dwControlID;
|
|
d.cChannels=1;
|
|
d.cMultipleItems=0;
|
|
d.cbDetails=sizeof(ds);
|
|
d.paDetails=&ds;
|
|
mixerSetControlDetails((HMIXEROBJ)mix_dev,&d,MIXER_SETCONTROLDETAILSF_VALUE|MIXER_OBJECTF_MIXER);
|
|
}
|
|
else if (ml.cChannels<16)
|
|
{
|
|
MIXERCONTROLDETAILS_UNSIGNED ds[16];
|
|
UINT n;
|
|
for(n=0;n<16;n++) ds[n].dwValue=val;
|
|
if (pan<0)
|
|
{
|
|
ds[1].dwValue=ds[1].dwValue*(128+pan)>>7;
|
|
}
|
|
else
|
|
{
|
|
ds[0].dwValue=ds[0].dwValue*(128-pan)>>7;
|
|
}
|
|
MIXERCONTROLDETAILS d;
|
|
d.cbStruct=sizeof(d);
|
|
d.dwControlID=c.dwControlID;
|
|
d.cChannels=ml.cChannels;
|
|
d.cMultipleItems=0;
|
|
d.cbDetails=sizeof(ds[0]);
|
|
d.paDetails=&ds;
|
|
mixerSetControlDetails((HMIXEROBJ)mix_dev,&d,MIXER_SETCONTROLDETAILSF_VALUE|MIXER_OBJECTF_MIXER);
|
|
}
|
|
}
|
|
/*
|
|
ZeroMemory(&cs,sizeof(cs));
|
|
cs.cbStruct=sizeof(cs);
|
|
cs.cControls=1;
|
|
cs.dwLineID=ml.dwLineID;
|
|
cs.dwControlType=MIXERCONTROL_CONTROLTYPE_PAN;
|
|
cs.cbmxctrl=sizeof(c);
|
|
cs.pamxctrl=&c;
|
|
ZeroMemory(&c,sizeof(c));
|
|
c.cbStruct=sizeof(c);
|
|
|
|
if (!mixerGetLineControls((HMIXEROBJ)mix_dev,&cs,MIXER_OBJECTF_MIXER|MIXER_GETLINECONTROLSF_ONEBYTYPE))
|
|
{
|
|
MIXERCONTROLDETAILS_SIGNED ds={c.Bounds.lMinimum + (pan+128) * (c.Bounds.lMaximum-c.Bounds.lMinimum) / 255};
|
|
MIXERCONTROLDETAILS d;
|
|
d.cbStruct=sizeof(d);
|
|
d.dwControlID=c.dwControlID;
|
|
d.cbDetails=sizeof(ds);
|
|
d.cChannels=ml.cChannels;
|
|
d.cMultipleItems=c.cMultipleItems;
|
|
d.paDetails=&ds;
|
|
mixerSetControlDetails((HMIXEROBJ)mix_dev,&d,MIXER_SETCONTROLDETAILSF_VALUE|MIXER_OBJECTF_MIXER);
|
|
}*/
|
|
}
|
|
|
|
int MIDI_core::SetVolume(int _volume)
|
|
{
|
|
volume=_volume;
|
|
if (volmod==0) return 0;
|
|
else
|
|
{
|
|
if (volmod==1)
|
|
{
|
|
if ((use_out && !use_smp) || !plr)
|
|
{
|
|
return 0;
|
|
}
|
|
else
|
|
{
|
|
return plr->setvol(player_getVol());
|
|
}
|
|
}
|
|
update_vol();
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
int MIDI_core::SetPan(int _pan)
|
|
{
|
|
pan=_pan;
|
|
if (volmod==0) return 0;
|
|
else
|
|
{
|
|
if (volmod==1)
|
|
{
|
|
if (plr) return plr->setpan(player_getPan());
|
|
else return 0;
|
|
}
|
|
else
|
|
{
|
|
update_vol();
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
int MIDI_core::SetPosition(int pos)
|
|
{
|
|
if (!plr) return 0;
|
|
if (!plr->settime(pos)) return 0;
|
|
sync.enter();
|
|
kmap_ptr=0;
|
|
LeaveCriticalSection(&sync);
|
|
|
|
if (data_src) data_src->Flush();
|
|
return 1;
|
|
}
|
|
|
|
void MIDI_core::Pause(int pause)
|
|
{
|
|
if (plr)
|
|
{
|
|
if (pause) plr->pause();
|
|
else plr->unpause();
|
|
}
|
|
if (data_src) data_src->Pause(pause);
|
|
}
|
|
|
|
int MIDI_core::GetPosition(void)
|
|
{
|
|
int i=0;
|
|
if (plr)
|
|
{
|
|
i=plr->gettime();
|
|
if (i<0) i=0;
|
|
}
|
|
return i;
|
|
}
|
|
|
|
int MIDI_core::GetLength(void)
|
|
{
|
|
if (theFile) return theFile->len;
|
|
else return -1;
|
|
}
|
|
|
|
void MIDI_core::Close()
|
|
{
|
|
#ifdef USE_LOG
|
|
log_write("shutting down MIDI_core");
|
|
#endif
|
|
if (plr) {delete plr;plr=0;}
|
|
if (data_src) {delete data_src;data_src=0;}
|
|
if (kwnd) {DestroyWindow(kwnd);kwnd=0;}
|
|
if (kmap) {free(kmap);kmap=0;}
|
|
if (theFile) {theFile->Free();theFile=0;}
|
|
}
|
|
|
|
void MIDI_core::Eof()
|
|
{
|
|
eof=1;
|
|
if (data_src)
|
|
data_src->Eof();
|
|
else
|
|
MIDI_callback::NotifyEOF();
|
|
}
|
|
|
|
|
|
static char INI_FILE[MAX_PATH];
|
|
|
|
void MIDI_core::GlobalInit()
|
|
{
|
|
#ifdef USE_LOG
|
|
log_start();
|
|
log_write("initializing");
|
|
log_write(NAME);
|
|
#endif
|
|
|
|
char *p;
|
|
if (mod.hMainWindow &&
|
|
(p = (char *)SendMessage(mod.hMainWindow, WM_WA_IPC, 0, IPC_GETINIFILE))
|
|
&& p!= (char *)1)
|
|
{
|
|
strcpy(INI_FILE, p);
|
|
}
|
|
else
|
|
{
|
|
GetModuleFileNameA(NULL,INI_FILE,sizeof(INI_FILE));
|
|
p = INI_FILE + strlen(INI_FILE);
|
|
while (p >= INI_FILE && *p != '.') p--;
|
|
strcpy(++p,"ini");
|
|
}
|
|
cfg_var::config_read(INI_FILE,"in_midi");
|
|
}
|
|
|
|
void MIDI_core::GlobalQuit()
|
|
{
|
|
MIDI_driver::shutdown();
|
|
log_quit();
|
|
}
|
|
|
|
void MIDI_core::WriteConfig()
|
|
{
|
|
cfg_var::config_write(INI_FILE,"in_midi");
|
|
}
|
|
|
|
void MIDI_core::MM_error(DWORD code)
|
|
{
|
|
string temp;
|
|
if (!mciGetErrorStringA(code,string_buffer_a(temp,256),256))
|
|
{
|
|
temp=WASABI_API_LNGSTRING(STRING_UNKNOWN_MMSYSTEM);
|
|
}
|
|
MIDI_callback::Error(temp);
|
|
|
|
}
|
|
|
|
|
|
static void fix_size(HWND wnd)
|
|
{
|
|
RECT r;
|
|
GetClientRect(wnd,&r);
|
|
SetWindowPos(GetDlgItem(wnd,IDC_BLAH),0,0,0,r.right,r.bottom,SWP_NOZORDER|SWP_NOACTIVATE);
|
|
}
|
|
|
|
static cfg_struct_t<RECT> cfg_lyrics_pos("lyrics_pos",-1);
|
|
|
|
static void SetWindowRect(HWND w,RECT* r)
|
|
{
|
|
SetWindowPos(w,0,r->left,r->top,r->right-r->left,r->bottom-r->top,SWP_NOZORDER);
|
|
}
|
|
|
|
|
|
static cfg_int cfg_lyrics_min("lyrics_min",0),cfg_lyrics_max("lyrics_max",0);
|
|
|
|
BOOL CALLBACK MIDI_core::KarProc(HWND wnd,UINT msg,WPARAM wp,LPARAM lp)
|
|
{
|
|
switch(msg)
|
|
{
|
|
case WM_INITDIALOG:
|
|
SetDlgItemTextA(wnd,IDC_BLAH,MIDI_core::kmap_data);
|
|
|
|
if (cfg_lyrics_pos.get_val().left!=-1)
|
|
{
|
|
int sx=GetSystemMetrics(SM_CXSCREEN),sy=GetSystemMetrics(SM_CYSCREEN);
|
|
if (cfg_lyrics_pos.get_val().right>sx)
|
|
{
|
|
cfg_lyrics_pos.get_val().left-=cfg_lyrics_pos.get_val().right-sx;
|
|
cfg_lyrics_pos.get_val().right=sx;
|
|
}
|
|
if (cfg_lyrics_pos.get_val().bottom>sy)
|
|
{
|
|
cfg_lyrics_pos.get_val().top-=cfg_lyrics_pos.get_val().bottom-sy;
|
|
cfg_lyrics_pos.get_val().bottom=sy;
|
|
}
|
|
if (cfg_lyrics_pos.get_val().left<0)
|
|
{
|
|
cfg_lyrics_pos.get_val().right-=cfg_lyrics_pos.get_val().left;
|
|
cfg_lyrics_pos.get_val().left=0;
|
|
}
|
|
if (cfg_lyrics_pos.get_val().top<0)
|
|
{
|
|
cfg_lyrics_pos.get_val().bottom-=cfg_lyrics_pos.get_val().top;
|
|
cfg_lyrics_pos.get_val().top=0;
|
|
}
|
|
SetWindowRect(wnd,&cfg_lyrics_pos.get_val());
|
|
}
|
|
if (cfg_lyrics_min)
|
|
{
|
|
ShowWindow(wnd,SW_MINIMIZE);
|
|
}
|
|
else if (cfg_lyrics_max)
|
|
{
|
|
ShowWindow(wnd,SW_MAXIMIZE);
|
|
}
|
|
fix_size(wnd);
|
|
SetTimer(wnd,1,100,0);
|
|
return 1;
|
|
case WM_TIMER:
|
|
{
|
|
sync.enter();
|
|
UINT time=GetPosition();
|
|
KAR_ENTRY * set=0;
|
|
UINT ptr=kmap_ptr;
|
|
while(ptr<kmap_size && kmap[ptr].time<time)
|
|
{
|
|
if (!kmap[ptr].foo) set=&kmap[ptr];
|
|
ptr++;
|
|
}
|
|
kmap_ptr=ptr;
|
|
sync.leave();
|
|
if (set)
|
|
{
|
|
SendDlgItemMessage(wnd,IDC_BLAH,EM_SETSEL,set->start,set->end);
|
|
}
|
|
|
|
}
|
|
break;
|
|
case WM_DESTROY:
|
|
KillTimer(wnd,1);
|
|
kwnd=0;
|
|
GetWindowRect(wnd,&cfg_lyrics_pos.get_val());
|
|
cfg_lyrics_max=!!IsZoomed(wnd);
|
|
cfg_lyrics_min=!!IsIconic(wnd);
|
|
break;
|
|
case WM_CLOSE:
|
|
|
|
cfg_lyrics=0;
|
|
|
|
if (!((int)cfg_bugged & BUGGED_BLAH))
|
|
{
|
|
char title[32] = {0};
|
|
cfg_bugged = (int)cfg_bugged | BUGGED_BLAH;
|
|
MessageBoxA(wnd,WASABI_API_LNGSTRING(IDS_TO_ENABLE_LYRICS_DISPLAY),
|
|
WASABI_API_LNGSTRING_BUF(IDS_INFORMATION,title,32),MB_ICONINFORMATION);
|
|
}
|
|
DestroyWindow(wnd);
|
|
break;
|
|
case WM_SIZE:
|
|
fix_size(wnd);
|
|
break;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
//MIDI_core static crap
|
|
bool MIDI_core::use_out;
|
|
MIDI_file* MIDI_core::theFile;
|
|
CStream* MIDI_core::data_src;
|
|
player_base* MIDI_core::plr;
|
|
int MIDI_core::format_srate,MIDI_core::format_nch,MIDI_core::format_bps;
|
|
int MIDI_core::volume=255,MIDI_core::pan=0;
|
|
bool MIDI_core::eof;
|
|
UINT MIDI_core::volmod;
|
|
UINT MIDI_core::mix_dev,MIDI_core::mix_idx;
|
|
MIDI_device * MIDI_core::device;
|
|
bool MIDI_core::use_smp;
|
|
HWND MIDI_core::kwnd;
|
|
KAR_ENTRY* MIDI_core::kmap;
|
|
UINT MIDI_core::kmap_size,MIDI_core::kmap_ptr;
|
|
char * MIDI_core::kmap_data;
|
|
critical_section MIDI_core::sync; |