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/midifile.cpp

603 lines
12 KiB
C++
Raw Blame History

#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;
}
Reference in New Issue View Git Blame Copy Permalink