steve
/
winamp
mirror of https://github.com/WinampDesktop/winamp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
winamp/Src/Plugins/Input/in_midi/utils.cpp

1065 lines
19 KiB
C++
Raw Permalink Blame History

#include "main.h"
#include "../Agave/language/api_language.h"
#include <commdlg.h>
#include "resource.h"
DWORD _fastcall rev32(DWORD d) {return _rv(d);}
void CPipe::WriteData(void* b,UINT s)
{
if (closed) return;
sec.enter();
if (buf_n+s>buf_s)
{
#ifdef USE_LOG
log_write("buffer overflow");
#endif
s=buf_s-buf_n;
s-=s%align;
}
if (s)
{
if (buf_wp+s<buf_s)
{
memcpy(buf+buf_wp,b,s);
buf_wp+=s;
}
else
{
UINT d=buf_s-buf_wp;
memcpy(buf+buf_wp,b,d);
memcpy(buf,(BYTE*)b+d,s-d);
buf_wp=s-d;
}
buf_n+=s;
}
sec.leave();
}
UINT CPipe::ReadData(void* _b,UINT s,bool* ks)
{
UINT rv=0;
BYTE * b=(BYTE*)_b;
sec.enter();
while(1)
{
UINT d=s;
if (d>buf_n) d=buf_n;
if (d)
{
if (buf_rp+d<buf_s)
{
memcpy(b,buf+buf_rp,d);
buf_rp+=d;
}
else
{
UINT d1=buf_s-buf_rp;
memcpy(b,buf+buf_rp,d1);
memcpy(b+d1,buf,d-d1);
buf_rp=d-d1;
}
buf_n-=d;
s-=d;
rv+=d;
b+=d;
}
if (closed || !s || *ks) break;
sec.leave();
MIDI_callback::Idle();
sec.enter();
}
sec.leave();
return rv;
}
#ifdef USE_LOG
static HANDLE hLog;
void log_start()
{
hLog=CreateFile("c:\\in_midi.log",GENERIC_WRITE,FILE_SHARE_READ,0,OPEN_ALWAYS,0,0);
SetFilePointer(hLog,0,0,FILE_END);
log_write("opening log");
}
void log_quit() {log_write("closing log");log_write("");log_write("");CloseHandle(hLog);}
void log_write(char* t)
{
DWORD bw;
WriteFile(hLog,t,strlen(t),&bw,0);
char _t[2]={13,10};
WriteFile(hLog,_t,2,&bw,0);
FlushFileBuffers(hLog);
}
#endif
//tempo map object
CTempoMap* tmap_create()
{
CTempoMap* m=new CTempoMap;
if (m)
{
m->pos=0;
m->size=0x100;
m->data=(TMAP_ENTRY*)malloc(m->size*sizeof(TMAP_ENTRY));
}
return m;
}
void CTempoMap::AddEntry(int _p,int tm)
{
if (!data) {pos=size=0;return;}
if (pos && _p<=data[pos-1].pos) {data[pos-1].tm=tm;return;}
if (pos==size)
{
size*=2;
data=(TMAP_ENTRY*)realloc(data,size*sizeof(TMAP_ENTRY));
if (!data) {pos=0;return;}
}
data[pos].pos=_p;
data[pos].tm=tm;
pos++;
}
int ReadSysex(const BYTE* src,int ml)
{
int r=1;
while(r<ml)
{
r++;
if (src[r]==0xF7) return r+1;
}
unsigned int d;
r=1+DecodeDelta(src+1,&d);
r+=d;
return r;
}
unsigned int DecodeDelta(const BYTE* src,unsigned int* _d, unsigned int limit)
{
unsigned int l=0;
unsigned int d=0;
BYTE b;
do
{
if (l >= limit)
{
*_d=0;
return l;
}
b=src[l++];
d=(d<<7)|(b&0x7F);
} while(b&0x80);
*_d=d;
return l;
}
int EncodeDelta(BYTE* dst,int d)
{
if (d==0)
{
dst[0]=0;
return 1;
}
else
{
int r=0;
int n=1;
unsigned int temp=d;
while (temp >>= 7)
{
n++;
}
do {
n--;
BYTE b=(BYTE)((d>>(7*n))&0x7F);
if (n) b|=0x80;
dst[r++]=b;
} while(n);
return r;
}
}
int CTempoMap::BuildTrack(grow_buf & out)
{
if (!pos) return 0;
int start=out.get_size();
//BYTE* trk=(BYTE*)malloc(8+4+pos*10);
//if (!trk) return 0;
out.write_dword(_rv('MTrk'));
out.write_dword(0);//track size
DWORD ct=0;
int n;
BYTE t_event[6]={0xFF,0x51,0x03,0,0,0};
for(n=0;n<pos;n++)
{
DWORD t=data[n].pos;
gb_write_delta(out,t-ct);
ct=t;
t=data[n].tm;
t_event[3]=(BYTE)(t>>16);
t_event[4]=(BYTE)(t>>8);
t_event[5]=(BYTE)(t);
out.write(t_event,6);
}
out.write_dword(0x002FFF00);
out.write_dword_ptr(rev32(out.get_size()-(start+8)),start+4);
return 1;
}
//sysex map management
void CSysexMap::AddEvent(const BYTE* e,DWORD s,DWORD t)
{
if (!data || !events) return;
DWORD np=pos+1;
if (np>=e_size)
{
do {
e_size<<=1;
} while(np>=e_size);
events=(SYSEX_ENTRY*)realloc(events,e_size*sizeof(SYSEX_ENTRY));
if (!events) return;
}
DWORD nd=d_pos+s;
if (nd>=d_size)
{
do {
d_size<<=1;
} while(nd>=d_size);
data=(BYTE*)realloc(data,d_size);
if (!data) return;
}
data[d_pos]=0xF0;
unsigned int x;
unsigned int sp=DecodeDelta(e+1,&x);
if (sp >= s)
return;
memcpy(data+d_pos+1,e+1+sp,s-1-sp);
events[pos].pos=t;
events[pos].ofs=d_pos;
events[pos].len=s-sp;
d_pos=nd-sp;
pos++;
}
CSysexMap* smap_create()
{
CSysexMap* s=new CSysexMap;
if (s)
{
s->e_size=0x10;
s->d_size=0x40;
s->events=(SYSEX_ENTRY*)malloc(sizeof(SYSEX_ENTRY)*s->e_size);
s->data=(BYTE*)malloc(s->d_size);
s->d_pos=s->pos=0;
}
return s;
}
CSysexMap::~CSysexMap()
{
if (data) free(data);
if (events) free(events);
}
BYTE d_GMReset[6]={0xF0,0x7E,0x7F,0x09,0x01,0xF7};
BYTE d_XGReset[9]={0xf0,0x43,0x10,0x4c,0x00,0x00,0x7e,0x00,0xf7};
BYTE d_GSReset[11]={0xF0,0x41,0x10,0x42,0x12,0x40,0x00,0x7F,0x00,0x41,0xF7};
CSysexMap* CSysexMap::Translate(MIDI_file * mf)
{
CTempoMap* tmap=mf->tmap;
if (!events || !data || !tmap) return 0;
CSysexMap* nm=smap_create();
if (!nm) return 0;
nm->d_size=d_size;
nm->d_pos=d_pos;
nm->data=(BYTE*)realloc(nm->data,nm->d_size);
if (!nm->data) {delete nm;return 0;}
memcpy(nm->data,data,d_pos);
nm->e_size=e_size;
nm->pos=pos;
nm->events=(SYSEX_ENTRY*)realloc(nm->events,sizeof(SYSEX_ENTRY)*nm->e_size);
if (!nm->events) {delete nm;return 0;}
int pos_ms=0;
int n=0;
int cur_temp=0;
int ntm=tmap->pos,t_pos=0;
int p_t=0;
int dtx = rev16(*(WORD*)(mf->data+12))*1000;
int pos_tx=0;
while(n<pos)
{
pos_tx=events[n].pos;
int d=pos_tx-p_t;
p_t=pos_tx;
while(t_pos<ntm && pos_tx+d>=tmap->data[t_pos].pos)
{
DWORD d1=tmap->data[t_pos].pos-pos_tx;
pos_ms+=MulDiv(cur_temp,d1<<8,dtx);
cur_temp=tmap->data[t_pos].tm;
t_pos++;
pos_tx+=d1;
d-=d1;
}
pos_ms+=MulDiv(cur_temp,d<<8,dtx);
pos_tx+=d;
nm->events[n].pos=pos_ms>>8;
nm->events[n].ofs=events[n].ofs;
nm->events[n].len=events[n].len;
n++;
}
return nm;
}
int CSysexMap::BuildTrack(grow_buf & out)
{
if (!pos) return 0;
int start=out.get_size();
out.write_dword(_rv('MTrk'));
out.write_dword(0);
int ct=0;
int n;
for(n=0;n<pos;n++)
{
DWORD t=events[n].pos;
gb_write_delta(out,t-ct);
ct=t;
out.write_byte(0xF0);
gb_write_delta(out,events[n].len-1);
out.write(data+events[n].ofs+1,events[n].len-1);
}
out.write_dword(0x002FFF00);
out.write_dword_ptr(rev32(out.get_size()-(start+8)),start+4);
return 1;
}
const char* CSysexMap::GetType()
{
int ret=0;
int n;
for(n=0;n<pos;n++)
{
ret=data[events[n].ofs+1];
if (ret!=0x7E) break;
}
switch(ret)
{
case 0x7E:
return "GM";
case 0x43:
return "XG";
case 0x42:
return "X5";
case 0x41:
return "GS";
}
return 0;
}
void CSysexMap::CleanUp()
{
if (!pos) return;
int n,m;
for(n=0;n<pos-1;n++)
{
for(m=n+1;m<pos;m++)
{
if (events[n].pos>events[m].pos)
{
SYSEX_ENTRY t=events[n];
events[n]=events[m];
events[m]=t;
}
}
}
}
char* BuildFilterString(UINT res_id, char* ext, int* len)
{
static char filterStr[256];
char *f = filterStr;
ZeroMemory(filterStr,256);
*len = 0;
WASABI_API_LNGSTRING_BUF(res_id,filterStr,256);
f += (*len = lstrlenA(filterStr) + 1);
lstrcatA(f,"*.");
f += 2;
lstrcatA(f,ext);
*(f + lstrlenA(ext)+1) = 0;
*len += lstrlenA(ext)+3;
return filterStr;
}
BOOL DoOpenFile(HWND w,char* fn,UINT res_id, char* ext,BOOL save)
{
int len = 0;
OPENFILENAMEA ofn = {sizeof(ofn),0};
ofn.hwndOwner=w;
ofn.lpstrFilter=BuildFilterString(res_id,ext,&len);
ofn.lpstrFile=fn;
ofn.nMaxFile=MAX_PATH;
ofn.lpstrDefExt=ext;
if (save)
{
ofn.Flags=OFN_OVERWRITEPROMPT|OFN_PATHMUSTEXIST|OFN_HIDEREADONLY;
return GetSaveFileNameA(&ofn);
}
else
{
ofn.Flags=OFN_FILEMUSTEXIST|OFN_PATHMUSTEXIST|OFN_HIDEREADONLY;
return GetOpenFileNameA(&ofn);
}
}
BOOL DoSaveFile(HWND w, char* fn, char* filt, char* ext)
{
OPENFILENAMEA ofn;
ZeroMemory(&ofn,sizeof(ofn));
ofn.lStructSize=sizeof(ofn);
ofn.hwndOwner=w;
ofn.lpstrFilter=filt;
ofn.lpstrFile=fn;
ofn.nMaxFile=MAX_PATH;
ofn.lpstrDefExt=ext;
ofn.Flags=OFN_FILEMUSTEXIST|OFN_PATHMUSTEXIST|OFN_HIDEREADONLY;
return GetOpenFileNameA(&ofn);
}
typedef void (*SYSEXFUNC)(void*,BYTE*,UINT);
#define rsysex(X) f(i,X,sizeof(X))
#define _sysex(X,Y) f(i,X,Y)
bool need_sysex_start()
{
return cfg_hardware_reset>0
|| cfg_sysex_table.num_entries()>0
;
}
void sysex_startup(SYSEXFUNC f,void* i)
{
if (cfg_hardware_reset>0)
{
switch(cfg_hardware_reset)
{
case 1:rsysex(d_GMReset);break;
case 2:rsysex(d_GSReset);break;
case 3:rsysex(d_XGReset);break;
}
MIDI_callback::Idle(200);
}
if (cfg_sysex_table.num_entries()>0)
{
int idx=0;
BYTE * data;
int size,time;
while(cfg_sysex_table.get_entry(idx++,&data,&size,&time))
{
_sysex(data,size);
MIDI_callback::Idle(time);
}
}
}
MIDI_EVENT* do_table(MIDI_file * mf,UINT prec,UINT * size,UINT* _lstart,DWORD cflags)
{
BYTE * data_ptr = 0;
int data_size = 0;
if (!DoCleanUp(mf,CLEAN_1TRACK|CLEAN_NOSYSEX|CLEAN_NOTEMPO|cflags,(void**)&data_ptr,&data_size)) return 0;
if (data_size<=0x0e) {free(data_ptr);return 0;}
UINT ts;
BYTE* track;
UINT ntm;
track=data_ptr+8+6+8;
ts=rev32(*(DWORD*)(track-4));
CTempoMap* tmap=mf->tmap;
UINT n=0;
UINT pt=0;
ntm=tmap->pos;
CSysexMap* smap;
if (!cfg_nosysex && mf->smap && mf->smap->pos)
{
smap=mf->smap;
}
else smap=0;
n=0;
DWORD pos=0;
DWORD pos_ms=0;
DWORD t_pos=0;
DWORD cur_temp=0;
UINT dtx=(UINT)rev16(*(WORD*)(data_ptr+8+4))*1000/prec;
grow_buf boo;
int ns=0;
UINT track_pos=0,smap_pos=0;
UINT loop_start=-1;
{
unsigned int _d;
n+=DecodeDelta(track+n,&_d);
track_pos+=_d;
}
if (smap)
{
smap_pos=smap->events[0].pos;
}
else smap_pos=-1;
while(1)
{
DWORD ev=0;
DWORD d=0;
{
if (n >= (data_size-26))
break;
if (track_pos<smap_pos)
{
d=track_pos-pos;
ev=(*(DWORD*)(track+n))&0xFFFFFF;
if ((ev&0xF0)==0xF0)
{
track_pos=-1;
continue;
}
if ((ev&0xF0)==0xC0 || (ev&0xF0)==0xD0)
{
ev&=0xFFFF;n+=2;
}
else
{
n+=3;
}
if ((ev&0xFF00F0)==0x90)
{
ev=(ev&0xFF0F)|0x7F0080;
}
unsigned int _d;
n+=DecodeDelta(track+n,&_d);
track_pos+=_d;
if (n >= (data_size-26))
break;
}
else if (smap_pos!=-1)
{
d=smap_pos-pos;
ev=0x80000000|ns;
ns++;
if (ns==smap->pos)
smap_pos=-1;
else
smap_pos=smap->events[ns].pos;
}
}
if (!ev) break;
while(t_pos<ntm && pos+d>=(UINT)tmap->data[t_pos].pos)
{
DWORD d1=tmap->data[t_pos].pos-pos;
if (loop_start==-1 && (UINT)mf->loopstart_t<=pos+d1) loop_start=pos_ms+MulDiv(cur_temp,pos+d1-mf->loopstart_t,dtx);
pos_ms+=MulDiv(cur_temp,d1,dtx);
cur_temp=tmap->data[t_pos].tm;
t_pos++;
pos+=d1;
d-=d1;
}
if (loop_start==-1 && (UINT)mf->loopstart_t<=pos+d) loop_start=pos_ms+MulDiv(cur_temp,d,dtx);
pos_ms+=MulDiv(cur_temp,d,dtx);
pos+=d;
{
MIDI_EVENT me={pos_ms,ev};
boo.write(&me,sizeof(me));
}
}
free(data_ptr);
UINT sz=boo.get_size();
MIDI_EVENT* ret=(MIDI_EVENT*)boo.finish();
if (ret)
{
*size=sz>>3;//sz/sizeof(MIDI_EVENT);
if (cfg_loop_type==2 && loop_start==-1) loop_start=0;
else if (cfg_loop_type==0) loop_start=-1;
if (_lstart) *_lstart=loop_start;
}
return ret;
}
void gb_write_delta(grow_buf & gb,DWORD d)
{
BYTE tmp[8] = {0};
gb.write(tmp,EncodeDelta(tmp,d));
}
void do_messages(HWND w,bool* b)
{
MSG msg;
while(b && *b)
{
BOOL b=GetMessage(&msg,w,0,0);
if (b==-1 || !b) break;
DispatchMessage(&msg);
}
}
static wchar_t cb_class[]=TEXT("CallbackWndClass0");
ATOM do_callback_class(WNDPROC p)
{
cb_class[sizeof(cb_class)-2]++;
WNDCLASS wc=
{
0,p,0,4,MIDI_callback::GetInstance(),0,0,0,0,cb_class
};
return RegisterClassW(&wc);
}
HWND create_callback_wnd(ATOM cl,void* p)
{
HWND w=CreateWindowA((char*)cl,0,0,0,0,0,0,MIDI_callback::GetMainWindow(),0,MIDI_callback::GetInstance(),0);
if (w) SetWindowLong(w,0,(long)p);
return w;
}
CTempoMap* tmap_merge(CTempoMap* m1,CTempoMap* m2)
{
int p1=0,p2=0;
CTempoMap * ret=0;
if (m1 && m2 && m1->data && m2->data)
{
ret=tmap_create();
if (ret)
{
while(p1<m1->pos && p2<m2->pos)
{
if (m1->data[p1].pos<=m2->data[p2].pos)
{
ret->AddEntry(m1->data[p1].pos,m1->data[p1].tm);
p1++;
}
else
{
ret->AddEntry(m2->data[p2].pos,m2->data[p2].tm);
p2++;
}
}
while(p1<m1->pos)
{
ret->AddEntry(m1->data[p1].pos,m1->data[p1].tm);
p1++;
}
while(p2<m2->pos)
{
ret->AddEntry(m2->data[p2].pos,m2->data[p2].tm);
p2++;
}
}
}
if (m1) delete m1;
if (m2) delete m2;
return ret;
}
KAR_ENTRY * kmap_create(MIDI_file* mf,UINT prec,UINT * num,char** text)
{
if (!mf->kar_track) return 0;
grow_buf b_data,b_map;
KAR_ENTRY te;
BYTE *track=(BYTE*)mf->data+mf->kar_track+8;
BYTE *track_end = track+rev32(*(DWORD*)(mf->data+mf->kar_track+4));
int time=0;
int ptr=0;
BYTE lc=0;
while(track<track_end)
{
unsigned int d;
track+=DecodeDelta(track,&d);
time+=d;
if (*track==0xFF) //meta
{
BYTE type=track[1];
track+=2;
track+=DecodeDelta(track,&d);
char * ptr=(char*)track;
track+=d;
if ((type==0x5 || type==0x1) && d && *ptr!='@') //lyrics
{
te.time=time;
te.foo=1;
unsigned int n;
te.start=b_data.get_size();
for(n=0;n<d;n++)
{
switch(ptr[n])
{
// case '@':
case '\\':
case '/':
case 0x0D:
b_data.write("\x0d\x0a",2);
break;
case 0x0A:
break;
default:
te.foo=0;
b_data.write_byte(ptr[n]);
break;
}
}
te.end=b_data.get_size();
if (te.start<te.end) b_map.write(&te,sizeof(te));
}
}
else if (*track==0xF0)
{
track++;
track+=DecodeDelta(track,&d);
track+=d;
}
else if ((*track&0xF0)==0xF0)
{
track++;//hack
}
else
{
if (*track&0x80) lc=*(track++)&0xF0;
if (lc==0 || lc==0xC0 || lc==0xD0) track++;
else track+=2;
}
}
int map_siz = b_map.get_size();
KAR_ENTRY * map=(KAR_ENTRY*)b_map.finish();
map_siz/=sizeof(KAR_ENTRY);
if (num) *num=map_siz;
if (text)
{
b_data.write_byte(0);
*text=(char*)b_data.finish();
}
else b_data.reset();
if (map)
{
int n;
time=0;
CTempoMap* tmap=mf->tmap;
int pos_ms=0;
int t_pos=0;
int cur_temp=0;
int dtx=(UINT)rev16(*(WORD*)(mf->data+8+4))*1000/prec;
for(n=0;n<map_siz;n++)
{
int d=0;
d=map[n].time-time;
while(t_pos<tmap->pos && time+d>=tmap->data[t_pos].pos)
{
DWORD d1=tmap->data[t_pos].pos-time;
pos_ms+=MulDiv(cur_temp,d1,dtx);
cur_temp=tmap->data[t_pos].tm;
t_pos++;
time+=d1;
d-=d1;
}
pos_ms+=MulDiv(cur_temp,d,dtx);
time+=d;
map[n].time=pos_ms;
}
}
return map;
}
int sysex_table::num_entries() const
{
int num=0;
entry * ptr=entries;
while(ptr) {ptr=ptr->next;num++;}
return num;
}
int sysex_table::get_entry(int idx,BYTE ** p_data,int * p_size,int * p_time) const
{
entry * ptr=entries;
while(ptr && idx>0) {ptr=ptr->next;idx--;}
if (!ptr) return 0;
if (p_data) *p_data = ptr->data;
if (p_size) *p_size = ptr->size;
if (p_time) *p_time = ptr->time;
return 1;
}
void sysex_table::insert_entry(int idx,BYTE * data,int size,int time)
{
entry ** ptr = &entries;
while(idx>0 && *ptr)
{
ptr = &(*ptr)->next;
idx--;
}
entry * insert = new entry;
insert->data = (BYTE*)malloc(size);
memcpy(insert->data,data,size);
insert->size = size;
insert->time = time;
insert->next = *ptr;
*ptr = insert;
}
int sysex_table::remove_entry(int idx)
{
entry ** ptr = &entries;
while(idx>0 && *ptr)
{
ptr = &(*ptr)->next;
idx--;
}
if (!*ptr) return 0;
entry * remove = *ptr;
*ptr=remove->next;
free(remove->data);
delete remove;
return 1;
}
int sysex_table::file_write(const char* file) const
{
HANDLE f=CreateFileA(file,GENERIC_WRITE,0,0,CREATE_ALWAYS,0,0);
if (f==INVALID_HANDLE_VALUE) return 0;
int size;
void * ptr = memblock_write(&size);
DWORD bw = 0;
WriteFile(f,ptr,size,&bw,0);
free(ptr);
CloseHandle(f);
return 1;
}
void * sysex_table::memblock_write(int * size) const
{
grow_buf wb;
entry * ptr;
//MAGIC:DWORD , NUM: DWORD,DATA_SIZE:DWORD, offsets, sleep,data
DWORD temp;
temp=MHP_MAGIC;
wb.write(&temp,4);
temp=num_entries();
wb.write(&temp,4);
temp=0;
for(ptr=entries;ptr;ptr=ptr->next) temp+=ptr->size;
wb.write(&temp,4);
temp=0;
for(ptr=entries;ptr;ptr=ptr->next)
{
wb.write(&temp,4);
temp+=ptr->size;
}
for(ptr=entries;ptr;ptr=ptr->next)
{
temp = ptr->time;
wb.write(&temp,4);
}
for(ptr=entries;ptr;ptr=ptr->next)
{
wb.write(ptr->data,ptr->size);
}
if (size) *size = wb.get_size();
return wb.finish();
}
int sysex_table::memblock_read(const void * block,int size)
{
entry * ptr;
const BYTE * src = (const BYTE*)block;
DWORD temp,total_size,total_num;
if (*(DWORD*)src!=MHP_MAGIC) return 0;
src+=4;
temp=total_num=*(DWORD*)src;
src+=4;
if (total_num>0xFFFF) return 0;
reset();
while(temp>0)
{
ptr=new entry;
ptr->next=entries;
entries = ptr;
temp--;
}
total_size=*(DWORD*)src;
UINT n;
for(n=0,ptr=entries;ptr;ptr=ptr->next,n++)
{
//offset : 12 + 4 * n;
//time : 12 + 4 * total_num + 4 * n;
//data : 12 + 8 * total_num + offset
DWORD offset,time,offset2;
src = (const BYTE*)block + 12 + 4*n;
offset=*(DWORD*)src;
if (n!=total_num-1) offset2=*(DWORD*)(src+4);
else offset2=total_size;
ptr->size = offset2-offset;
src = (const BYTE*)block + 12 + 4*total_num + 4*n;
time = *(DWORD*)src;
ptr->data = (BYTE*)malloc(offset2);
src = (const BYTE*)block + 12 + 8*total_num + offset;
memcpy(ptr->data,src,ptr->size);
ptr->time = time;
}
return 1;
}
int sysex_table::file_read(const char* file)
{
HANDLE f=CreateFileA(file,GENERIC_READ,FILE_SHARE_READ,0,OPEN_EXISTING,0,0);
if (f==INVALID_HANDLE_VALUE) return 0;
int size = GetFileSize(f,0);
void * temp = malloc(size);
DWORD br = 0;
ReadFile(f,temp,size,&br,0);
CloseHandle(f);
int rv = memblock_read(temp,size);
free(temp);
return rv;
}
int sysex_table::print_preview(int idx,char * out) const
{
BYTE* data;
int size,time;
if (!get_entry(idx,&data,&size,&time)) return 0;
int size2=size;
if (size2>10) size2=10;
wsprintfA(out,WASABI_API_LNGSTRING(STRING_MS_FMT),time);
while(out && *out) out++;
int n;
for(n=0;n<size2;n++)
{
wsprintfA(out," %02X",data[n]);
out+=3;
}
if (size!=size2)
{
strcpy(out,"...");
}
return 1;
}
void sysex_table::print_edit(int idx,HWND wnd) const
{
BYTE* data;
int size,time;
if (!get_entry(idx,&data,&size,&time)) {SetWindowTextA(wnd,"");return;}
if (size<=2) {SetWindowTextA(wnd,"");return;}
char *temp = (char*)malloc(3*size);
char *ptr = temp;
int n;
for(n=1;n<size-1;n++)
{
wsprintfA(ptr,"%02X ",data[n]);
ptr+=3;
}
ptr[-1]=0;
SetWindowTextA(wnd,temp);
free(temp);
}
void sysex_table::copy(const sysex_table & src)
{
reset();
int idx=0;
BYTE * data;
int size,time;
while(src.get_entry(idx++,&data,&size,&time))//ASS SLOW
insert_entry(idx,data,size,time);
}
//special sysex table cfg_var hack
class cfg_var_sysex : private cfg_var
{
private:
sysex_table * tab;
virtual void read(HKEY hk)
{
int size=reg_get_struct_size(hk);
if (size>0)
{
void * temp = malloc(size);
if (temp)
{
reg_read_struct(hk,temp,size);
tab->memblock_read(temp,size);
free(temp);
}
}
}
virtual void write(HKEY hk)
{
void * data;
int size;
data = tab->memblock_write(&size);
if (data) reg_write_struct(hk,data,size);
}
virtual void reset() {tab->reset();}
public:
cfg_var_sysex(const char * name,sysex_table * p_tab) : cfg_var(name) {tab=p_tab;}
};
static cfg_var_sysex thevar("sysex_table",&cfg_sysex_table);
Reference in New Issue View Git Blame Copy Permalink