COM

#include "objidl.h"

#ifndef INCLUDE_AUDIOSTREAM
#define INCLUDE_AUDIOSTREAM

class CAudioStream :
	public IStream
{
private:
	LONG m_cRef;
	HANDLE m_hFile;
public:
	CAudioStream(TCHAR* pszFileName);
	~CAudioStream(void);

	HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void** ppvObject);
	ULONG STDMETHODCALLTYPE AddRef(void);
	ULONG STDMETHODCALLTYPE Release(void);

	HRESULT STDMETHODCALLTYPE Read(void *pv, ULONG cb, ULONG *pcbRead);
	HRESULT STDMETHODCALLTYPE Write(const void *pv, ULONG cb, ULONG *pcbWritten);

	HRESULT STDMETHODCALLTYPE Seek(LARGE_INTEGER dlibMove, DWORD dwOrigin, ULARGE_INTEGER *plibNewPosition);
	HRESULT STDMETHODCALLTYPE SetSize(ULARGE_INTEGER libNewSize);
	HRESULT STDMETHODCALLTYPE CopyTo(IStream *pstm, ULARGE_INTEGER cb, ULARGE_INTEGER *pcbRead, ULARGE_INTEGER *pcbWritten);
	HRESULT STDMETHODCALLTYPE Commit(DWORD grfCommitFlags);
	HRESULT STDMETHODCALLTYPE Revert(void);
	HRESULT STDMETHODCALLTYPE LockRegion(ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType);
	HRESULT STDMETHODCALLTYPE UnlockRegion(ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType);
	HRESULT STDMETHODCALLTYPE Stat(STATSTG *pstatstg, DWORD grfStatFlag);
	HRESULT STDMETHODCALLTYPE Clone(IStream **ppstm);
};

#endif

#include "StdAfx.h"
#include "AudioStream.h"

CAudioStream::CAudioStream(TCHAR* pszFileName)
{
	m_cRef = 0;
	m_hFile = CreateFile(pszFileName, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING,
		FILE_ATTRIBUTE_ARCHIVE | FILE_ATTRIBUTE_NORMAL, NULL);
	if(m_hFile == INVALID_HANDLE_VALUE)
		MessageBox(GetActiveWindow(), "can not open file.", "error", MB_OK);
}

CAudioStream::~CAudioStream(void)
{
	if(m_hFile != INVALID_HANDLE_VALUE)
		CloseHandle(m_hFile);

	m_hFile = INVALID_HANDLE_VALUE;
}

HRESULT STDMETHODCALLTYPE CAudioStream::QueryInterface(const IID &riid, void **ppvObject)
{
	if(IID_IStream == riid || IID_IUnknown == riid)
	{
		*ppvObject = static_cast<IStream*>(this);
		AddRef();
		return S_OK;
	}

	*ppvObject = NULL;
	return E_NOINTERFACE;
}

ULONG STDMETHODCALLTYPE CAudioStream::AddRef()
{
	return InterlockedIncrement(&m_cRef);
}

ULONG STDMETHODCALLTYPE CAudioStream::Release()
{
	if(InterlockedDecrement(&m_cRef) == 0)
	{
		delete this;
		return S_OK;
	}

	return m_cRef;
}

HRESULT STDMETHODCALLTYPE CAudioStream::Read(void *pv, ULONG cb, ULONG *pcbRead)
{
	if(!ReadFile(m_hFile, pv, cb, pcbRead, NULL))
		return E_FAIL;

	if(*pcbRead <= 0)
		return E_FAIL;

	return S_OK;
}

HRESULT STDMETHODCALLTYPE CAudioStream::Write(const void *pv, ULONG cb, ULONG *pcbWritten)
{
	if(!WriteFile(m_hFile, pv, cb, pcbWritten, NULL))
		return E_FAIL;

	if(*pcbWritten <= 0)
		return E_FAIL;

	return S_OK;
}

HRESULT STDMETHODCALLTYPE CAudioStream::Seek(LARGE_INTEGER dlibMove, DWORD dwOrigin, ULARGE_INTEGER *plibNewPosition)
{
	plibNewPosition->QuadPart = SetFilePointer(m_hFile, dlibMove.LowPart, NULL, dwOrigin);
	return S_OK;
}

HRESULT STDMETHODCALLTYPE CAudioStream::SetSize(ULARGE_INTEGER libNewSize)
{
	SetFilePointer(m_hFile, libNewSize.LowPart, NULL, 0);
	return S_OK;
}

HRESULT STDMETHODCALLTYPE CAudioStream::CopyTo(IStream *pstm, ULARGE_INTEGER cb, ULARGE_INTEGER *pcbRead, ULARGE_INTEGER *pcbWritten)
{
	return -1;
}

