multimedia.cpp

EVC环境下用SDK开发WINCE的应用程序

	{
		if(!IsPaused())
		{	
			if(SUCCEEDED(m_pMediaControl->Pause()))
			{
				return true;
			}
		}
		else
		{
			return true;
		}
	}
	return false;
}

/////////////////////////////////////////////////////////////////////////////
//
bool CMultimedia::IsRunning(void)
{
	if(m_pGraphBuilder && m_pMediaControl)
	{
		OAFilterState state = State_Stopped;
		if(SUCCEEDED(m_pMediaControl->GetState(10, &state)))
		{
			return state == State_Running;
		}
	}
	return false;
}

/////////////////////////////////////////////////////////////////////////////
//
bool CMultimedia::IsStopped(void)
{
	if(m_pGraphBuilder && m_pMediaControl)
	{
		OAFilterState state = State_Stopped;
		if(SUCCEEDED(m_pMediaControl->GetState(10, &state)))
		{
			return state == State_Stopped;
		}
	}
	return false;
}

/////////////////////////////////////////////////////////////////////////////
//
bool CMultimedia::IsPaused(void)
{
	if(m_pGraphBuilder && m_pMediaControl)
	{
		OAFilterState state = State_Stopped;
		if(SUCCEEDED(m_pMediaControl->GetState(10, &state)))
		{
			return state == State_Paused;
		}
	}
	return false;
}

/////////////////////////////////////////////////////////////////////////////
//
bool CMultimedia::SetFullScreen(BOOL inEnabled)
{
	if(m_pVideoWindow)
	{
		HRESULT hr = m_pVideoWindow->put_FullScreenMode(inEnabled ? OATRUE : OAFALSE);
		return SUCCEEDED(hr);
	}
	return false;
}

/////////////////////////////////////////////////////////////////////////////
//
bool CMultimedia::GetFullScreen(void)
{
	if(m_pVideoWindow)
	{
		long fullScreenMode = OAFALSE;
		m_pVideoWindow->get_FullScreenMode(&fullScreenMode);
		return (fullScreenMode == OATRUE);
	}
	return false;
}

/////////////////////////////////////////////////////////////////////////////
// IMediaSeeking features
bool CMultimedia::GetCurrentPosition(double * outPosition)
{
	if(m_pMediaSeeking)
	{
		__int64 position = 0;
		if(SUCCEEDED(m_pMediaSeeking->GetCurrentPosition(&position)))
		{
			*outPosition = ((double)position) / 10000000.;
			return true;
		}
	}
	return false;
}

/////////////////////////////////////////////////////////////////////////////
//
bool CMultimedia::GetStopPosition(double * outPosition)
{
	if(m_pMediaSeeking)
	{
		__int64 position = 0;
		if(SUCCEEDED(m_pMediaSeeking->GetStopPosition(&position)))
		{
			*outPosition = ((double)position) / 10000000.;
			return true;
		}
	}
	return false;
}

/////////////////////////////////////////////////////////////////////////////
//
bool CMultimedia::SetCurrentPosition(double inPosition)
{
	if(m_pMediaSeeking)
	{
		__int64 one = 10000000;
		__int64 position = (__int64)(one * inPosition);
		HRESULT hr = m_pMediaSeeking->SetPositions(&position, AM_SEEKING_AbsolutePositioning | AM_SEEKING_SeekToKeyFrame, 
			0, AM_SEEKING_NoPositioning);
		return SUCCEEDED(hr);
	}
	return false;
}

/////////////////////////////////////////////////////////////////////////////
//
bool CMultimedia::SetStartStopPosition(double inStart, double inStop)
{
	if(m_pMediaSeeking)
	{
		__int64 one = 10000000;
		__int64 startPos = (__int64)(one * inStart);
		__int64 stopPos  = (__int64)(one * inStop);
		HRESULT hr = m_pMediaSeeking->SetPositions(&startPos, AM_SEEKING_AbsolutePositioning | AM_SEEKING_SeekToKeyFrame, 
			&stopPos, AM_SEEKING_AbsolutePositioning | AM_SEEKING_SeekToKeyFrame);
		return SUCCEEDED(hr);
	}
	return false;
}

/////////////////////////////////////////////////////////////////////////////
//
bool CMultimedia::GetDuration(double * outDuration)
{
	if(m_pMediaSeeking)
	{
		__int64 length = 0;
		if(SUCCEEDED(m_pMediaSeeking->GetDuration(&length)))
		{
			*outDuration = ((double)length) / 10000000.;
			return true;
		}
	}
	return false;
}

/////////////////////////////////////////////////////////////////////////////
//
bool CMultimedia::SetPlaybackRate(double inRate)
{
	if(m_pMediaSeeking)
	{
		if(SUCCEEDED(m_pMediaSeeking->SetRate(inRate)))
		{
			return true;
		}
	}
	return false;
}

