603 lines
12 KiB
C++
603 lines
12 KiB
C++
#include "main.h"
|
|
#include <intsafe.h>
|
|
|
|
//#define HUNT_LEAKS
|
|
#ifdef MF_USE_DMCRAP
|
|
extern IDirectMusicCollection *pCDLS;
|
|
#endif
|
|
|
|
#ifdef HUNT_LEAKS
|
|
static UINT n_files;
|
|
#endif
|
|
|
|
MIDI_file::MIDI_file(const char * fn) : path(fn)
|
|
{
|
|
flags=0;
|
|
format=0;
|
|
len=0;tix=0;
|
|
size=0;
|
|
data=0;
|
|
#ifdef MF_USE_DMCRAP
|
|
pSeg=0;
|
|
pDLS=0;
|
|
pDLSdata=0;
|
|
DLSsize=0;
|
|
#endif
|
|
info.fmt=info.ntrax=info.tix=0;
|
|
info.channels=0;
|
|
info.e_type=0;
|
|
loopstart=0;loopend=0;
|
|
loopstart_t=0;
|
|
rmi_data=0;
|
|
rmi_size=0;
|
|
bmp_data=0;
|
|
bmp_size=0;
|
|
kar_track=0;
|
|
tmap=0;
|
|
smap=0;
|
|
#ifdef HUNT_LEAKS
|
|
n_files++;
|
|
#endif
|
|
refcount=1;
|
|
info.traxnames=0;
|
|
}
|
|
|
|
#ifdef MF_USE_DMCRAP
|
|
extern IDirectMusicCollection *pCDLS;
|
|
extern IDirectMusicLoader* pLoader;
|
|
#endif
|
|
|
|
|
|
static bool is_gmd(const BYTE* b,size_t s)
|
|
{
|
|
return s>12 && *(DWORD*)b==_rv('MIDI') && *(DWORD*)(b+8)==_rv('MDpg');
|
|
}
|
|
|
|
static bool is_hmi(const BYTE* b,size_t s)
|
|
{
|
|
return s>12 && *(DWORD*)b==_rv('HMI-') && *(DWORD*)(b+4)==_rv('MIDI') && *(DWORD*)(b+8)==_rv('SONG');
|
|
}
|
|
|
|
static bool is_hmp(const BYTE* b,size_t s)
|
|
{
|
|
if (s>8 && ((DWORD*)b)[0]==_rv('HMIM') && (((DWORD*)b)[1]==_rv('IDIP') || ((DWORD*)b)[1]==_rv('IDIR')) )
|
|
{
|
|
//DWORD d=*(DWORD*)(b+0x30);
|
|
//return (d<0x40 && d);
|
|
return 1;
|
|
}
|
|
else return 0;
|
|
}
|
|
|
|
static bool is_xmidi(const BYTE* b,size_t s)
|
|
{
|
|
return s>0x20 && *(DWORD*)b==_rv('FORM') && *(DWORD*)(b+8)==_rv('XDIR') && *(DWORD*)(b+0x1e)==_rv('XMID');
|
|
}
|
|
|
|
static bool is_rmi(const BYTE* b,size_t s)
|
|
{
|
|
return s>20+8+6+8 && *(DWORD*)b==_rv('RIFF') && *(DWORD*)(b+8)==_rv('RMID') && *(DWORD*)(b+12)==_rv('data');
|
|
}
|
|
|
|
static bool is_midi(const BYTE* b,size_t s)
|
|
{
|
|
return s>8+6+8 && *(DWORD*)b==_rv('MThd') && *(DWORD*)(b+4)==0x06000000 && *(DWORD*)(b+14)==_rv('MTrk');
|
|
}
|
|
|
|
static bool is_midi_scan(const BYTE* b,size_t s)
|
|
{
|
|
int x,m=s;
|
|
if (m>256) m=256;
|
|
m-=8+6+8;
|
|
for(x=0;x<m;x++)
|
|
if (is_midi(b+x,s-x)) return 1;
|
|
return 0;
|
|
}
|
|
|
|
#define REM (unsigned int)(sz-ptr)
|
|
|
|
static bool load_midi_fix(MIDI_file* mf,const BYTE* buf,size_t sz,int n_track,size_t p_ofs)
|
|
{
|
|
if (!cfg_recover_tracks)
|
|
return 0;
|
|
|
|
size_t malloc_sz;
|
|
if (SizeTAdd(sz, 0x10, &malloc_sz) != S_OK)
|
|
return false;
|
|
|
|
BYTE* outbuf=(BYTE*)malloc(malloc_sz);
|
|
if (!outbuf) return 0;
|
|
size_t ptr=p_ofs;
|
|
size_t bp=ptr;
|
|
BYTE lc=0;
|
|
while(1)
|
|
{
|
|
bp=ptr;
|
|
if (REM<4) break;
|
|
while(buf[ptr]&0x80)
|
|
{
|
|
if (ptr==bp+4) break;
|
|
ptr++;
|
|
}
|
|
ptr++;
|
|
if (REM<3) break;
|
|
BYTE b=buf[ptr];
|
|
if (b==0xFF)
|
|
{
|
|
ptr+=2;
|
|
if (REM<4) break;
|
|
unsigned int d;
|
|
unsigned int l=DecodeDelta(buf+ptr,&d, sz-ptr);
|
|
if (l+d>REM) break;
|
|
ptr+=l+d;
|
|
}
|
|
else if (b==0xF0)
|
|
{
|
|
ptr++;
|
|
if (REM<4) break;
|
|
unsigned int d;
|
|
unsigned int l=DecodeDelta(buf+ptr,&d, sz-ptr);
|
|
if (l+d>REM) break;
|
|
ptr+=l+d;
|
|
}
|
|
else
|
|
{
|
|
if (b&0x80)
|
|
{
|
|
lc=b&0xF0;
|
|
if (lc==0xF0) break;
|
|
ptr++;
|
|
}
|
|
else if (!lc) break;
|
|
if (lc==0xC0 || lc==0xD0) ptr++;
|
|
else ptr+=2;
|
|
}
|
|
}
|
|
memcpy(outbuf,buf,ptr);
|
|
ptr=bp;
|
|
outbuf[ptr++]=0;
|
|
outbuf[ptr++]=0xFF;
|
|
outbuf[ptr++]=0x2F;
|
|
outbuf[ptr++]=0;
|
|
*(DWORD*)(outbuf+p_ofs-4)=rev32(ptr-p_ofs);
|
|
mf->data=outbuf;
|
|
mf->size=ptr;
|
|
|
|
return 1;
|
|
}
|
|
|
|
#undef REM
|
|
|
|
static bool load_midi(MIDI_file* mf,const BYTE* buf,size_t sz)
|
|
{
|
|
int trax=rev16(*(WORD*)(buf+4+4+2));
|
|
size_t ofs=6+8;
|
|
int n;
|
|
for(n=0;n<trax;n++)
|
|
{
|
|
if (ofs>(sz-12) || *(DWORD*)(buf+ofs)!=_rv('MTrk'))
|
|
{
|
|
mf->flags|=FLAG_INCOMPLETE;
|
|
*(WORD*)(buf+4+4+2)=rev16(n);
|
|
sz=ofs;
|
|
break;
|
|
}
|
|
|
|
if (SizeTAdd(ofs, 8, &ofs) != S_OK)
|
|
return false;
|
|
|
|
size_t p_ofs=ofs;
|
|
DWORD next = rev32(*(DWORD*)(buf+ofs-4));
|
|
if (SizeTAdd(ofs, next, &ofs) != S_OK)
|
|
return false;
|
|
|
|
if (ofs>sz)
|
|
{
|
|
mf->flags|=FLAG_INCOMPLETE;
|
|
*(WORD*)(buf+4+4+2)=rev16(n+1);
|
|
if (!load_midi_fix(mf,buf,sz,n,p_ofs))
|
|
{
|
|
*(WORD*)(buf+4+4+2)=rev16(n);
|
|
sz=p_ofs-8;
|
|
break;
|
|
}
|
|
else return 1;
|
|
}
|
|
}
|
|
|
|
BYTE * out = (BYTE*)malloc(sz);
|
|
if (!out)
|
|
return 0;
|
|
memcpy(out,buf,sz);
|
|
mf->data=out;
|
|
mf->size=sz;
|
|
return 1;
|
|
}
|
|
|
|
static bool load_gmd(MIDI_file* mf,const BYTE* buf,size_t sz)
|
|
{
|
|
if (sz<=0x10) return 0;
|
|
DWORD s=rev32(*(DWORD*)(buf+4));
|
|
if ((sz-8)<s) return 0;
|
|
DWORD ofs=rev32(*(DWORD*)(buf+12))+0x10;
|
|
s-=ofs;
|
|
BYTE * out=(BYTE*)malloc(s);
|
|
if (!out) return 0;
|
|
mf->size=s;
|
|
memcpy(out,buf+ofs,s);
|
|
mf->data=out;
|
|
return 1;
|
|
}
|
|
|
|
#ifdef MF_USE_DMCRAP
|
|
void ReleaseObject(IUnknown* o);
|
|
#endif
|
|
|
|
static bool load_rmi(MIDI_file* mf,const BYTE* source,size_t source_size)
|
|
{
|
|
if (source_size < 8)
|
|
return 0;
|
|
|
|
unsigned int sx=*(DWORD*)(source+4);
|
|
size_t _p=0;
|
|
BYTE * out;
|
|
if (sx>source_size-8) goto _er;
|
|
mf->size=*(DWORD*)(source+16);
|
|
if (mf->size+20>source_size) goto _er;
|
|
out=(BYTE*)malloc(mf->size);
|
|
if (!out) goto _er;
|
|
memcpy(out,source+20,mf->size);
|
|
mf->data = out;
|
|
|
|
_p=20+mf->size;
|
|
if (_p&1) _p++;
|
|
while(_p<source_size)
|
|
{
|
|
if (! mf->bmp_data && *(DWORD*)(source+_p)==_rv('DISP') && *(DWORD*)(source+_p+8)==8)//bitmap
|
|
{
|
|
DWORD s=*(DWORD*)(source+_p+4)-4;
|
|
void * r=malloc(s);
|
|
if (r)
|
|
{
|
|
memcpy(r,source+_p+12,s);
|
|
mf->bmp_size=s;
|
|
mf->bmp_data=r;
|
|
}
|
|
}
|
|
else if (! mf->title && *(DWORD*)(source+_p)==_rv('DISP') && *(DWORD*)(source+_p+8)==1)
|
|
{
|
|
DWORD s=*(DWORD*)(source+_p+4)-4;
|
|
char * src=(char*)(source+_p+12); //remove eol's
|
|
char * dst=mf->title.buffer_get(s+1);
|
|
char * src_b=src;
|
|
while(src && *src && (UINT)(src-src_b)<s)
|
|
{
|
|
if (*src!=10 && *src!=13) *(dst++)=*src;
|
|
src++;
|
|
}
|
|
*dst=0;
|
|
mf->title.buffer_done();
|
|
}
|
|
else if (! mf->rmi_data && *(DWORD*)(source+_p)==_rv('LIST') && *(DWORD*)(source+_p+8)==_rv('INFO'))
|
|
{
|
|
DWORD s=*(DWORD*)(source+_p+4);
|
|
void * r=malloc(s);
|
|
if (r)
|
|
{
|
|
memcpy(r,source+_p+8,s);
|
|
mf->rmi_size=s;
|
|
mf->rmi_data=r;
|
|
}
|
|
}
|
|
#ifdef MF_USE_DMCRAP
|
|
else if (!mf->pDLSdata && *(DWORD*)(source+_p)==_rv('RIFF') && *(DWORD*)(source+_p+8)==_rv('DLS '))
|
|
{
|
|
int rs=*(long*)(source+_p+4)+8;
|
|
if (rs+_p>source_size) break;
|
|
|
|
mf->DLSsize=rs;
|
|
mf->pDLSdata=(BYTE*)malloc(rs);
|
|
memcpy(mf->pDLSdata,source+_p,rs);
|
|
|
|
}
|
|
#endif
|
|
_p+=*(DWORD*)(source+_p+4)+8;
|
|
if (_p&1) _p++;
|
|
}
|
|
return 1;
|
|
_er:
|
|
return 0;
|
|
}
|
|
|
|
bool load_xmi(MIDI_file* mf,const BYTE*,size_t);
|
|
bool load_hmp(MIDI_file* mf,const BYTE*,size_t);
|
|
bool load_hmi(MIDI_file* mf,const BYTE*,size_t);
|
|
bool load_mus(MIDI_file* mf,const BYTE*,size_t);
|
|
bool load_cmf(MIDI_file* mf,const BYTE*,size_t);
|
|
bool load_mids(MIDI_file* mf,const BYTE*,size_t);
|
|
bool load_gmf(MIDI_file* mf,const BYTE*,size_t);
|
|
bool is_mus(const BYTE*,size_t);
|
|
bool is_cmf(const BYTE*,size_t);
|
|
bool is_mids(const BYTE*,size_t);
|
|
bool is_gmf(const BYTE*,size_t);
|
|
|
|
static bool load_midi_scan(MIDI_file* mf,const BYTE* ptr,size_t size)
|
|
{
|
|
int max = size-3;
|
|
if (max>256) max=256;
|
|
int x;
|
|
for(x=0;x<256;x++)
|
|
{
|
|
if (*(DWORD*)(ptr+x)==_rv('MThd') && *(DWORD*)(ptr+x+4)==_rv(6))
|
|
{
|
|
size-=x;
|
|
ptr+=x;
|
|
void * buf=malloc(size);
|
|
if (!buf) return 0;
|
|
memcpy(buf,ptr,size);
|
|
bool r=load_midi(mf,(BYTE*)buf,size);
|
|
if (!r) free(buf);
|
|
return r;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
struct
|
|
{
|
|
bool ( * test ) (const BYTE* b,size_t s);
|
|
bool ( * load ) (MIDI_file* mf,const BYTE* ptr,size_t size);
|
|
} format_list[] =
|
|
{
|
|
{is_midi,load_midi},
|
|
{is_rmi,load_rmi},
|
|
{is_hmp,load_hmp},
|
|
{is_hmi,load_hmi},
|
|
{is_xmidi,load_xmi},
|
|
{is_mus,load_mus},
|
|
{is_cmf,load_cmf},
|
|
{is_gmd,load_gmd},
|
|
{is_mids,load_mids},
|
|
{is_gmf,load_gmf},
|
|
{is_midi_scan,load_midi_scan}
|
|
};
|
|
|
|
//static fmtfunc fmts[]={is_midi,is_rmi,is_hmp,is_hmi,is_xmidi,is_mus,is_cmf,is_gmd,is_mids,is_gmf,is_midi_scan};
|
|
//loadfunc loaders[]={load_midi,load_rmi,load_hmp,load_hmi,load_xmi,load_mus,load_cmf,load_gmd,load_mids,load_gmf,load_midi_scan};
|
|
|
|
#ifdef MF_USE_DMCRAP
|
|
void LoadDLS(MIDI_file* mf)
|
|
{
|
|
if (mf->pDLSdata && ! mf->pDLS)
|
|
{
|
|
DMUS_OBJECTDESC ObjDesc;
|
|
ZeroMemory(&ObjDesc,sizeof(ObjDesc));
|
|
ObjDesc.dwSize = sizeof(DMUS_OBJECTDESC);
|
|
ObjDesc.dwValidData = DMUS_OBJ_CLASS | DMUS_OBJ_MEMORY;
|
|
ObjDesc.llMemLength = mf->DLSsize;
|
|
ObjDesc.pbMemData = mf->pDLSdata;
|
|
ObjDesc.guidClass = CLSID_DirectMusicCollection;
|
|
|
|
pLoader->GetObject(&ObjDesc,IID_IDirectMusicCollection,(void**)&mf->pDLS);
|
|
if (mf->pDLS)
|
|
{
|
|
ReleaseObject(mf->pDLS);
|
|
}
|
|
}
|
|
}
|
|
|
|
void _LoadSegment(MIDI_file* mf)
|
|
{
|
|
#ifdef USE_LOG
|
|
log_write("_LoadSegment()");
|
|
#endif
|
|
mf->pSeg=0;
|
|
int data_size=0;
|
|
void * data_ptr=0;
|
|
|
|
|
|
if (
|
|
!DoCleanUp(mf,CLEAN_DM|CLEAN_DLS|(cfg_nosysex ? CLEAN_NOSYSEX : 0),&data_ptr,&data_size)
|
|
)
|
|
return;
|
|
|
|
|
|
IDirectMusicSegment* pSeg=0;
|
|
DMUS_OBJECTDESC ObjDesc;
|
|
ZeroMemory(&ObjDesc,sizeof(ObjDesc));
|
|
ObjDesc.dwSize=sizeof(ObjDesc);
|
|
ObjDesc.dwValidData = DMUS_OBJ_CLASS | DMUS_OBJ_MEMORY;
|
|
ObjDesc.llMemLength = data_size;
|
|
ObjDesc.pbMemData = (BYTE*)data_ptr;
|
|
ObjDesc.guidClass=CLSID_DirectMusicSegment;
|
|
#ifdef USE_LOG
|
|
log_write("pLoader->EnableCache(GUID_DirectMusicAllTypes,1);");
|
|
#endif
|
|
pLoader->EnableCache(GUID_DirectMusicAllTypes,1);
|
|
// pLoader->ClearCache(CLSID_DirectMusicSegment); //%$%&%@! this->sucks = TRUE
|
|
#ifdef USE_LOG
|
|
log_write("pLoader->GetObject(&ObjDesc,IID_IDirectMusicSegment,(void**)&pSeg);");
|
|
#endif
|
|
pLoader->GetObject(&ObjDesc,IID_IDirectMusicSegment,(void**)&pSeg);
|
|
|
|
if (!pSeg)
|
|
{
|
|
#ifdef USE_LOG
|
|
log_write("attempting memdump");
|
|
#endif
|
|
char tmpf[MAX_PATH] = {0};
|
|
get_temp_file(tmpf);
|
|
HANDLE f=CreateFileA(tmpf,GENERIC_WRITE,0,0,CREATE_ALWAYS,0,0);
|
|
if (f!=INVALID_HANDLE_VALUE)
|
|
{
|
|
DWORD bw = 0;
|
|
WriteFile(f,data_ptr,data_size,&bw,0);
|
|
CloseHandle(f);
|
|
mbstowcs(ObjDesc.wszFileName,tmpf,MAX_PATH);
|
|
ObjDesc.dwValidData = DMUS_OBJ_CLASS | DMUS_OBJ_FULLPATH | DMUS_OBJ_FILENAME;
|
|
pLoader->GetObject(&ObjDesc,IID_IDirectMusicSegment,(void**)&pSeg);
|
|
DeleteFileA(tmpf);
|
|
}
|
|
}
|
|
if (pSeg)
|
|
{
|
|
#ifdef USE_LOG
|
|
log_write("got IDirectMusicSegment");
|
|
log_write("pSeg->SetParam(GUID_StandardMIDIFile,-1,0,0,0);");
|
|
#endif
|
|
pSeg->SetParam(GUID_StandardMIDIFile,-1,0,0,0);
|
|
#ifdef USE_LOG
|
|
log_write("pSeg->SetStartPoint(0);");
|
|
#endif
|
|
pSeg->SetStartPoint(0);
|
|
#ifdef USE_LOG
|
|
log_write("pSeg->SetLength();");
|
|
#endif
|
|
{
|
|
bool ok=0;
|
|
if (cfg_eof_delay)
|
|
{
|
|
MUSIC_TIME mnt;
|
|
DMUS_TEMPO_PARAM tp;
|
|
if (SUCCEEDED(pSeg->GetParam(GUID_TempoParam,-1,0,mf->tix,&mnt,&tp)))
|
|
{
|
|
pSeg->SetLength((MUSIC_TIME)(mf->tix+(double)cfg_eof_delay*78.0/tp.dblTempo));
|
|
ok=1;
|
|
}
|
|
}
|
|
if (!ok) pSeg->SetLength(mf->tix);
|
|
}
|
|
|
|
mf->pSeg=pSeg;
|
|
|
|
LoadDLS(mf);
|
|
|
|
if (pCDLS) pSeg->SetParam(GUID_ConnectToDLSCollection,0xFFFFFFFF,0,0,(void*)pCDLS);
|
|
if (mf->pDLS) pSeg->SetParam(GUID_ConnectToDLSCollection,0xFFFFFFFF,0,0,(void*)mf->pDLS);
|
|
|
|
if (mf->loopstart)
|
|
{
|
|
pSeg->SetLoopPoints(mf->loopstart,mf->loopend);
|
|
}
|
|
}
|
|
free(data_ptr);
|
|
pLoader->EnableCache(GUID_DirectMusicAllTypes,0);
|
|
}
|
|
|
|
IDirectMusicSegment* LoadSegment(MIDI_file* mf)
|
|
{
|
|
#ifdef USE_LOG
|
|
log_write("LoadSegment()");
|
|
#endif
|
|
if (!pLoader) return 0;
|
|
IDirectMusicSegment* pSeg=0;
|
|
if (!mf->pSeg) _LoadSegment(mf);
|
|
if (mf->pSeg)
|
|
{
|
|
#ifdef USE_LOG
|
|
log_write("LoadSegment() : got IDirectMusicSegment");
|
|
#endif
|
|
pSeg=mf->pSeg;
|
|
#ifdef USE_LOG
|
|
log_write("pSeg->AddRef()");
|
|
#endif
|
|
pSeg->AddRef();
|
|
#ifdef USE_LOG
|
|
log_write("pSeg->AddRef() returned");
|
|
#endif
|
|
}
|
|
#ifdef USE_LOG
|
|
log_write("LoadSegment() returning");
|
|
#endif
|
|
return pSeg;
|
|
}
|
|
#endif
|
|
|
|
MIDI_file::~MIDI_file()
|
|
{
|
|
#ifdef MF_USE_DMCRAP
|
|
if (pSeg) pSeg->Release();
|
|
if (pDLS) pDLS->Release();
|
|
if (pDLSdata) free(pDLSdata);
|
|
#endif
|
|
if (data) free((BYTE*)data);
|
|
if (tmap) delete tmap;
|
|
if (smap) delete smap;
|
|
if (info.traxnames) delete[] info.traxnames;
|
|
if (rmi_data) free(rmi_data);
|
|
if (bmp_data) free(bmp_data);
|
|
#ifdef HUNT_LEAKS
|
|
n_files--;
|
|
#endif
|
|
}
|
|
|
|
bool GetMidiInfo(MIDI_file*);
|
|
|
|
static bool try_format(const void * data,int size,int idx)
|
|
{
|
|
bool rv;
|
|
try {
|
|
rv = format_list[idx].test((const BYTE*)data,size);
|
|
} catch(...)
|
|
{
|
|
rv = 0;
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
int MIDI_file::HeaderTest(const void * data,int size)
|
|
{
|
|
int n;
|
|
for(n=0;n<tabsize(format_list);n++)
|
|
{
|
|
if (try_format(data,size,n)) return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int MIDI_file::Load(const void * data,int size)
|
|
{
|
|
#ifdef USE_LOG
|
|
log_write("Load()");
|
|
#endif
|
|
|
|
{
|
|
int n;
|
|
int fmt=-1;
|
|
for(n=0;n<tabsize(format_list);n++)
|
|
{
|
|
if (try_format(data,size,n)) {fmt=n;break;}
|
|
}
|
|
if (fmt==-1) return 0;
|
|
format = fmt;
|
|
}
|
|
|
|
|
|
|
|
{
|
|
bool r;
|
|
try {
|
|
r=format_list[format].load(this,(const BYTE*)data,size);
|
|
} catch(...) {
|
|
#ifdef USE_LOG
|
|
log_write("midi loader crashed");
|
|
#endif
|
|
r=0;
|
|
}
|
|
if (!r) return 0;
|
|
}
|
|
|
|
return GetMidiInfo(this);
|
|
}
|
|
|
|
MIDI_file* MIDI_file::Create(const char* fn,const void * data, size_t size)
|
|
{
|
|
MIDI_file* mf=new MIDI_file(fn);
|
|
if (!mf->Load(data,size))
|
|
{
|
|
delete mf;
|
|
mf=0;
|
|
}
|
|
return mf;
|
|
} |