int WaveFile_Open(WaveFile* This, String* Sorc)
{
int OpenStatus = File_Open(WStream, Sorc, READONLY);
if(! OpenStatus)
return 0;
char RIFFChars[5];
char WAVEChars[5];
char FACTChars[5];
RIFFChars[4] = 0;
WAVEChars[4] = 0;
FACTChars[4] = 0;
File_Read_Buffer(WStream, RIFFChars, 4); //RIFF
File_Read_Int(WStream); //Size
File_Read_Buffer(WStream, WAVEChars, 4); //WAVE
if(strcmp(RIFFChars, "RIFF"))
return 0;
if(strcmp(WAVEChars, "WAVE"))
return 0;
File_Read_Int32(WStream); //fmt
int fmtSize = File_Read_Int32(WStream);
File_Read_Int16(WStream); //FormatTag
Header.Channel = File_Read_Int16(WStream);
Header.SamplePerSecond = File_Read_Int32(WStream);
Header.BytePerSecond = File_Read_Int32(WStream);
Header.BlockAlign = File_Read_Int16(WStream);
Header.BitPerSample = File_Read_Int16(WStream);
if(fmtSize == 16)
{
//No extra info
}else
File_Read_Int16(WStream); //Extra info
File_Read_Buffer(WStream, FACTChars, 4);
if(! strcmp(FACTChars, "fact"))
{
int factSize = File_Read_Int32(WStream);
File_SetPosition(WStream, File_GetPosition(WStream) + factSize + 4);
}
Header.DataSize = File_Read_Int32(WStream);
Header.DataPosition = File_GetPosition(WStream);
Header.BytePerSample = Header.BitPerSample / 8;
Header.DataNum = Header.DataSize / Header.BytePerSample / Header.Channel;
return 1;
}
int WaveFile_Save(WaveFile* This, String* Dest)
{
int SaveStatus = File_Open(WStream, Dest, CREATE);
if(! SaveStatus)
return 0;
File_Write_Buffer(WStream, "RIFF", 4);
File_Write_Int32(WStream, 0); //Size = 0 by default
File_Write_Buffer(WStream, "WAVE", 4);
File_Write_Buffer(WStream, "fmt ", 4);
File_Write_Int32(WStream, 16); //No extra
File_Write_Int16(WStream, 1); //FormatTag = 0x0001
File_Write_Int16(WStream, Header.Channel);
File_Write_Int32(WStream, Header.SamplePerSecond);
File_Write_Int32(WStream, Header.BytePerSecond);
File_Write_Int16(WStream, Header.BlockAlign);
File_Write_Int16(WStream, Header.BitPerSample);
File_Write_Buffer(WStream, "data", 4);
File_Write_Int32(WStream, 0); //DataSize = 0 by default
This -> WritePosition = File_GetPosition(WStream);
This -> WriteCounter = 0;
Header.BytePerSample = Header.BitPerSample / 8;
return 1;
}
void WaveFile_FinishWrite(WaveFile* This)
{
int FileSize = File_GetPosition(WStream);
File_SetPosition(WStream, 4); //Size
File_Write_Int32(WStream, FileSize - 8);
int DataSize =
This -> WriteCounter * Header.Channel * Header.BitPerSample / 8;
File_SetPosition(WStream, This -> WritePosition - 4); //dataSize
File_Write_Int32(WStream, DataSize);
File_Flush(WStream);
File_Close(WStream);
}
static void ParseLabelFile(File* Sorc, int SampleRate)
{
int Size = File_GetLength(Sorc) - 1;
String Temp;
String_Ctor(& Temp);
while(File_GetPosition(Sorc) < Size)
{
double Pos;
File_ReadWord(Sorc, & Temp);
Pos = CDoubleStr(& Temp);
Array_Push(int, SegList, (int)(Pos * SampleRate));
//Trash
File_ReadLine(Sorc, & Temp);
}
String_Dtor(& Temp);
}
// ---------------------------------------
// Load Image File function w. filters.
// ---------------------------------------
BOOL LoadImageFile(LPRDATA rdPtr, LPSURFACE psf, LPSTR pFileName, DWORD dwFlags)
{
BOOL bOK = FALSE;
LPRH rhPtr = rdPtr->rHo.hoAdRunHeader;
HANDLE hf = INVALID_HANDLE_VALUE;
do {
if ( pFileName == NULL || *pFileName == 0 )
break;
// Copy filename to temporary string
char fname[MAX_PATH];
strcpy(fname, pFileName);
// Open file
//
// mvOpenHFile opens the file directly from the CCN/EXE file ifthe file has been included in the embedded binary files of the application.
// If the file is not embedded, mvOpenHFile opens it from its current location (and downloads it first in Vitalize mode).
//
DWORD dwSize; // file size
hf = rhPtr->rh4.rh4Mv->mvOpenHFile(fname, &dwSize, 0);
if ( hf == INVALID_HANDLE_VALUE )
break;
// Create CInputFile
DWORD dwOff = File_GetPosition((HFILE)hf); // position of embedded file in CCN/EXE file (0 if not embedded)
CInputBufFile bf;
if ( bf.Create((HFILE)hf, dwOff, dwSize) != 0 )
break;
// Load picture
if ( ImportImageFromInputFile(rhPtr->rh4.rh4Mv->mvImgFilterMgr, &bf, psf, NULL, dwFlags) )
bOK = TRUE;
} while(FALSE);
if ( hf != INVALID_HANDLE_VALUE )
rhPtr->rh4.rh4Mv->mvCloseHFile(hf);
return bOK;
}
void LoadImageFile(LPRDATA rdPtr, LPSTR pFileName)
{
LPRH rhPtr = rdPtr->rHo.hoAdRunHeader;
HANDLE hf = INVALID_HANDLE_VALUE;
do {
if ( pFileName == NULL || *pFileName == 0 )
break;
// Copy filename to temp buffer
char fname[MAX_PATH];
strcpy(fname, pFileName);
// Get surface prototype
LPSURFACE wSurf = WinGetSurface((int)rhPtr->rhIdEditWin);
LPSURFACE proto;
GetSurfacePrototype(&proto, (wSurf != NULL) ? wSurf->GetDepth() : 24, ST_MEMORYWITHDC, SD_DIB);
if ( proto == NULL )
break;
// Ask MMF2 to open the file (opens external file and embedded files, and downloads files in Vitalize mode)
DWORD dwSize;
hf = rhPtr->rh4.rh4Mv->mvOpenHFile(fname, &dwSize, 0);
if ( hf == INVALID_HANDLE_VALUE )
break;
// Create CInpuBufFile object associated with the file handle
DWORD dwOff = File_GetPosition((HFILE)hf);
CInputBufFile bf;
if ( bf.Create((HFILE)hf, dwOff, dwSize) != 0 )
break;
// Create surface
cSurface* psf = NewSurface();
if ( psf == NULL )
break;
psf->Create(4, 4, proto);
psf->Fill(RGB(0,0,0));
if ( psf->GetDepth() == 8 )
psf->SetPalette (*wSurf);
// Load picture
CImageFilterMgr* pImgMgr = rhPtr->rh4.rh4Mv->mvImgFilterMgr;
if ( ImportImageFromInputFile(pImgMgr, &bf, psf, NULL, IMPORT_IMAGE_USESURFACEDEPTH | IMPORT_IMAGE_USESURFACEPALETTE) )
{
// Copy filename if file successfully loaded
strcpy(rdPtr->sFilename, fname);
rdPtr->nWidth = rdPtr->rHo.hoImgWidth = psf->GetWidth();
rdPtr->nHeight = rdPtr->rHo.hoImgHeight = psf->GetHeight();
// Replace picture surface
if ( rdPtr->pSf != NULL )
DeleteSurface(rdPtr->pSf);
rdPtr->pSf = psf;
// Free collision mask
FreeColMask(rdPtr);
// Set transparent color
if ( psf->GetTransparentColor() == RGB(0,0,0) )
{
COLORREF trspColor = rdPtr->dwTranspColor;
if ( (rdPtr->dwOptions & SPICTFLAGS_TRANSP_FIRSTPIXEL) != 0 )
psf->GetPixel(0,0,trspColor);
psf->SetTransparentColor(trspColor);
}
}
else
DeleteSurface(psf);
} while(FALSE);
// Close picture file (opened with mvOpenHFile)
if ( hf != INVALID_HANDLE_VALUE )
rhPtr->rh4.rh4Mv->mvCloseHFile(hf);
}
