//************************************************************************
BOOL CDib::LoadFromResource(HINSTANCE hInstance, LPCSTR szResource, BOOL fDecodeRLE)
//************************************************************************
{
HRSRC hDibRes;
HGLOBAL hDib;
LPTR lpDib;
LPBITMAPINFO lpbmInfo;
DWORD dwBits;
if ( !(hDibRes = FindResource(hInstance, szResource, RT_BITMAP)) )
return(FALSE);
if (! (hDib = LoadResource(hInstance, hDibRes)) )
return(FALSE);
lpDib = (LPTR)LockResource(hDib);
if (!lpDib)
return(FALSE);
lpbmInfo = (LPBITMAPINFO)lpDib;
m_bmiHeader = lpbmInfo->bmiHeader;
FixHeader();
hmemcpy(m_rgbQuad, lpbmInfo->bmiColors, GetNumColors() * sizeof(RGBQUAD));
lpDib += m_bmiHeader.biSize + (GetNumColors() * sizeof(RGBQUAD));
// Can we get enough memory to hold the DIB bits
if ( (m_lp = AllocX( dwBits = GetSizeImage(), GMEM_ZEROINIT )) != NULL )
hmemcpy(m_lp, lpDib, dwBits);
UnlockResource(hDib);
FreeResource(hDib);
return(CheckDecodeRLE(fDecodeRLE));
}
BOOL8 STRING::operator!=(const STRING& str) const {
FixHeader();
str.FixHeader();
const STRING_HEADER* str_header = str.GetHeader();
const STRING_HEADER* this_header = GetHeader();
int this_used = this_header->used_;
int str_used = str_header->used_;
return (this_used != str_used)
|| (memcmp(GetCStr(), str.GetCStr(), this_used) != 0);
}
BOOL8 STRING::operator!=(const char* cstr) const {
FixHeader();
const STRING_HEADER* this_header = GetHeader();
if (cstr == NULL)
return this_header->used_ > 1; // either '\0' or NULL
else {
inT32 length = strlen(cstr) + 1;
return (this_header->used_ != length)
|| (memcmp(GetCStr(), cstr, length) != 0);
}
}
//buf = HMP image, br = HMP image size, out_size = output MIDI image size
extern "C" void* load_hmp(BYTE* buf,DWORD br,DWORD* out_size)
{
MIDIHEADER mhd = {1,0,0xC0};
BYTE * max = buf+br;
BYTE* ptr = buf;
CWriteBuf* dst=wb_create();
DWORD n1,n2;
dst->writedword(_rv('MThd'));
dst->writedword(_rv(6));
dst->write(0,sizeof(mhd));
ptr = buf+0x30;
mhd.trax = *ptr;
dst->write(hmp_track0,sizeof(hmp_track0));
while(*(WORD*)ptr != 0x2FFF && ptr < max - 4-7) ptr++;
ptr+=7;
if (ptr == max-4) { dst->freebuf(); delete dst; return 0; }
UINT n;
for(n=1;n<mhd.trax;n++)
{
dst->writedword(_rv('MTrk'));
n1 = *(DWORD*)ptr - 12;
if (ptr + n1 > max) { dst->freebuf(); delete dst; return 0; }
ptr += 8;
UINT ts_ofs=dst->get_offs();
dst->writedword(0);
if (!(n2=ProcessTrack(ptr,dst,n1)))
{ dst->freebuf(); delete dst; return 0; }
dst->writedwordoffs(_rv(n2),ts_ofs);
ptr += n1 + 4;
}
FixHeader(mhd);
dst->writeoffs(&mhd,sizeof(mhd),8);
UINT f_sz;
BYTE* r=(BYTE*)dst->finish(&f_sz);
delete dst;
if (r)
{
if (out_size) *out_size=f_sz;
return r;
}
else
{
return 0;
}
}
STRING STRING::operator+(const char ch) const {
STRING result;
FixHeader();
const STRING_HEADER* this_header = GetHeader();
int this_used = this_header->used_;
char* result_cstr = result.ensure_cstr(this_used + 1);
STRING_HEADER* result_header = result.GetHeader();
int result_used = result_header->used_;
// copies '\0' but we'll overwrite that
memcpy(result_cstr, GetCStr(), this_used);
result_cstr[result_used] = ch; // overwrite old '\0'
result_cstr[result_used + 1] = '\0'; // append on '\0'
++result_header->used_;
assert(InvariantOk());
return result;
}
STRING& STRING::operator+=(const char ch) {
if (ch == '\0')
return *this;
FixHeader();
int this_used = GetHeader()->used_;
char* this_cstr = ensure_cstr(this_used + 1);
STRING_HEADER* this_header = GetHeader();
if (this_used > 0)
--this_used; // undo old empty null if there was one
this_cstr[this_used++] = ch; // append ch to end
this_cstr[this_used++] = '\0'; // append '\0' after ch
this_header->used_ = this_used;
assert(InvariantOk());
return *this;
}
STRING & STRING::operator+=(const STRING& str) {
FixHeader();
str.FixHeader();
const STRING_HEADER* str_header = str.GetHeader();
const char* str_cstr = str.GetCStr();
int str_used = str_header->used_;
int this_used = GetHeader()->used_;
char* this_cstr = ensure_cstr(this_used + str_used);
STRING_HEADER* this_header = GetHeader(); // after ensure for realloc
if (this_used > 1) {
memcpy(this_cstr + this_used - 1, str_cstr, str_used);
this_header->used_ += str_used - 1; // overwrite '\0'
} else {
memcpy(this_cstr, str_cstr, str_used);
this_header->used_ = str_used;
}
assert(InvariantOk());
return *this;
}
STRING& STRING::operator+=(const char *str) {
if (!str || !*str) // empty string has no effect
return *this;
FixHeader();
int len = strlen(str) + 1;
int this_used = GetHeader()->used_;
char* this_cstr = ensure_cstr(this_used + len);
STRING_HEADER* this_header = GetHeader(); // after ensure for realloc
// if we had non-empty string then append overwriting old '\0'
// otherwise replace
if (this_used > 0) {
memcpy(this_cstr + this_used - 1, str, len);
this_header->used_ += len - 1;
} else {
memcpy(this_cstr, str, len);
this_header->used_ = len;
}
assert(InvariantOk());
return *this;
}
int main(int argc, char **argv)
{
FILE *outfile = NULL;
char *tempname = NULL;
int j=0;
if(argc!=3)
{
printf("usage: %s infolder outpack\n",argv[0]);
return 0;
}
outfile = fopen(argv[2],"wb");
tempname = (char*)calloc(strlen(argv[1])+4,sizeof(char));
sprintf(tempname,"%s\\*",argv[1]);
parsedir(tempname);
FixHeader();
WriteHeader(outfile);
chdir(argv[1]);
WriteFiles(outfile);
chdir("..");
free(tempname);
while((ftell(outfile)%4)!=0)
{
fwrite(&pad[j],1,1,outfile);
j = 1-j;
}
fclose(outfile);
return 0;
}
//************************************************************************
BOOL CDib::Create( int bits, int dx, int dy )
//************************************************************************
{
DWORD dwSizeImage;
int i;
LPDWORD pdw;
dwSizeImage = dy * (DWORD)((dx * bits/8+3)&~3);
if ( !(m_lp = AllocX( dwSizeImage + 1024, GMEM_ZEROINIT )) )
{
return FALSE;
}
#ifdef UNUSED // We can't use this because of a problem noted in DibToDCBlt()
// Get WinG to recommend the fastest DIB format
// Orientation = ( m_bmiHeader.biHeight < 0 ? -1 : 1 );
if ( WinGRecommendDIBFormat( (LPBITMAPINFO)&m_bmiHeader ) )
{ // make sure it's 8bpp
m_bmiHeader.biWidth *= dx;
m_bmiHeader.biHeight *= dy;
m_bmiHeader.biBitCount = bits;
m_bmiHeader.biCompression = BI_RGB;
}
else
#endif
{ // set it up ourselves
m_bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
m_bmiHeader.biPlanes = 1;
m_bmiHeader.biSizeImage = dwSizeImage;
m_bmiHeader.biXPelsPerMeter = 0 ;
m_bmiHeader.biYPelsPerMeter = 0 ;
m_bmiHeader.biClrUsed = 0 ;
m_bmiHeader.biClrImportant = 0 ;
m_bmiHeader.biWidth = dx;
m_bmiHeader.biHeight = dy;
m_bmiHeader.biBitCount = bits;
m_bmiHeader.biCompression = BI_RGB;
}
if (bits == 4)
m_bmiHeader.biClrUsed = 16;
else
if (bits == 8)
m_bmiHeader.biClrUsed = 256;
pdw = (LPDWORD)m_rgbQuad;
for (i=0; i<(int)m_bmiHeader.biClrUsed/16; i++)
{
*pdw++ = 0x00000000; // 0000 black
*pdw++ = 0x00800000; // 0001 dark red
*pdw++ = 0x00008000; // 0010 dark green
*pdw++ = 0x00808000; // 0011 mustard
*pdw++ = 0x00000080; // 0100 dark blue
*pdw++ = 0x00800080; // 0101 purple
*pdw++ = 0x00008080; // 0110 dark turquoise
*pdw++ = 0x00C0C0C0; // 1000 gray
*pdw++ = 0x00808080; // 0111 dark gray
*pdw++ = 0x00FF0000; // 1001 red
*pdw++ = 0x0000FF00; // 1010 green
*pdw++ = 0x00FFFF00; // 1011 yellow
*pdw++ = 0x000000FF; // 1100 blue
*pdw++ = 0x00FF00FF; // 1101 pink (magenta)
*pdw++ = 0x0000FFFF; // 1110 cyan
*pdw++ = 0x00FFFFFF; // 1111 white
}
FixHeader();
return TRUE;
}
// Will read a file in DIB format and return a global HANDLE to its
// BITMAPINFO. This function will work with both "old" and "new"
// bitmap formats, but will always return a "new" BITMAPINFO
//************************************************************************
BOOL CDib::ReadBitmapInfo( HFILE fh )
//************************************************************************
{
DWORD off, size;
HANDLE hbi = NULL;
int i, nNumColors;
LPRGBQUAD pRgb;
BITMAPINFOHEADER bi;
BITMAPCOREHEADER bc;
BITMAPFILEHEADER bf;
if ( fh < 0 )
return FALSE;
off = _llseek(fh,0L,SEEK_CUR);
if (sizeof(bf) != _lread(fh,(LPSTR)&bf,sizeof(bf)))
return FALSE;
// do we have a RC HEADER?
if (bf.bfType != BFT_BITMAP)
{
bf.bfOffBits = 0L;
_llseek(fh,off,SEEK_SET);
}
if (sizeof(bi) != _lread(fh,(LPSTR)&bi,sizeof(bi)))
return FALSE;
// what type of bitmap info is this?
if ( (size = bi.biSize) == sizeof(BITMAPCOREHEADER) )
{
bc = *(LPBITMAPCOREHEADER)&bi;
bi.biSize = sizeof(BITMAPINFOHEADER);
bi.biWidth = (DWORD)bc.bcWidth;
bi.biHeight = (DWORD)bc.bcHeight;
bi.biPlanes = (UINT)bc.bcPlanes;
bi.biBitCount = (UINT)bc.bcBitCount;
bi.biCompression = BI_RGB;
bi.biSizeImage = 0;
bi.biXPelsPerMeter = 0;
bi.biYPelsPerMeter = 0;
bi.biClrUsed = 0;
bi.biClrImportant = 0;
_llseek(fh,(long)sizeof(BITMAPCOREHEADER)-sizeof(BITMAPINFOHEADER),SEEK_CUR);
}
//!!! hack for BI_BITFIELDS
if ( bi.biCompression == BI_BITFIELDS && !bi.biClrUsed )
bi.biClrUsed = 3;
// Copy in the bitmap info header
m_bmiHeader = bi;
FixHeader();
nNumColors = GetNumColors();
pRgb = GetColors();
if (nNumColors)
{
if (size == sizeof(BITMAPCOREHEADER))
{
// convert old color table (3 byte entries) to new (4 byte entries)
_lread(fh,(LPVOID)pRgb,nNumColors * sizeof(RGBTRIPLE));
for (i=nNumColors-1; i>=0; i--)
{
RGBQUAD rgb;
rgb.rgbRed = ((LPRGBTRIPLE)pRgb)[i].rgbtRed;
rgb.rgbBlue = ((LPRGBTRIPLE)pRgb)[i].rgbtBlue;
rgb.rgbGreen = ((LPRGBTRIPLE)pRgb)[i].rgbtGreen;
rgb.rgbReserved = (BYTE)0;
pRgb[i] = rgb;
}
}
else
{
_lread(fh,(LPVOID)pRgb,nNumColors * sizeof(RGBQUAD));
}
}
if (bf.bfOffBits)
_llseek(fh,off + bf.bfOffBits,SEEK_SET);
return TRUE;
}
inT32 STRING::length() const {
FixHeader();
return GetHeader()->used_ - 1;
}
