#include <windows.h>

// Implement a FileStream that derives from IStream.
class FrameStream : public IStream
{
public:
    FrameStream(PBYTE pFrame, DWORD dwSize) 
    { 
        _refcount = 0; 
		_pFrameData = pFrame;
		_dwSize = dwSize;
		_dwOffset = 0;
		_pStream = 0;
//		_dwCheck = 0;
		InitializeCriticalSection (&_cs);

		// Test
//		_pFrameData = (LPBYTE)LocalAlloc (LPTR, dwSize);
//		if (!_pFrameData)
//		{
//			ASSERT (0);
//			return;
//		}
//		memcpy (_pFrameData, pFrame, dwSize);


//		for (DWORD i = 0; i < dwSize; i++)
//			_dwCheck += pFrame[i];

	    // Create the stream
   HRESULT hr = CreateStreamOnHGlobal(_pFrameData, TRUE, &_pStream);

    }

    ~FrameStream() 
    { 
//		DWORD dw = 0;
//		for (DWORD i = 0; i < _dwSize; i++)
//			dw += _pFrameData[i];
//
//		if (_dwCheck != dw)
//		{
//			DEBUGCHK ((TEXT("*********** Data corrupted!!! *************\r\n")));
//			printf ("*********** Data corrupted!!! *************\r\n");
//		}

		_pStream->Release();
//		LocalFree (_pFrameData);
		DeleteCriticalSection (&_cs);
    }

    virtual HRESULT STDMETHODCALLTYPE QueryInterface(
        REFIID iid,         // Identifier of the requested interface.
        void ** ppvObject   // Receives an indirect pointer to the object.
        ) 
    { 
        if (iid == __uuidof(IUnknown)
            || iid == __uuidof(IStream)
            || iid == __uuidof(ISequentialStream))
        {
            *ppvObject = static_cast<IStream*>(this);
            AddRef();
            return S_OK;
        } else
            return E_NOINTERFACE; 
    }

    virtual ULONG STDMETHODCALLTYPE AddRef(void) 
    { 
        return (ULONG)InterlockedIncrement(&_refcount); 
    }

    virtual ULONG STDMETHODCALLTYPE Release(void) 
    {
        ULONG res = (ULONG) InterlockedDecrement(&_refcount);
        if (res == 0) 
            delete this;
        return res;
    }

    // ISequentialStream Interface
public:
    virtual HRESULT STDMETHODCALLTYPE Read(void* pv, ULONG cb, ULONG*   pcbRead)
    {
		return _pStream->Read (pv, cb, pcbRead);


		EnterCriticalSection (&_cs);

		// Limit check
		if ((_dwOffset + cb) > _dwSize)
			cb = _dwSize - _dwOffset;

		memcpy (pv, _pFrameData, cb);
		_dwOffset += cb;
		*pcbRead = cb;

		LeaveCriticalSection (&_cs);
		return S_OK;
    }

    virtual HRESULT STDMETHODCALLTYPE Write(void const* pv, ULONG cb,   ULONG* pcbWritten)
    { 
        return E_NOTIMPL;   
    }

    // IStream Interface
public:
    virtual HRESULT STDMETHODCALLTYPE SetSize(ULARGE_INTEGER)
    { 
        return E_NOTIMPL;   
    }
    virtual HRESULT STDMETHODCALLTYPE 
        CopyTo(IStream*, ULARGE_INTEGER, ULARGE_INTEGER*, ULARGE_INTEGER*) 
    { 
        return E_NOTIMPL;   
    }
    virtual HRESULT STDMETHODCALLTYPE Commit(DWORD)                                      
    { 
        return E_NOTIMPL;   
    }
    virtual HRESULT STDMETHODCALLTYPE Revert(void)                                       
    { 
        return E_NOTIMPL;   
    }
    virtual HRESULT STDMETHODCALLTYPE LockRegion(ULARGE_INTEGER, ULARGE_INTEGER, DWORD)              
    { 
        return E_NOTIMPL;   
    }
    virtual HRESULT STDMETHODCALLTYPE UnlockRegion(ULARGE_INTEGER, ULARGE_INTEGER, DWORD)            
    { 
        return E_NOTIMPL;   
    }
    virtual HRESULT STDMETHODCALLTYPE Clone(IStream **)                                  
    { 
        return E_NOTIMPL;   
    }

    virtual HRESULT STDMETHODCALLTYPE 
        Seek(LARGE_INTEGER liDistanceToMove, DWORD dwOrigin, ULARGE_INTEGER* lpNewFilePointer)                
    { 

		return _pStream->Seek (liDistanceToMove, dwOrigin, lpNewFilePointer);


		HRESULT hr = S_OK;
		DWORD dwMove = (DWORD)liDistanceToMove.QuadPart;
        // Check to see if the origin is valid.



		EnterCriticalSection (&_cs);
        switch(dwOrigin)
        {
        case STREAM_SEEK_SET:
			if (dwMove > _dwSize)
				dwMove = _dwSize;

			_dwOffset = dwMove;
            break;
        case STREAM_SEEK_CUR:
			if ((_dwOffset + dwMove) > _dwSize)
				dwMove = _dwSize - _dwOffset;

			_dwOffset += dwMove;
            break;
        case STREAM_SEEK_END:
			if (dwMove > _dwSize)
				_dwOffset = 0;
			else
				_dwOffset = _dwSize - dwMove;
            break;
        default:   
            hr = STG_E_INVALIDFUNCTION;
            break;
        }
		LeaveCriticalSection (&_cs);
        return hr;
    }

    virtual HRESULT STDMETHODCALLTYPE Stat(STATSTG* pStatstg, DWORD grfStatFlag) 
    {
		return _pStream->Stat (pStatstg, grfStatFlag);

		pStatstg->cbSize.QuadPart = _dwSize;
        return S_OK;
    }

private:

    IStream *_pStream;
	DWORD _dwOffset;
	DWORD _dwSize;
	PBYTE _pFrameData;
    LONG _refcount;
//	DWORD _dwCheck;
	CRITICAL_SECTION _cs;
};