HRESULT STDMETHODCALLTYPE CAudioStream::Commit(DWORD grfCommitFlags)
{
	return -1;
}

HRESULT STDMETHODCALLTYPE CAudioStream::Revert(void)
{
	return -1;
}

HRESULT STDMETHODCALLTYPE CAudioStream::LockRegion(ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType)
{
	return -1;
}

HRESULT STDMETHODCALLTYPE CAudioStream::UnlockRegion(ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType)
{
	return -1;
}

HRESULT STDMETHODCALLTYPE CAudioStream::Stat(STATSTG *pstatstg, DWORD grfStatFlag)
{
	pstatstg->cbSize.QuadPart = GetFileSize(m_hFile, NULL);
	pstatstg->grfLocksSupported = 0;
	return -1;
}

HRESULT STDMETHODCALLTYPE CAudioStream::Clone(IStream **ppstm)
{
	return -1;
}

#include "stdafx.h"
#include "AudioStream.h"

int main(int argc, char* argv[])
{
	CoInitialize(NULL);
	CAudioStream* pAudioStream = NULL;
	

	IWMSyncReader* reader;
	HRESULT hr;

	hr = WMCreateSyncReader(NULL, 0, &reader);
	if(hr != S_OK)
	{
		CoUninitialize();
		return 0;
	}

	pAudioStream = new CAudioStream("d:\\Music\\You&Me.mp3");
	IStream* pStream = static_cast<IStream*>(pAudioStream);
	pStream->AddRef();

	hr = reader->OpenStream(pStream);
	if(hr != S_OK)
	{
		LARGE_INTEGER dlibMove;
		ULARGE_INTEGER plibNewPosition;

		dlibMove.QuadPart = 30;
		plibNewPosition.QuadPart = 0;
		pAudioStream->Seek(dlibMove, FILE_BEGIN, &plibNewPosition);

		hr = reader->OpenStream(pStream);
		if(hr != S_OK)
		{
			reader->Release();
			reader = NULL;

			pStream->Release();
			pStream = NULL;
			CoUninitialize();

			return 0;
		}

		DWORD dwOutputCount;
		hr = reader->GetOutputCount(&dwOutputCount);
		if(hr != S_OK)
		{
			reader->Release();
			reader = NULL;

			pStream->Release();
			pStream = NULL;

			CoUninitialize();

			return 0;
		}

		printf("OutputCount=%d\n", dwOutputCount);
	}

	system("pause");
	
	reader->Release();
	reader = NULL;

	pStream->Release();
	pStream = NULL;

	CoUninitialize();

	return 0;
}

IStorage *Storage;
	CLSID   clsidWord; 
	CoInitialize(NULL);
	HRESULT hr=CoCreateInstance(clsidWord,NULL,CLSCTX_SERVER,IID_IStorage,(void**) &Storage);

int CRXGemApp::StartRemoteApplication(void)
{
	if(m_RemoteApp != NULL)
		return 0;

	if(m_RemoteApp == NULL)
	{
		m_RemoteApp = new CRXMFX();

             		// Start Application and get Application object...
	        	COleException e;

       		 if(!m_RemoteApp->CreateDispatch("REMOTEAPP.Application", &e))
       		 {
			AddToErrorLog("could not startthe Application");
			delete m_RemoteApp;
			m_RemoteApp = NULL;
			return -1; //Application error return -1
       		 }

		// Make the server visible through automation.
		// i.e.: Application.Visible = TRUE
		DISPID dispID;
//		unsigned short *ucPtr;
		BYTE *parmStr;
//		ucPtr = L"visible";
		CString cx = "visible";
		BSTR szMember = cx.AllocSysString();
		m_RemoteApp->m_lpDispatch->GetIDsOfNames( IID_NULL, &szMember, 1, LOCALE_USER_DEFAULT, &dispID );
		::SysFreeString(szMember);
		parmStr = (BYTE *)( VTS_VARIANT );
	}		

	//Initialisation of the hardware is done in REMOTEAPP OnInitDlg() and is thus automatically called

	//Check that the communication works
	int Timeout = 5; //Timeout in seconds
	int IncTime = 1000; //increment in millisec = freqency of GetStatus Call
	CChrono Chrono;
	Chrono.InitChrono();
	Chrono.StartChrono();
	double t = 0.0f;
	while(m_RemoteApp->GetStatus() < 0 && t < Timeout) //wait 5 secs for the Status Ready
	{
		//Sleep(IncTime);
		//Timeout+=IncTime;
		Chrono.DureeChrono(t);
	}
	
	if (m_RemoteApp->GetStatus() < 0)// Communication failed
	{
		StopRemoteApplication();
		AddToErrorLog("Communication error with the hardware.");
		return -2; //Communication Error return -2
	}

	return 1;
}