/////////////////////////////////////////////////////////////////////////////
// Attention: range from -10000 to 0, and 0 is FULL_VOLUME.
bool CMultimedia::SetAudioVolume(long inVolume)
{
	if(m_pBasicAudio)
	{
		HRESULT hr = m_pBasicAudio->put_Volume(inVolume);
		return SUCCEEDED(hr);
	}
	return false;
}

/////////////////////////////////////////////////////////////////////////////
//
long CMultimedia::GetAudioVolume(void)
{
	long volume = 0;
	if(m_pBasicAudio)
	{
		m_pBasicAudio->get_Volume(&volume);
	}
	return volume;
}

/////////////////////////////////////////////////////////////////////////////
// Attention: range from -10000(left) to 10000(right), and 0 is both.
bool CMultimedia::SetAudioBalance(long inBalance)
{
	if(m_pBasicAudio)
	{
		HRESULT hr = m_pBasicAudio->put_Balance(inBalance);
		return SUCCEEDED(hr);
	}
	return false;
}

/////////////////////////////////////////////////////////////////////////////
//
long CMultimedia::GetAudioBalance(void)
{
	long balance = 0;
	if(m_pBasicAudio)
	{
		m_pBasicAudio->get_Balance(&balance);
	}
	return balance;
}

/////////////////////////////////////////////////////////////////////////////
//
bool CMultimedia::RenderFile(const TCHAR * inFile)
{
	if(m_pGraphBuilder)
	{
		WCHAR    szFilePath[MAX_PATH];
#ifdef UNICODE
		_tcscpy(szFilePath, inFile);
#else
		MultiByteToWideChar(CP_ACP, 0, inFile, -1, szFilePath, MAX_PATH);
#endif
		if(SUCCEEDED(m_pGraphBuilder->RenderFile(szFilePath, NULL)))
		{
			return true;
		}
	}
	return false;
}

/////////////////////////////////////////////////////////////////////////////
//
bool CMultimedia::SnapshotBitmap(const TCHAR * outFile)
{
	if(m_pBasicVideo)
	{
		long bitmapSize = 0;
		if(SUCCEEDED(m_pBasicVideo->GetCurrentImage(&bitmapSize, 0)))
		{
			bool pass = false;
			unsigned char * buffer = new unsigned char[bitmapSize];
			if(SUCCEEDED(m_pBasicVideo->GetCurrentImage(&bitmapSize, (long *)buffer)))
			{
				BITMAPFILEHEADER	hdr;
				LPBITMAPINFOHEADER	lpbi;

				lpbi = (LPBITMAPINFOHEADER)buffer;

				int nColors = 1 << lpbi->biBitCount;
				if(nColors > 256)
					nColors = 0;

				hdr.bfType		= ((WORD) ('M' << 8) | 'B');	//always is "BM"
				hdr.bfSize		= bitmapSize + sizeof( hdr );
				hdr.bfReserved1 	= 0;
				hdr.bfReserved2 	= 0;
				hdr.bfOffBits		= (DWORD) (sizeof(BITMAPFILEHEADER) + lpbi->biSize +
						nColors * sizeof(RGBQUAD));

				//CFile bitmapFile(outFile, CFile::modeReadWrite | CFile::modeCreate | CFile::typeBinary);
				FILE *fpBitmapFile = _tfopen(outFile, _T("w+b"));

				//bitmapFile.Write(&hdr, sizeof(BITMAPFILEHEADER));
				//bitmapFile.Write(buffer, bitmapSize);
				//bitmapFile.Close();
				fwrite(&hdr, sizeof(BITMAPFILEHEADER), 1, fpBitmapFile);
				fwrite(buffer, bitmapSize, 1, fpBitmapFile);
				pass = true;
			}
			delete [] buffer;
			return pass;
		}
	}
	return false;
}

//////////////////////// For GraphEdit Dubug purpose /////////////////////////////
/////////////////////////////////////////////////////////////////////////////
//
void CMultimedia::AddToObjectTable(void)
{
/*	IMoniker * pMoniker = 0;
    IRunningObjectTable * objectTable = 0;
    if(SUCCEEDED(GetRunningObjectTable(0, &objectTable))) 
	{
		WCHAR wsz[256];
		wsprintfW(wsz, L"FilterGraph %08p pid %08x", (DWORD)m_pGraphBuilder, GetCurrentProcessId());
		HRESULT hr = CreateItemMoniker(L"!", wsz, &pMoniker);
		if(SUCCEEDED(hr)) 
		{
			hr = objectTable->Register(0, m_pGraphBuilder, pMoniker, &m_dwObjectTableEntry);
			pMoniker->Release();
		}
		objectTable->Release();
	}
*/}

/////////////////////////////////////////////////////////////////////////////
//
void CMultimedia::RemoveFromObjectTable(void)
{
/*	IRunningObjectTable * objectTable = 0;
    if(SUCCEEDED(GetRunningObjectTable(0, &objectTable))) 
	{
        objectTable->Revoke(m_dwObjectTableEntry);
        objectTable->Release();
		m_dwObjectTableEntry = 0;
    }
*/}

/////////////////////////////////////////////////////////////////////////////