//************************************************************************
BOOL CDib::WriteFile( LPCSTR lpFileName )
//************************************************************************
{
BITMAPFILEHEADER hdr;
HFILE fh;
OFSTRUCT of;
DWORD dwSize, dwDibSize;
if ( (fh = OpenFile( lpFileName, &of, OF_CREATE|OF_READWRITE )) < 0 )
return FALSE;
dwSize = GetSizeImage();
dwDibSize = sizeof(BITMAPINFOHEADER) + (256*sizeof(RGBQUAD));
hdr.bfType = BFT_BITMAP;
hdr.bfSize = (DWORD)sizeof(BITMAPFILEHEADER) + dwDibSize + dwSize;
hdr.bfReserved1 = 0;
hdr.bfReserved2 = 0;
hdr.bfOffBits = (DWORD)sizeof(BITMAPFILEHEADER) + dwDibSize;
_lwrite( fh, (LPCSTR)(LPVOID)&hdr, sizeof(BITMAPFILEHEADER) );
_hwrite( fh, (LPCSTR)(LPVOID)&m_bmiHeader, sizeof(m_bmiHeader) );
_hwrite( fh, (LPCSTR)(LPVOID)&m_rgbQuad, sizeof(m_rgbQuad) );
_hwrite( fh, (LPCSTR)(LPVOID)m_lp, dwSize );
_lclose( fh );
return TRUE;
}
BOOL My__hwrite()
{
HFILE hFile=NULL;
LPCSTR lpBuffer=NULL;
long lBytes=NULL;
long returnVal_Real = NULL;
long returnVal_Intercepted = NULL;
DWORD error_Real = 0;
DWORD error_Intercepted = 0;
disableInterception();
returnVal_Real = _hwrite (hFile,lpBuffer,lBytes);
error_Real = GetLastError();
enableInterception();
returnVal_Intercepted = _hwrite (hFile,lpBuffer,lBytes);
error_Intercepted = GetLastError();
return ((returnVal_Real == returnVal_Intercepted) && (error_Real == error_Intercepted));
}
/***********************************************************************
* LZCopy (KERNEL32.@)
*
* Copies everything from src to dest
* if src is a LZ compressed file, it will be uncompressed.
* will return the number of bytes written to dest or errors.
*/
LONG WINAPI LZCopy( HFILE src, HFILE dest )
{
int usedlzinit = 0, ret, wret;
LONG len;
HFILE oldsrc = src, srcfd;
FILETIME filetime;
struct lzstate *lzs;
#define BUFLEN 1000
CHAR buf[BUFLEN];
/* we need that weird typedef, for i can't seem to get function pointer
* casts right. (Or they probably just do not like WINAPI in general)
*/
typedef UINT (WINAPI *_readfun)(HFILE,LPVOID,UINT);
_readfun xread;
DPRINT("(%d,%d)\n",src,dest);
if (!IS_LZ_HANDLE(src)) {
src = LZInit(src);
if ((INT)src <= 0) return 0;
if (src != oldsrc) usedlzinit=1;
}
/* not compressed? just copy */
if (!IS_LZ_HANDLE(src))
xread=_lread;
else
xread=(_readfun)LZRead;
len=0;
while (1) {
ret=xread(src,buf,BUFLEN);
if (ret<=0) {
if (ret==0)
break;
if (ret==-1)
return LZERROR_READ;
return ret;
}
len += ret;
wret = _hwrite(dest,buf,ret);
if (wret!=ret)
return LZERROR_WRITE;
}
/* Maintain the timestamp of source file to destination file */
srcfd = (!(lzs = GET_LZ_STATE(src))) ? src : lzs->realfd;
GetFileTime( LongToHandle(srcfd), NULL, NULL, &filetime );
SetFileTime( LongToHandle(dest), NULL, NULL, &filetime );
/* close handle */
if (usedlzinit)
LZClose(src);
return len;
#undef BUFLEN
}
/******************************Public*Routine******************************\
* VcdPlyerCaptureImage
*
\**************************************************************************/
BOOL
VcdPlyerCaptureImage(
LPCSTR szFile
)
{
if(pMpegMovie)
{
BYTE* lpCurrImage = NULL;
if(pMpegMovie->GetCurrentImage(&lpCurrImage) == S_OK)
{
BITMAPFILEHEADER hdr;
HFILE fh;
OFSTRUCT of;
DWORD dwSize;
PDIB pdib = (PDIB)lpCurrImage;
fh = OpenFile(szFile,&of,OF_CREATE|OF_READWRITE);
if(fh == -1)
return FALSE;
dwSize = DibSize(pdib);
hdr.bfType = BFT_BITMAP;
hdr.bfSize = dwSize + sizeof(BITMAPFILEHEADER);
hdr.bfReserved1 = 0;
hdr.bfReserved2 = 0;
hdr.bfOffBits = (DWORD)sizeof(BITMAPFILEHEADER) + pdib->biSize +
DibPaletteSize(pdib);
_lwrite(fh,(LPCSTR)(LPVOID)&hdr,sizeof(BITMAPFILEHEADER));
_hwrite(fh,(LPCSTR)(LPVOID)pdib,dwSize);
_lclose(fh);
CoTaskMemFree(lpCurrImage);
TCHAR szText[128], szDir[MAX_PATH];
GetCurrentDirectory(MAX_PATH, szDir);
wsprintf(szText, TEXT("Captured current image to %s\\%s."), szDir, szFile);
MessageBox(hwndApp, szText, TEXT("Captured bitmap"), MB_OK);
return TRUE;
}
}
return FALSE;
}
static tsize_t
_tiffWriteProc(thandle_t fd, tdata_t buf, tsize_t size)
{
return (_hwrite(fd, buf, size));
}
/***********************************************************************
* _hwrite (KERNEL.350)
*/
LONG WINAPI _hwrite16( HFILE16 hFile, LPCSTR buffer, LONG count )
{
return _hwrite( (HFILE)DosFileHandleToWin32Handle(hFile), buffer, count );
}
/***********************************************************************
* _lwrite (KERNEL.86)
*/
UINT16 WINAPI _lwrite16( HFILE16 hFile, LPCSTR buffer, UINT16 count )
{
return (UINT16)_hwrite( (HFILE)DosFileHandleToWin32Handle(hFile), buffer, (LONG)count );
}
/**************************************************************************
* mmioDosIOProc [internal]
*/
static LRESULT CALLBACK mmioDosIOProc(LPMMIOINFO lpmmioinfo, UINT uMessage,
LPARAM lParam1, LPARAM lParam2)
{
LRESULT ret = MMSYSERR_NOERROR;
TRACE("(%p, %X, 0x%lx, 0x%lx);\n", lpmmioinfo, uMessage, lParam1, lParam2);
switch (uMessage) {
case MMIOM_OPEN:
{
/* Parameters:
* lParam1 = szFileName parameter from mmioOpen
* lParam2 = reserved
* Returns: zero on success, error code on error
* NOTE: lDiskOffset automatically set to zero
*/
LPCSTR szFileName = (LPCSTR)lParam1;
if (lpmmioinfo->dwFlags & MMIO_GETTEMP) {
FIXME("MMIO_GETTEMP not implemented\n");
return MMIOERR_CANNOTOPEN;
}
/* if filename NULL, assume open file handle in adwInfo[0] */
if (szFileName) {
OFSTRUCT ofs;
lpmmioinfo->adwInfo[0] = (DWORD)OpenFile(szFileName, &ofs, lpmmioinfo->dwFlags & 0xFFFF);
}
if (lpmmioinfo->adwInfo[0] == (DWORD)HFILE_ERROR)
ret = MMIOERR_CANNOTOPEN;
}
break;
case MMIOM_CLOSE:
/* Parameters:
* lParam1 = wFlags parameter from mmioClose
* lParam2 = unused
* Returns: zero on success, error code on error
*/
if (!(lParam1 & MMIO_FHOPEN))
_lclose((HFILE)lpmmioinfo->adwInfo[0]);
break;
case MMIOM_READ:
/* Parameters:
* lParam1 = huge pointer to read buffer
* lParam2 = number of bytes to read
* Returns: number of bytes read, 0 for EOF, -1 for error (error code
* in wErrorRet)
*/
ret = _lread((HFILE)lpmmioinfo->adwInfo[0], (HPSTR)lParam1, (LONG)lParam2);
if (ret != -1)
lpmmioinfo->lDiskOffset += ret;
break;
case MMIOM_WRITE:
case MMIOM_WRITEFLUSH:
/* no internal buffering, so WRITEFLUSH handled same as WRITE */
/* Parameters:
* lParam1 = huge pointer to write buffer
* lParam2 = number of bytes to write
* Returns: number of bytes written, -1 for error (error code in
* wErrorRet)
*/
ret = _hwrite((HFILE)lpmmioinfo->adwInfo[0], (HPSTR)lParam1, (LONG)lParam2);
if (ret != -1)
lpmmioinfo->lDiskOffset += ret;
break;
case MMIOM_SEEK:
/* Parameters:
* lParam1 = new position
* lParam2 = from whence to seek (SEEK_SET, SEEK_CUR, SEEK_END)
* Returns: new file postion, -1 on error
*/
ret = _llseek((HFILE)lpmmioinfo->adwInfo[0], (LONG)lParam1, (LONG)lParam2);
if (ret != -1)
lpmmioinfo->lDiskOffset = ret;
return ret;
case MMIOM_RENAME:
/* Parameters:
* lParam1 = old name
* lParam2 = new name
* Returns: zero on success, non-zero on failure
*/
if (!MoveFileA((const char*)lParam1, (const char*)lParam2))
ret = MMIOERR_FILENOTFOUND;
break;
default:
FIXME("unexpected message %u\n", uMessage);
return 0;
}
return ret;
}
BOOL ExportSound( HWND hwndParent, WND_DATA *pWndData, INT index )
{
INT n;
LONG lsize;
HFILE fh;
BOOL bResult;
OPENFILENAME ofn;
CHAR szDirName[256], szFile[256], szFileTitle[256];
struct
{
char r_id[4];
long r_len;
char w_id[4];
char f_id[4];
long f_len;
int f_tag;
int f_channels;
long f_sample_rate;
long f_avg_bytes_per_sec;
int f_block_align;
int f_bits_per_sample;
char d_id[4];
long d_len;
} hdr;
static CHAR *szFilter = "WAV files (*.wav)\000*.wav\000";
_fstrcpy( szDirName, szPath );
n = _fstrlen( szDirName );
if (n > 0)
{
if (szDirName[n-1] == '\\' )
{
szDirName[n-1] = '\0';
}
}
_fstrcpy( szFile, pWndData->pSoundData[index].sound_name );
_fmemset( &ofn, 0, sizeof(OPENFILENAME) );
ofn.lStructSize = sizeof(OPENFILENAME);
ofn.hwndOwner = hwndParent;
ofn.hInstance = hInst;
ofn.lpstrFilter = szFilter;
ofn.nFilterIndex = 1;
ofn.lpstrFile= szFile;
ofn.nMaxFile = sizeof(szFile);
ofn.lpstrFileTitle = szFileTitle;
ofn.nMaxFileTitle = sizeof(szFileTitle);
ofn.lpstrInitialDir = szDirName;
ofn.Flags = OFN_OVERWRITEPROMPT | OFN_HIDEREADONLY;
bResult = GetSaveFileName( &ofn );
if ( !bResult )
{
DWORD dwError;
dwError = CommDlgExtendedError();
if ( dwError )
{
MsgBox( hwndParent,
MB_ICONEXCLAMATION,
"Common dialog error %lu",
dwError );
}
return FALSE;
}
fh = _lcreat( szFile, READ );
if ( fh == HFILE_ERROR )
{
MsgBox( hwndParent,
MB_ICONEXCLAMATION,
"Unable to create %s",
(LPSTR)szFile );
return FALSE;
}
lsize = pWndData->pSoundData[index].length;
hdr.r_id[0] = 'R';
hdr.r_id[1] = 'I';
hdr.r_id[2] = 'F';
hdr.r_id[3] = 'F';
hdr.r_len = sizeof(hdr) + lsize - 8L;
hdr.w_id[0] = 'W';
hdr.w_id[1] = 'A';
hdr.w_id[2] = 'V';
hdr.w_id[3] = 'E';
hdr.f_id[0] = 'f';
hdr.f_id[1] = 'm';
hdr.f_id[2] = 't';
hdr.f_id[3] = ' ';
hdr.f_len = 16L;
hdr.f_tag = 1;
hdr.f_channels = 1;
hdr.f_sample_rate = 22050L;
hdr.f_avg_bytes_per_sec = 22050L;
hdr.f_block_align = 1;
hdr.f_bits_per_sample = 8;
hdr.d_id[0] = 'd';
hdr.d_id[1] = 'a';
hdr.d_id[2] = 't';
hdr.d_id[3] = 'a';
hdr.d_len = lsize;
if ( _lwrite( fh, &hdr, sizeof(hdr) ) != sizeof(hdr) )
{
_lclose(fh);
MsgBox( hwndParent,
MB_ICONEXCLAMATION,
"Error writing sound file header for %s",
(LPSTR)szFile );
return FALSE;
}
if ( _hwrite( fh, pWndData->pSoundData[index].data, lsize) != lsize )
{
_lclose(fh);
MsgBox( hwndParent,
MB_ICONEXCLAMATION,
"Error writing sound file data for %s",
(LPSTR)szFile );
return FALSE;
}
_lclose(fh);
return TRUE;
} // ExportSound
