150 lines
2.8 KiB
C++
150 lines
2.8 KiB
C++
#include "main.h"
|
|
#include "cvt.h"
|
|
#include <intsafe.h>
|
|
|
|
#define _MThd 'dhTM'
|
|
#define _MTrk 'krTM'
|
|
|
|
static DWORD ProcessTrack(const BYTE* track,grow_buf & out,int size)
|
|
{
|
|
UINT s_sz=out.get_size();
|
|
const BYTE *pt = track;
|
|
BYTE lc1 = 0,lastcom = 0;
|
|
DWORD t=0,d;
|
|
bool run = 0;
|
|
int n1,n2;
|
|
while(track < pt + size)
|
|
{
|
|
if (track[0]&0x80)
|
|
{
|
|
BYTE b=track[0]&0x7F;
|
|
out.write_byte(b);
|
|
t+=b;
|
|
}
|
|
else
|
|
{
|
|
d = (track[0])&0x7F;
|
|
n1 = 0;
|
|
while((track[n1]&0x80)==0)
|
|
{
|
|
n1++;
|
|
d+=(track[n1]&0x7F)<<(n1*7);
|
|
}
|
|
t+=d;
|
|
|
|
n1 = 1;
|
|
while((track[n1]&0x80)==0)
|
|
{
|
|
n1++;
|
|
if (n1==4) return 0;
|
|
}
|
|
for(n2=0;n2<=n1;n2++)
|
|
{
|
|
BYTE b=track[n1-n2]&0x7F;
|
|
|
|
if (n2!=n1) b|=0x80;
|
|
out.write_byte(b);
|
|
}
|
|
track+=n1;
|
|
}
|
|
track++;
|
|
if (*track == 0xFF)//meta
|
|
{
|
|
unsigned int _d;
|
|
UINT s=DecodeDelta(track+2,&_d);
|
|
UINT result;
|
|
if (UIntAdd(2, s, &result) || UIntAdd(result, _d, &result) == S_OK || !out.write(track,result))
|
|
return 0;
|
|
if (track[1]==0x2F) break;
|
|
}
|
|
else
|
|
{
|
|
lc1=track[0];
|
|
if ((lc1&0x80) == 0) return 0;
|
|
switch(lc1&0xF0)
|
|
{
|
|
case 0x80:
|
|
case 0x90:
|
|
case 0xA0:
|
|
case 0xB0:
|
|
case 0xE0:
|
|
if (lc1!=lastcom)
|
|
{
|
|
out.write_byte(lc1);
|
|
}
|
|
out.write(track+1,2);
|
|
track+=3;
|
|
break;
|
|
case 0xC0:
|
|
case 0xD0:
|
|
if (lc1!=lastcom)
|
|
{
|
|
out.write_byte(lc1);
|
|
}
|
|
out.write_byte(track[1]);
|
|
track+=2;
|
|
break;
|
|
default:
|
|
return 0;
|
|
}
|
|
lastcom=lc1;
|
|
}
|
|
}
|
|
return out.get_size()-s_sz;
|
|
}
|
|
|
|
#define FixHeader(H) {(H).fmt=rev16((H).fmt);(H).trax=rev16((H).trax);(H).dtx=rev16((H).dtx);}
|
|
|
|
BYTE hmp_track0[19]={'M','T','r','k',0,0,0,11,0,0xFF,0x51,0x03,0x18,0x80,0x00,0,0xFF,0x2F,0};
|
|
|
|
bool load_hmp(MIDI_file* mf,const BYTE* buf, size_t br)
|
|
{
|
|
MIDIHEADER mhd = {1,0,0xC0};
|
|
const BYTE * max = buf+br;
|
|
const BYTE* ptr = buf;
|
|
BOOL funky=0;
|
|
if (!memcmp(buf,"HMIMIDIR",8)) funky=1;
|
|
grow_buf dst;
|
|
DWORD n1,n2;
|
|
dst.write_dword(_rv('MThd'));
|
|
dst.write_dword(_rv(6));
|
|
dst.write(0,sizeof(mhd));
|
|
ptr = buf+(funky ? 0x1a: 0x30);
|
|
mhd.trax = *ptr;
|
|
if (funky) mhd.dtx=rev16(*(WORD*)(buf+0x4c))/6;
|
|
dst.write(hmp_track0,sizeof(hmp_track0));
|
|
|
|
while(*(WORD*)ptr != 0x2FFF && ptr < max - 4-7) ptr++;
|
|
ptr+=funky ? 5 : 7;
|
|
if (ptr == max-4) return 0;
|
|
UINT n;
|
|
|
|
|
|
for(n=1;n<mhd.trax;n++)
|
|
{
|
|
n1 = funky ? *(WORD*)ptr : *(DWORD*)ptr - 12;
|
|
if (ptr + n1 > max)
|
|
{
|
|
mhd.trax=n;
|
|
break;
|
|
}
|
|
dst.write_dword(_rv('MTrk'));
|
|
if (!funky) ptr += 8;
|
|
|
|
UINT ts_ofs=dst.get_size();
|
|
dst.write_dword(0);
|
|
if (!(n2=ProcessTrack(funky ? ptr+4 : ptr,dst,n1))) return 0;
|
|
|
|
dst.write_dword_ptr(rev32(n2),ts_ofs);
|
|
if (funky) ptr+=n1;
|
|
else ptr += n1 + 4;
|
|
}
|
|
FixHeader(mhd);
|
|
dst.write_ptr(&mhd,sizeof(mhd),8);
|
|
|
|
|
|
mf->size = dst.get_size();
|
|
mf->data = (BYTE*)dst.finish();
|
|
return !!mf->data;
|
|
}
|