//-----------------------------------------------------------------------------
// Name: CWaveFile::Open()
// Desc: Opens a wave file for reading
//-----------------------------------------------------------------------------
HRESULT CWaveFile::Open( LPSTR strFileName, WAVEFORMATEX* pwfx, DWORD dwFlags )
{
HRESULT hr;
m_dwFlags = dwFlags;
m_bIsReadingFromMemory = FALSE;
if( m_dwFlags == WAVEFILE_READ )
{
if( strFileName == NULL )
return E_INVALIDARG;
SAFE_DELETE_ARRAY( m_pwfx );
m_hmmio = mmioOpen( strFileName, NULL, MMIO_ALLOCBUF | MMIO_READ );
if( FAILED( hr = ReadMMIO() ) )
{
// ReadMMIO will fail if its an not a wave file
mmioClose( m_hmmio, 0 );
return WAVEFILE_ERROR( L"ReadMMIO", hr );
}
if( FAILED( hr = ResetFile() ) )
return WAVEFILE_ERROR( L"ResetFile", hr );
// After the reset, the size of the wav file is m_ck.cksize so store it now
m_dwSize = m_ck.cksize;
}
else
{
m_hmmio = mmioOpen( strFileName, NULL, MMIO_ALLOCBUF |
MMIO_READWRITE |
MMIO_CREATE );
if( NULL == m_hmmio )
return WAVEFILE_ERROR( L"mmioOpen", E_FAIL );
if( FAILED( hr = WriteMMIO( pwfx ) ) )
{
mmioClose( m_hmmio, 0 );
return WAVEFILE_ERROR( L"WriteMMIO", hr );
}
if( FAILED( hr = ResetFile() ) )
return WAVEFILE_ERROR( L"ResetFile", hr );
}
return hr;
}
HRESULT WaveDecoder::Seek(float duration ,DWORD *newPosition)
{
*newPosition = 0;
if(duration < 0 || duration >= m_id3.duration_times)
{
return M_DURATION_OUT_OF_RANGE;//E_FAIL;
}
if(0 == duration)
{
*newPosition = 0;
return ResetFile();
}
else
{
DWORD seekSize = (DWORD)(duration * m_pwfx->nAvgBytesPerSec);
if(seekSize > m_dwSize)
{
return E_FAIL;
}
*newPosition = seekSize;
if( -1 == mmioSeek( m_hmmio, m_ckRiff.dwDataOffset + sizeof( FOURCC ) + seekSize,
SEEK_SET ) )
return E_FAIL;
// Search the input file for the 'data' chunk.
//m_ck.ckid = mmioFOURCC( 'd', 'a', 't', 'a' );
//if( 0 != mmioDescend( m_hmmio, &m_ck, &m_ckRiff, MMIO_FINDCHUNK ) )
// return E_FAIL;
}
return S_OK;
}
void CTextView::InitVars(void)
{
m_hwnd = NULL;
m_pfnOldTextViewWndProc = NULL;
m_lOldStyle = 0;
m_nWheelLines = g_dwDefaultNumWheels;
ResetFile();
}
void CFileStream::Close(void)
{
if (m_hFile != INVALID_HANDLE_VALUE)
{
FlushBuffer();
CloseHandle(m_hFile);
ResetFile(GetLastError());
}
}
void CRunLog::WriteRunLog(const char *shm,...)
{
char buffer[MAX_LINE_SIZE];
va_list sp;
AddHead(buffer);
va_start(sp,shm);
vsnprintf(buffer+strlen(buffer),MAX_LINE_SIZE - strlen(buffer),shm,sp);
va_end(sp);
strcat(buffer,"\n");
buffer[MAX_LINE_SIZE - 2] = '\n';
if (GetFileSize(this->LogFile) > this->FileSize) ResetFile();
if (NULL == fp) OpenFile();
WriteContent(buffer);
}
HRESULT ApeDecoder::Seek(float duration ,DWORD *newPosition )
{
*newPosition = 0;
if(duration < 0 || duration >= m_id3.duration_times)
{
return M_DURATION_OUT_OF_RANGE;//E_FAIL;
}
if(0 == duration)
{
*newPosition = 0;
return ResetFile();
}
else
{
DWORD seekSize = (DWORD)(duration * m_pwfx->nAvgBytesPerSec);
if(seekSize > m_dwSize)
{
return E_FAIL;
}
m_nWaveDataNum = 0;
*newPosition = seekSize;
unsigned int mcBlock = seekSize / m_block_algin;
if(mcBlock > m_total_blocks)
{
return E_FAIL;
}
int num = m_pAPEDecompress->Seek(mcBlock);
m_current_blocks = mcBlock;
//return (0 == num);
}
return S_OK;;
}
//-----------------------------------------------------------------------------
// Name: CWaveFile::Open()
// Desc: Opens a wave file for reading
//-----------------------------------------------------------------------------
HRESULT CWaveFile::Open( LPTSTR strFileName, WAVEFORMATEX* pwfx, DWORD dwFlags )
{
HRESULT hr;
m_dwFlags = dwFlags;
m_bIsReadingFromMemory = FALSE;
if( m_dwFlags == WAVEFILE_READ )
{
if( strFileName == NULL )
return E_INVALIDARG;
SAFE_DELETE_ARRAY( m_pwfx );
m_hmmio = mmioOpen( strFileName, NULL, MMIO_ALLOCBUF | MMIO_READ );
if( NULL == m_hmmio )
{
HRSRC hResInfo;
HGLOBAL hResData;
DWORD dwSize;
VOID* pvRes;
// Loading it as a file failed, so try it as a resource
if( NULL == ( hResInfo = FindResource( NULL, strFileName, TEXT("WAVE") ) ) )
{
if( NULL == ( hResInfo = FindResource( NULL, strFileName, TEXT("WAV") ) ) )
return DXTRACE_ERR( TEXT("FindResource"), E_FAIL );
}
if( NULL == ( hResData = LoadResource( NULL, hResInfo ) ) )
return DXTRACE_ERR( TEXT("LoadResource"), E_FAIL );
if( 0 == ( dwSize = SizeofResource( NULL, hResInfo ) ) )
return DXTRACE_ERR( TEXT("SizeofResource"), E_FAIL );
if( NULL == ( pvRes = LockResource( hResData ) ) )
return DXTRACE_ERR( TEXT("LockResource"), E_FAIL );
m_pResourceBuffer = new CHAR[ dwSize ];
memcpy( m_pResourceBuffer, pvRes, dwSize );
MMIOINFO mmioInfo;
ZeroMemory( &mmioInfo, sizeof(mmioInfo) );
mmioInfo.fccIOProc = FOURCC_MEM;
mmioInfo.cchBuffer = dwSize;
mmioInfo.pchBuffer = (CHAR*) m_pResourceBuffer;
m_hmmio = mmioOpen( NULL, &mmioInfo, MMIO_ALLOCBUF | MMIO_READ );
}
if( FAILED( hr = ReadMMIO() ) )
{
// ReadMMIO will fail if its an not a wave file
mmioClose( m_hmmio, 0 );
return DXTRACE_ERR( TEXT("ReadMMIO"), hr );
}
if( FAILED( hr = ResetFile() ) )
return DXTRACE_ERR( TEXT("ResetFile"), hr );
// After the reset, the size of the wav file is m_ck.cksize so store it now
m_dwSize = m_ck.cksize;
}
else
{
m_hmmio = mmioOpen( strFileName, NULL, MMIO_ALLOCBUF |
MMIO_READWRITE |
MMIO_CREATE );
if( NULL == m_hmmio )
return DXTRACE_ERR( TEXT("mmioOpen"), E_FAIL );
if( FAILED( hr = WriteMMIO( pwfx ) ) )
{
mmioClose( m_hmmio, 0 );
return DXTRACE_ERR( TEXT("WriteMMIO"), hr );
}
if( FAILED( hr = ResetFile() ) )
return DXTRACE_ERR( TEXT("ResetFile"), hr );
}
return hr;
}
void CTextView::LoadCache(void)
{
_ASSERTE(m_hFile != INVALID_HANDLE_VALUE);
m_dwFirstCachedLine = m_dwNumCachedLines = 0;
m_nMaxLineWidth = 0;
DWORD dwNumLines = m_arrLines.GetCount();
if (dwNumLines > 0)
{
HDC hdc = GetDC(m_hwnd);
HFONT hOldFont = g_pResManager->m_hFixedFont ? SelectFont(hdc, g_pResManager->m_hFixedFont) : NULL;
TEXTMETRIC tmetr;
::GetTextMetrics(hdc, &tmetr);
int nExtraWidth = tmetr.tmAveCharWidth + LOWORD(GetTabbedTextExtent(hdc, g_szEllipsis, g_dwEllipsisLength, 0, NULL));
if (m_pTextCache == NULL)
{
_ASSERTE(MAX_NUMBER_OF_SYMBOLS <= TEXT_CACHE_SIZE);
m_pTextCache = new TCHAR[TEXT_CACHE_SIZE];
if (m_pTextCache == NULL)
{
ResetFile();
goto end;
}
}
const CLineInfo& rLineInfo = m_arrLines[0];
SetFilePointer(m_hFile, rLineInfo.m_dwLineStart, NULL, FILE_BEGIN);
DWORD dwLineBufferPos = 0, dwTextCachePos = 0;
for (;;)
{
DWORD dwNumRead = 0;
if (! ReadFile(m_hFile, m_pLineBuffer + dwLineBufferPos, m_dwLineBufferSize - dwLineBufferPos, &dwNumRead, NULL))
goto end;
dwNumRead += dwLineBufferPos;
dwLineBufferPos = 0;
if (dwNumRead == 0)
break;
for (;;)
{
DWORD dwBytesLeft = dwNumRead - dwLineBufferPos;
if (dwBytesLeft == 0)
{
dwLineBufferPos = 0;
break;
}
CLineInfo& rLineInfo = m_arrLines[(int)m_dwNumCachedLines];
if (dwTextCachePos + rLineInfo.m_dwLength > TEXT_CACHE_SIZE)
goto end;
DWORD dwLineSize;
if (m_dwNumCachedLines + 1 < dwNumLines)
{
const CLineInfo& rNextLineInfo = m_arrLines[(int)(m_dwNumCachedLines + 1)];
dwLineSize = rNextLineInfo.m_dwLineStart - rLineInfo.m_dwLineStart; // line size includes line end
}
else
dwLineSize = rLineInfo.m_dwSize;
if (dwLineSize > dwBytesLeft)
{
MoveMemory(m_pLineBuffer, m_pLineBuffer + dwLineBufferPos, dwBytesLeft);
dwLineBufferPos = dwBytesLeft;
break;
}
m_pDecoder->DecodeString(m_pLineBuffer + dwLineBufferPos, rLineInfo.m_dwSize, m_pTextCache + dwTextCachePos, rLineInfo.m_dwLength);
int nLineWidth = LOWORD(GetTabbedTextExtent(hdc, m_pTextCache + dwTextCachePos, rLineInfo.m_dwLength, 0, NULL));
if (m_nMaxLineWidth < nLineWidth)
m_nMaxLineWidth = nLineWidth;
rLineInfo.m_dwTextStart = dwTextCachePos;
dwTextCachePos += rLineInfo.m_dwLength;
dwLineBufferPos += dwLineSize;
++m_dwNumCachedLines;
}
}
end:
m_nMaxLineWidth += nExtraWidth;
ResizeTextView(TRUE);
if (hOldFont)
SelectFont(hdc, hOldFont);
ReleaseDC(m_hwnd, hdc);
}
}
void CTextView::CountLines(void)
{
_ASSERTE(m_hFile != INVALID_HANDLE_VALUE);
m_arrLines.DeleteAll(false);
DWORD dwFileSize = GetFileSize(m_hFile, NULL);
DWORD dwFilePos = SetFilePointer(m_hFile, 0, NULL, FILE_CURRENT);
dwFileSize -= dwFilePos;
DWORD dwBufferSize = min(dwFileSize, g_dwMaxBufferSize);
PBYTE pFileBuffer = new BYTE[dwBufferSize];
if (pFileBuffer == NULL)
return;
m_arrLines.EnsureSize(dwFileSize / APROX_NUMBER_OF_SYMBOLS, false); // approximate number of lines
DWORD dwBufferPos = 0, dwNumSymbols = 0, dwNumChars = 0, dwLineStartPos = dwFilePos, dwLineEndPos = dwFilePos;
TCHAR chPrevLineEnd = _T('\0');
m_dwLineBufferSize = 0;
for (;;)
{
DWORD dwNumRead = 0, dwFreeSize = dwBufferSize - dwBufferPos;
if (! ReadFile(m_hFile, pFileBuffer + dwBufferPos, dwFreeSize, &dwNumRead, NULL))
break;
BOOL bEndOfFile = dwNumRead < dwFreeSize;
dwNumRead += dwBufferPos;
dwBufferPos = 0;
if (dwNumRead == 0)
break;
for (;;)
{
DWORD dwBytesLeft = dwNumRead - dwBufferPos;
// one character in UTF-16 encoding may require up to 4 bytes
// one character in UTF-8 encoding may require up to 4 bytes
// one character in ANSI encoding may require up to 2 bytes
// make sure at least one character can be read from the buffer
// (i.e. at least 4 bytes should be available)
if (dwBytesLeft < 4 && ! bEndOfFile)
{
MoveMemory(pFileBuffer, pFileBuffer + dwBufferPos, dwBytesLeft);
dwBufferPos = dwBytesLeft;
break;
}
BOOL bGotoNewLine, bSkipLineEnd, bLineEndChar;
if (dwBytesLeft > 0)
{
TCHAR arrChar[2];
int nNumBytesInChar, nCharSize;
nNumBytesInChar = m_pDecoder->DecodeChar(pFileBuffer + dwBufferPos, dwBytesLeft, arrChar, nCharSize);
if (nCharSize <= 0)
{
++dwBufferPos;
++dwFilePos;
++dwLineEndPos;
continue;
}
else
{
dwBufferPos += nNumBytesInChar;
dwFilePos += nNumBytesInChar;
}
if (nCharSize == 1 && (arrChar[0] == _T('\r') || arrChar[0] == _T('\n')))
{
bGotoNewLine = bLineEndChar = TRUE;
if (chPrevLineEnd != _T('\0') && chPrevLineEnd != arrChar[0])
{
chPrevLineEnd = _T('\0');
bSkipLineEnd = TRUE;
}
else
{
chPrevLineEnd = arrChar[0];
bSkipLineEnd = FALSE;
}
}
else
{
++dwNumSymbols;
dwNumChars += nCharSize;
bGotoNewLine = dwNumSymbols == MAX_NUMBER_OF_SYMBOLS;
chPrevLineEnd = _T('\0');
bSkipLineEnd = bLineEndChar = FALSE;
dwLineEndPos = dwFilePos;
}
}
else
{
bGotoNewLine = TRUE;
bSkipLineEnd = FALSE;
bLineEndChar = TRUE;
}
if (bGotoNewLine)
{
if (! bSkipLineEnd)
{
CLineInfo LineInfo;
LineInfo.m_dwLineStart = dwLineStartPos;
LineInfo.m_dwLength = dwNumChars;
LineInfo.m_dwSize = dwLineEndPos - dwLineStartPos;
LineInfo.m_bTruncated = ! bLineEndChar;
m_arrLines.AddItem(LineInfo);
if (m_dwLineBufferSize < LineInfo.m_dwSize)
m_dwLineBufferSize = LineInfo.m_dwSize;
if (dwBytesLeft == 0)
goto end;
}
dwLineStartPos = dwLineEndPos = dwFilePos;
dwNumSymbols = 0;
dwNumChars = 0;
}
}
}
end:
delete[] pFileBuffer;
// reserve space for two line end characters in order to retrieve contiguous lines using ReadFile() sequentially
// (for Unicode encoding this requires 4 bytes)
m_dwLineBufferSize += 4;
// add some extra space to the buffer to let several lines to be loaded
if (m_dwLineBufferSize < LINE_BUFFER_SIZE)
m_dwLineBufferSize = LINE_BUFFER_SIZE;
m_pLineBuffer = new BYTE[m_dwLineBufferSize];
if (m_pLineBuffer == NULL)
ResetFile();
}
HRESULT WaveDecoder::Open( LPWSTR strFileName, WAVEFORMATEX* pwfx, DWORD dwFlags )
{
m_id3.EmptyTags();
/*char ex[2048] = "wav";
if(!isFile_ex(strFileName,ex))
{
return E_FAIL;
}*/
HRESULT hr;
if(WAVEFILE_READ != dwFlags)
{
return M_INVALID_PARAMETERS;//E_FAIL;
}
m_dwFlags = dwFlags;
//m_bIsReadingFromMemory = FALSE;
SAFE_DELETE_ARRAY( m_pwfx );
m_pwfx = NULL;
if( m_dwFlags == WAVEFILE_READ )
{
if( strFileName == NULL )
return E_INVALIDARG;
m_hmmio = mmioOpen( strFileName, NULL, MMIO_ALLOCBUF | MMIO_READ );
if( NULL == m_hmmio )
{
HRSRC hResInfo;
HGLOBAL hResData;
DWORD dwSize;
VOID* pvRes;
// Loading it as a file failed, so try it as a resource
if( NULL == ( hResInfo = FindResource( NULL, strFileName, L"WAVE" ) ) )
{
if( NULL == ( hResInfo = FindResource( NULL, strFileName, L"WAV" ) ) )
//return DXTRACE_ERR( L"FindResource", E_FAIL );
return E_FAIL;
}
if( NULL == ( hResData = LoadResource( GetModuleHandle( NULL ), hResInfo ) ) )
//return DXTRACE_ERR( L"LoadResource", E_FAIL );
return E_FAIL;
if( 0 == ( dwSize = SizeofResource( GetModuleHandle( NULL ), hResInfo ) ) )
//return DXTRACE_ERR( L"SizeofResource", E_FAIL );
return E_FAIL;
if( NULL == ( pvRes = LockResource( hResData ) ) )
//return DXTRACE_ERR( L"LockResource", E_FAIL );
return E_FAIL;
m_pResourceBuffer = new CHAR[ dwSize ];
if( m_pResourceBuffer == NULL )
//return DXTRACE_ERR( L"new", E_OUTOFMEMORY );
return E_OUTOFMEMORY;
memcpy( m_pResourceBuffer, pvRes, dwSize );
MMIOINFO mmioInfo;
ZeroMemory( &mmioInfo, sizeof( mmioInfo ) );
mmioInfo.fccIOProc = FOURCC_MEM;
mmioInfo.cchBuffer = dwSize;
mmioInfo.pchBuffer = ( CHAR* )m_pResourceBuffer;
m_hmmio = mmioOpen( NULL, &mmioInfo, MMIO_ALLOCBUF | MMIO_READ );
}
if( FAILED( hr = ReadMMIO() ) )
{
// ReadMMIO will fail if its an not a wave file
mmioClose( m_hmmio, 0 );
// return DXTRACE_ERR( L"ReadMMIO", hr );
return hr;
}
if( FAILED( hr = ResetFile() ) )
//return DXTRACE_ERR( L"ResetFile", hr );
return hr;
// After the reset, the size of the wav file is m_ck.cksize so store it now
m_dwSize = m_ck.cksize;
m_id3.duration_times = (float)m_dwSize / (float) m_pwfx->nAvgBytesPerSec;
m_id3.bitrate = m_pwfx->nChannels * m_pwfx->nSamplesPerSec * m_pwfx->wBitsPerSample;
}
else
{
m_hmmio = mmioOpen( strFileName, NULL, MMIO_ALLOCBUF |
MMIO_READWRITE |
MMIO_CREATE );
if( NULL == m_hmmio )
//return DXTRACE_ERR( L"mmioOpen", E_FAIL );
return E_FAIL;
if( FAILED( hr = WriteMMIO( pwfx ) ) )
{
mmioClose( m_hmmio, 0 );
//return DXTRACE_ERR( L"WriteMMIO", hr );
return hr;
}
if( FAILED( hr = ResetFile() ) )
//return DXTRACE_ERR( L"ResetFile", hr );
return hr;
}
return hr;
}
//-----------------------------------------------------------------------------
// Name: idWaveFile::Open()
// Desc: Opens a wave file for reading
//-----------------------------------------------------------------------------
int idWaveFile::Open(const char *strFileName, waveformatex_t *pwfx)
{
mbIsReadingFromMemory = false;
mpbData = NULL;
mpbDataCur = mpbData;
if (strFileName == NULL) {
return -1;
}
idStr name = strFileName;
// note: used to only check for .wav when making a build
name.SetFileExtension(".ogg");
if (fileSystem->ReadFile(name, NULL, NULL) != -1) {
return OpenOGG(name, pwfx);
}
memset(&mpwfx, 0, sizeof(waveformatextensible_t));
mhmmio = fileSystem->OpenFileRead(strFileName);
if (!mhmmio) {
mdwSize = 0;
return -1;
}
if (mhmmio->Length() <= 0) {
mhmmio = NULL;
return -1;
}
if (ReadMMIO() != 0) {
// ReadMMIO will fail if its an not a wave file
Close();
return -1;
}
mfileTime = mhmmio->Timestamp();
if (ResetFile() != 0) {
Close();
return -1;
}
// After the reset, the size of the wav file is mck.cksize so store it now
mdwSize = mck.cksize / sizeof(short);
mMemSize = mck.cksize;
if (mck.cksize != 0xffffffff) {
if (pwfx) {
memcpy(pwfx, (waveformatex_t *)&mpwfx, sizeof(waveformatex_t));
}
return 0;
}
return -1;
}
