// avifps.cpp - proxy and stub code for IAVIFile & IAVIStream
//
//
//  Copyright (c) 1993 Microsoft Corporation.  All Rights Reserved.
//
// History:
//  Created by DavidMay		6/19/93
//
//
// What's in this file:
//
//  Code to enable "standard marshalling" of the IAVIFile and IAVIStream
//  interfaces, consisting of the following classes:
//
//  CPSFactory, derived from IPSFactory:
//	Proxy/stub factory, called from DllGetClassObject to create
//	the other classes.
//
//  CPrxAVIStream, derived from IAVIStream:
//	This class serves as a stand-in for the interface in the app that's
//	calling it.  Uses RPC to communicate with....
//
//  CStubAVIStream, derived from IRpcStubBuffer:
//	This class in the called app receives requests from the proxy
//	and forwards them to the actual implementation of the IAVIStream.
//
//  CPrxAVIFile & CStubAVIFile, just like the stream versions.
//
//
//  Also included:
//  The function TaskHasExistingProxies can be used by an application
//  before exiting to check whether any of its objects are being used
//  by other applications.  This is done by keeping track of what active
//  stubs exist within a given task context.
//

#include <win32.h>
#pragma warning(disable:4355)
#include "avifile.h"
#include "avifps.h"
#include "debug.h"

#ifndef WIN32
typedef POINT POINTS;
#endif

// when thunking between 16-bit ansi and 32-bit unicode apps, the
// AVISTREAMINFO and AVIFILEINFO structures are different. What is transmitted
// is a common format that includes space for both unicode and ansi strings.
// ansi apps will not send or use the unicode strings. unicode apps will send
// both.
typedef struct _PS_STREAMINFO {
    DWORD		fccType;
    DWORD               fccHandler;
    DWORD               dwFlags;        /* Contains AVITF_* flags */
    DWORD		dwCaps;
    WORD		wPriority;
    WORD		wLanguage;
    DWORD               dwScale;
    DWORD               dwRate; /* dwRate / dwScale == samples/second */
    DWORD               dwStart;
    DWORD               dwLength; /* In units above... */
    DWORD		dwInitialFrames;
    DWORD               dwSuggestedBufferSize;
    DWORD               dwQuality;
    DWORD               dwSampleSize;
    POINTS		ptFrameTopLeft;
    POINTS		ptFrameBottomRight;
    DWORD		dwEditCount;
    DWORD		dwFormatChangeCount;
    char		szName[64];
    DWORD		bHasUnicode;
    WCHAR		szUnicodeName[64];
} PS_STREAMINFO, FAR * LPPS_STREAMINFO;

typedef struct _PS_FILEINFO {
    DWORD		dwMaxBytesPerSec;	// max. transfer rate
    DWORD		dwFlags;		// the ever-present flags
    DWORD		dwCaps;
    DWORD		dwStreams;
    DWORD		dwSuggestedBufferSize;

    DWORD		dwWidth;
    DWORD		dwHeight;

    DWORD		dwScale;	
    DWORD		dwRate;	/* dwRate / dwScale == samples/second */
    DWORD		dwLength;

    DWORD		dwEditCount;

    char		szFileType[64];		// descriptive string for file type?
    DWORD		bHasUnicode;
    WCHAR		szUnicodeType[64];	
} PS_FILEINFO, FAR * LPPS_FILEINFO;



#ifndef WIN32
//
// These constants are defined in the 32-bit UUID.LIB, but not
// in any 16-bit LIB.  They are stolen here from the .IDL files
// in the TYPES project.
//
extern "C" {
const IID IID_IRpcStubBuffer = {0xD5F56AFC,0x593b,0x101A,{0xB5,0x69,0x08,0x00,0x2B,0x2D,0xBF,0x7A}};
const IID IID_IRpcProxyBuffer = {0xD5F56A34,0x593b,0x101A,{0xB5,0x69,0x08,0x00,0x2B,0x2D,0xBF,0x7A}};
const IID IID_IPSFactoryBuffer = {0xD5F569D0,0x593b,0x101A,{0xB5,0x69,0x08,0x00,0x2B,0x2D,0xBF,0x7A}};
}
#endif

// functions for proxy/stub usage tracking; see end of this file.
void UnregisterStubUsage(void);
void RegisterStubUsage(void);
extern "C" BOOL FAR TaskHasExistingProxies(void);



#if 0	// this function is actually in classobj.cpp,
// but if this were a separate proxy/stub DLL, it would look like this.
STDAPI DllGetClassObject(const CLSID FAR&	rclsid,
			 const IID FAR&	riid,
			 void FAR* FAR*	ppv)
{
    HRESULT	hresult;

    DPF("DllGetClassObject\n");

    if (rclsid == CLSID_AVIStreamPS) {
	return (*ppv = (LPVOID)new CPSFactory()) != NULL
		? NOERROR : ResultFromScode(E_OUTOFMEMORY);
    } else {
	return ResultFromScode(E_UNEXPECTED);
    }
}
#endif

/*
 *	IMPLEMENTATION of CPSFactory
 *
 *
 *  Note: This Factory supports proxies and stubs for two separate
 *  interfaces, IID_IAVIFile and IID_IAVIStream.
 */

CPSFactory::CPSFactory(void)
{
    m_refs = 1;
}



// controlling unknown for PSFactory
STDMETHODIMP CPSFactory::QueryInterface(REFIID iid, LPVOID FAR* ppv)
{
    if (iid == IID_IUnknown || iid == IID_IPSFactoryBuffer)
    {
	*ppv = this;
	++m_refs;
	return NOERROR;
    }
    else
    {
	*ppv = NULL;
	return ResultFromScode(E_NOINTERFACE);
    }
}

STDMETHODIMP_(ULONG) CPSFactory::AddRef(void)
{
    return ++m_refs;
}

STDMETHODIMP_(ULONG) CPSFactory::Release(void)
{
    if (--m_refs == 0)
    {
	delete this;
	return 0;
    }

    return m_refs;
}


// create proxy for given interface
STDMETHODIMP CPSFactory::CreateProxy(IUnknown FAR* pUnkOuter, REFIID iid,
	IRpcProxyBuffer FAR* FAR* ppProxy, void FAR* FAR* ppv)
{
    IRpcProxyBuffer FAR* pProxy;
    HRESULT     hresult;

    *ppProxy = NULL;
    *ppv = NULL;

    if (pUnkOuter == NULL)
	return ResultFromScode(E_INVALIDARG);

    if (iid == IID_IAVIStream) {
	if ((pProxy = CPrxAVIStream::Create(pUnkOuter)) == NULL)
	    return ResultFromScode(E_OUTOFMEMORY);
    } else if (iid == IID_IAVIFile) {
	if ((pProxy = CPrxAVIFile::Create(pUnkOuter)) == NULL)
	    return ResultFromScode(E_OUTOFMEMORY);
    } else
	return ResultFromScode(E_NOINTERFACE);

    hresult = pProxy->QueryInterface(iid, ppv);

    if (hresult == NOERROR)
	*ppProxy = pProxy;			// transfer ref to caller
    else
	pProxy->Release();			// free proxy just created

    return hresult;
}



// create stub for given interface
STDMETHODIMP CPSFactory::CreateStub(REFIID iid, IUnknown FAR* pUnkServer, IRpcStubBuffer FAR* FAR* ppStub)
{
    if (iid == IID_IAVIStream) {
	return CStubAVIStream::Create(pUnkServer, ppStub);
    } else if (iid == IID_IAVIFile) {
	return CStubAVIFile::Create(pUnkServer, ppStub);
    } else
	return ResultFromScode(E_NOINTERFACE);
}





/*
 *  IMPLEMENTATION of CPrxAVIStream
 *
 */


// create unconnected CPrxAVIStream; return controlling IProxy/IUnknokwn FAR*
IRpcProxyBuffer FAR* CPrxAVIStream::Create(IUnknown FAR* pUnkOuter)
{
    CPrxAVIStream FAR* pPrxAVIStream;

    if ((pPrxAVIStream = new CPrxAVIStream(pUnkOuter)) == NULL)
	return NULL;

    return &pPrxAVIStream->m_Proxy;
}


CPrxAVIStream::CPrxAVIStream(IUnknown FAR* pUnkOuter) : m_Proxy(this)
{
    // NOTE: could assert here since we should always be aggregated
    if (pUnkOuter == NULL)
	pUnkOuter = &m_Proxy;

    m_refs = 1;
    m_pUnkOuter = pUnkOuter;
    m_pRpcChannelBuffer = NULL;
    m_sh.fccType = 0;

    DPF("PrxStream %lx: Usage++=%lx\n", (DWORD) (LPVOID) this, 1L);
}


CPrxAVIStream::~CPrxAVIStream(void)
{
    m_Proxy.Disconnect();
}
		

// Methods for controlling unknown
STDMETHODIMP CPrxAVIStream::CProxyImpl::QueryInterface(REFIID iid, LPVOID FAR* ppv)
{
    if (iid == IID_IUnknown || iid == IID_IRpcProxyBuffer)
        *ppv = (void FAR *)this;
    else if (iid ==  IID_IAVIStream)
        *ppv = (void FAR *)m_pPrxAVIStream;
    else {
	*ppv = NULL;
	return ResultFromScode(E_NOINTERFACE);
    }

    // simplest way to be correct: always addref the pointer we will return;
    // easy since all interfaces here are derived from IUnknown.
    ((IUnknown FAR*) *ppv)->AddRef();

    return NOERROR;
}

STDMETHODIMP_(ULONG) CPrxAVIStream::CProxyImpl::AddRef(void)
{
    return ++m_pPrxAVIStream->m_refs;
}

STDMETHODIMP_(ULONG) CPrxAVIStream::CProxyImpl::Release(void)
{
    if (--m_pPrxAVIStream->m_refs == 0)
    {
	delete m_pPrxAVIStream;
	return 0;
    }
    return m_pPrxAVIStream->m_refs;
}


// connect proxy to channel given
STDMETHODIMP CPrxAVIStream::CProxyImpl::Connect(IRpcChannelBuffer FAR* pRpcChannelBuffer)
{
    if (m_pPrxAVIStream->m_pRpcChannelBuffer != NULL)
	return ResultFromScode(E_UNEXPECTED);

    if (pRpcChannelBuffer == NULL)
	return ResultFromScode(E_INVALIDARG);

    (m_pPrxAVIStream->m_pRpcChannelBuffer = pRpcChannelBuffer)->AddRef();
    return NOERROR;
}


// disconnect proxy from any current channel
STDMETHODIMP_(void) CPrxAVIStream::CProxyImpl::Disconnect(void)
{
    if (m_pPrxAVIStream->m_pRpcChannelBuffer)
    {
	m_pPrxAVIStream->m_pRpcChannelBuffer->Release();
	m_pPrxAVIStream->m_pRpcChannelBuffer = NULL;
    }
}



// IUnknown methods for external interface(s); always delegate
STDMETHODIMP CPrxAVIStream::QueryInterface(REFIID iid, LPVOID FAR* ppv)
{
    return m_pUnkOuter->QueryInterface(iid, ppv);
}

STDMETHODIMP_(ULONG) CPrxAVIStream::AddRef(void)
{
    DPF("PrxStream %lx: Usage++=%lx\n", (DWORD) (LPVOID) this, m_refs + 1);
    return m_pUnkOuter->AddRef();
}

STDMETHODIMP_(ULONG) CPrxAVIStream::Release(void)
{
    DPF("PrxStream %lx: Usage--=%lx\n", (DWORD) (LPVOID) this, m_refs - 1);
    return m_pUnkOuter->Release();
}



// IAVIStream interface methods

STDMETHODIMP CPrxAVIStream::Create(LONG lParam1, LONG lParam2)
{
    return ResultFromScode(E_NOTIMPL);
}

#ifdef WIN32
STDMETHODIMP CPrxAVIStream::Info(AVISTREAMINFOW FAR * psi, LONG lSize)
#else
STDMETHODIMP CPrxAVIStream::Info(AVISTREAMINFO FAR * psi, LONG lSize)
#endif
{
    HRESULT hrMarshal;
    HRESULT hrMethod = NOERROR;
    IRpcChannelBuffer FAR* pChannel = m_pRpcChannelBuffer;
    RPCOLEMESSAGE Message;

    _fmemset(&Message, 0, sizeof(Message));

    if (pChannel == NULL)
	return ResultFromScode(RPC_E_CONNECTION_TERMINATED);

    //
    // NOTE: We take advantage here of the fact that we assume the
    // stream is read-only and not being changed on the other end!
    //
    // To avoid some intertask calls, we assume that the result
    // of the Info() method will not change.
    //
    if (m_sh.fccType == 0) {

	// we might be talking to 16 or 32-bit stub, so we need to
	// exchange a common (superset) format and pick out the bits we need.

	// format in: lSize
	// format out: PS_STREAMINFO, hrMethod
	Message.cbBuffer = sizeof(lSize);
	Message.iMethod = IAVISTREAM_Info;
	
	if ((hrMarshal = pChannel->GetBuffer(&Message, IID_IAVIStream)) != NOERROR)
	    goto ErrExit;

	((DWORD FAR *)Message.Buffer)[0] = sizeof(PS_STREAMINFO);
	
	if ((hrMarshal = pChannel->SendReceive(&Message,(ULONG*) &hrMethod)) != NOERROR) {
	    ;
ErrExit:
	    return PropagateResult(hrMarshal, RPC_E_CLIENT_CANTMARSHAL_DATA);
	}

	hrMethod = ((HRESULT FAR *)Message.Buffer)[0];
	PS_STREAMINFO FAR * psinfo = (PS_STREAMINFO FAR *)
			((LPBYTE)Message.Buffer + sizeof(HRESULT));

	// get the bits we want
	m_sh.fccType 	= psinfo->fccType;
	m_sh.fccHandler = psinfo->fccHandler;
	m_sh.dwFlags 	= psinfo->dwFlags;        /* Contains AVITF_* flags */
	m_sh.dwCaps 	= psinfo->dwCaps;
	m_sh.wPriority 	= psinfo->wPriority;
	m_sh.wLanguage 	= psinfo->wLanguage;
	m_sh.dwScale 	= psinfo->dwScale;
	m_sh.dwRate 	= psinfo->dwRate; /* dwRate / dwScale == samples/second */
	m_sh.dwStart 	= psinfo->dwStart;
	m_sh.dwLength 	= psinfo->dwLength; /* In units above... */
	m_sh.dwInitialFrames = psinfo->dwInitialFrames;
	m_sh.dwSuggestedBufferSize = psinfo->dwSuggestedBufferSize;
	m_sh.dwQuality 	= psinfo->dwQuality;
	m_sh.dwSampleSize = psinfo->dwSampleSize;

	// RECTs are different sizes, so use POINTS (WORD point)
	m_sh.rcFrame.top = psinfo->ptFrameTopLeft.y;	
	m_sh.rcFrame.left = psinfo->ptFrameTopLeft.x;
	m_sh.rcFrame.bottom = psinfo->ptFrameBottomRight.y;	
	m_sh.rcFrame.right = psinfo->ptFrameBottomRight.x;

    	m_sh.dwEditCount = psinfo->dwEditCount;
    	m_sh.dwFormatChangeCount = psinfo->dwFormatChangeCount;

#ifdef WIN32	
	// use unicode if we've been sent it
	if (psinfo->bHasUnicode) {
	    _fmemcpy(m_sh.szName, psinfo->szUnicodeName, sizeof(m_sh.szName));
	} else {
	    // need ansi->unicode thunk
	    MultiByteToWideChar(
	    	CP_ACP, 0,
		psinfo->szName,
	     	-1,
		m_sh.szName,
		NUMELMS(m_sh.szName));
	}
#else
    	// we only use the ansi which is always sent
	_fmemcpy(m_sh.szName, psinfo->szName, sizeof(m_sh.szName));
#endif

	pChannel->FreeBuffer(&Message);
    }

    _fmemcpy(psi, &m_sh, min((int) lSize, sizeof(m_sh)));

    return hrMethod;
}


STDMETHODIMP_(LONG) CPrxAVIStream::FindSample(LONG lPos, LONG lFlags)
{
    HRESULT hrMarshal;
    HRESULT hrMethod;
    IRpcChannelBuffer FAR* pChannel = m_pRpcChannelBuffer;
    LONG    lResult;

    if (pChannel == NULL)
	return -1; // !!! ResultFromScode(RPC_E_CONNECTION_TERMINATED);

    RPCOLEMESSAGE Message;

    _fmemset(&Message, 0, sizeof(Message));

    // format in: lPos, lFlags
    // format out: hrMethod, lResult
    Message.cbBuffer = sizeof(lPos) + sizeof(lFlags);
    Message.iMethod = IAVISTREAM_FindSample;

    if ((hrMarshal = pChannel->GetBuffer(&Message, IID_IAVIStream)) != NOERROR)
	goto ErrExit;

    ((DWORD FAR *)Message.Buffer)[0] = lPos;
    ((DWORD FAR *)Message.Buffer)[1] = lFlags;

    if ((hrMarshal = pChannel->SendReceive(&Message, (ULONG*) &hrMethod)) != NOERROR) {
	goto ErrExit;
    }

    hrMethod = ((HRESULT FAR *)Message.Buffer)[0];
    lResult = ((LONG FAR *)Message.Buffer)[1];

    pChannel->FreeBuffer(&Message);

    DPF("Proxy: FindSample (%ld) returns (%ld)\n", lPos, lResult);
    return lResult; // !!! hrMethod;

ErrExit:
    DPF("Proxy: FindSample returning error...\n");
    return -1; // !!! PropagateResult(hrMarshal, RPC_E_CLIENT_CANTMARSHAL_DATA);
}


STDMETHODIMP CPrxAVIStream::ReadFormat(LONG lPos, LPVOID lpFormat, LONG FAR *lpcbFormat)
{
    HRESULT hrMarshal;
    HRESULT hrMethod;
    IRpcChannelBuffer FAR* pChannel = m_pRpcChannelBuffer;

    if (pChannel == NULL)
	return ResultFromScode(RPC_E_CONNECTION_TERMINATED);

    // check that size is 0 if pointer is null
    if (lpFormat == NULL) {
	*lpcbFormat = 0;
    }

    // format in: dw, *lpcbFormat
    // format out: hrMethod, *lpcbFormat, format data

    RPCOLEMESSAGE Message;

    _fmemset(&Message, 0, sizeof(Message));

    Message.cbBuffer = sizeof(lPos) + sizeof(*lpcbFormat);
    Message.iMethod = IAVISTREAM_ReadFormat;

    if ((hrMarshal = pChannel->GetBuffer(&Message, IID_IAVIStream)) != NOERROR)
	goto ErrExit;

    ((DWORD FAR *)Message.Buffer)[0] = lPos;
    ((DWORD FAR *)Message.Buffer)[1] = lpFormat ? *lpcbFormat : 0;

    if ((hrMarshal = pChannel->SendReceive(&Message, (ULONG*) &hrMethod)) != NOERROR) {
	goto ErrExit;
    }

    hrMethod = ((HRESULT FAR *)Message.Buffer)[0];

    if (lpFormat && *lpcbFormat)
	hmemcpy(lpFormat, (LPBYTE) Message.Buffer + 2*sizeof(DWORD),
		min(*lpcbFormat, (long) ((DWORD FAR *) Message.Buffer)[1]));

    // write the size last, so we don't copy more than user's buffer
    *lpcbFormat = ((DWORD FAR *)Message.Buffer)[1];

    pChannel->FreeBuffer(&Message);

    return hrMethod;

ErrExit:
    return PropagateResult(hrMarshal, RPC_E_CLIENT_CANTMARSHAL_DATA);
}


STDMETHODIMP CPrxAVIStream::Read(
                 LONG       lStart,
                 LONG       lSamples,
                 LPVOID     lpBuffer,
                 LONG       cbBuffer,
                 LONG FAR * plBytes,
                 LONG FAR * plSamples)
{
    HRESULT hrMarshal;
    HRESULT hrMethod;
    IRpcChannelBuffer FAR* pChannel = m_pRpcChannelBuffer;
    LONG    lTemp;

    if (pChannel == NULL)
	return ResultFromScode(RPC_E_CONNECTION_TERMINATED);

    if (lpBuffer == NULL)
	cbBuffer = 0;

    // format on input: lPos, lLength, cb
    // format on output: hresult, samples, cb, frame
    RPCOLEMESSAGE Message;

    _fmemset(&Message, 0, sizeof(Message));

    Message.cbBuffer = sizeof(lStart) + sizeof(lSamples) + sizeof(cbBuffer);
    Message.iMethod = IAVISTREAM_Read;

    if ((hrMarshal = pChannel->GetBuffer(&Message, IID_IAVIStream)) != NOERROR)
	goto ErrExit;

    ((DWORD FAR *)Message.Buffer)[0] = lStart;
    ((DWORD FAR *)Message.Buffer)[1] = lSamples;
    ((DWORD FAR *)Message.Buffer)[2] = lpBuffer ? cbBuffer : 0;

    if ((hrMarshal = pChannel->SendReceive(&Message, (ULONG*) &hrMethod)) != NOERROR) {
	goto ErrExit;
    }

    hrMethod = ((HRESULT FAR *)Message.Buffer)[0];

    lTemp = ((DWORD FAR *)Message.Buffer)[1];
    if (plBytes)
	*plBytes = lTemp;

    if (plSamples)
	*plSamples = ((DWORD FAR *)Message.Buffer)[2];

    if (lpBuffer && lTemp)
	hmemcpy(lpBuffer, (LPBYTE) Message.Buffer + 3*sizeof(DWORD), lTemp);

    pChannel->FreeBuffer(&Message);

    return hrMethod;

ErrExit:
    return PropagateResult(hrMarshal, RPC_E_CLIENT_CANTMARSHAL_DATA);
}

//
// All of the writing-related messages are not remoted....
//
STDMETHODIMP CPrxAVIStream::SetFormat(LONG lPos,LPVOID lpFormat,LONG cbFormat)
{
    return ResultFromScode(E_NOTIMPL);
}


STDMETHODIMP CPrxAVIStream::Write(LONG lStart,
				  LONG lSamples,
				  LPVOID lpData,
				  LONG cbData,
				  DWORD dwFlags,
				  LONG FAR *plSampWritten,
				  LONG FAR *plBytesWritten)
{
    return ResultFromScode(E_NOTIMPL);
}


STDMETHODIMP CPrxAVIStream::Delete(LONG lStart,LONG lSamples)
{
    return ResultFromScode(E_NOTIMPL);
}


STDMETHODIMP CPrxAVIStream::ReadData(DWORD ckid, LPVOID lp, LONG FAR *lpcb)
{
    // !!! This should really be remoted!
    return ResultFromScode(E_NOTIMPL);
}


STDMETHODIMP CPrxAVIStream::WriteData(DWORD ckid, LPVOID lp, LONG cb)
{
    return ResultFromScode(E_NOTIMPL);
}


#ifdef WIN32
STDMETHODIMP CPrxAVIStream::SetInfo(AVISTREAMINFOW FAR *lpInfo, LONG cbInfo)
{
    return ResultFromScode(E_NOTIMPL);
}

#else
STDMETHODIMP CPrxAVIStream::Reserved1(void)
{
    return ResultFromScode(E_NOTIMPL);
}


STDMETHODIMP CPrxAVIStream::Reserved2(void)
{
    return ResultFromScode(E_NOTIMPL);
}


STDMETHODIMP CPrxAVIStream::Reserved3(void)
{
    return ResultFromScode(E_NOTIMPL);
}


STDMETHODIMP CPrxAVIStream::Reserved4(void)
{
    return ResultFromScode(E_NOTIMPL);
}


STDMETHODIMP CPrxAVIStream::Reserved5(void)
{
    return ResultFromScode(E_NOTIMPL);
}

#endif


/*
 *  IMPLEMENTATION of CStubAVIStream
 *	
 */

// create connected interface stub
HRESULT CStubAVIStream::Create(IUnknown FAR* pUnkObject, IRpcStubBuffer FAR* FAR* ppStub)
{
    CStubAVIStream FAR* pStubAVIStream;

    *ppStub = NULL;

    if ((pStubAVIStream = new CStubAVIStream()) == NULL)
	return ResultFromScode(E_OUTOFMEMORY);

    HRESULT hresult;
    if ((hresult = pStubAVIStream->Connect(pUnkObject)) != NOERROR)
    {
	pStubAVIStream->Release();
	return hresult;
    }

    *ppStub = pStubAVIStream;
    return NOERROR;
}


CStubAVIStream::CStubAVIStream(void)
{
    m_refs	 = 1; /// !!! ??? 0
    DPF("StubStream %lx: Usage++=%lx  (C)\n", (DWORD) (LPVOID) this, 1L);
    m_pAVIStream = NULL;
    RegisterStubUsage();
}


CStubAVIStream::~CStubAVIStream(void)
{
    UnregisterStubUsage();
    Disconnect();
}


// controling unknown methods for interface stub
STDMETHODIMP CStubAVIStream::QueryInterface(REFIID iid, LPVOID FAR* ppv)
{

    if (iid == IID_IUnknown || iid == IID_IRpcStubBuffer)
    {
	*ppv = this;
	DPF("StubStream %lx: Usage++=%lx  (QI)\n", (DWORD) (LPVOID) this, m_refs + 1);
	++m_refs;
	return NOERROR;
    }
    else
    {
	*ppv = NULL;
	return ResultFromScode(E_NOINTERFACE);
    }
}

STDMETHODIMP_(ULONG) CStubAVIStream::AddRef(void)
{
    DPF("StubStream %lx: Usage++=%lx\n", (DWORD) (LPVOID) this, m_refs + 1);
    return ++m_refs;
}

STDMETHODIMP_(ULONG) CStubAVIStream::Release(void)
{
    DPF("StubStream %lx: Usage--=%lx\n", (DWORD) (LPVOID) this, m_refs - 1);
    if (--m_refs == 0)
    {
	if (m_pAVIStream) {
	    DPF("Releasing stream in funny place!\n");
	    m_pAVIStream->Release();
	    m_pAVIStream = NULL;
	}
	delete this;
	return 0;
    }

    return m_refs;
}


// connect interface stub to server object
STDMETHODIMP CStubAVIStream::Connect(IUnknown FAR* pUnkObj)
{
    HRESULT	hr;

    if (m_pAVIStream)
	// call Disconnect first
	return ResultFromScode(E_UNEXPECTED);

    if (pUnkObj == NULL)
	return ResultFromScode(E_INVALIDARG);
		
    // NOTE: QI ensures out param is zero if error
    hr = pUnkObj->QueryInterface(IID_IAVIStream, (LPVOID FAR*)&m_pAVIStream);

    DPF("CStubAVIStream::Connect: Result = %lx, stream = %lx\n", (DWORD) (LPVOID) hr, (DWORD) m_pAVIStream);
    return hr;
}


// disconnect interface stub from server objec
STDMETHODIMP_(void) CStubAVIStream::Disconnect(void)
{
    DPF("CStubAVIStream::Disconnect\n");
    if (m_pAVIStream) {
	DPF("Disconnect: Releasing stream\n");
	m_pAVIStream->Release();
	m_pAVIStream = NULL;
    }
}


// remove method call
STDMETHODIMP CStubAVIStream::Invoke
	(RPCOLEMESSAGE FAR *pMessage, IRpcChannelBuffer FAR *pChannel)
{
    HRESULT     hresult;
    HRESULT	hrMethod;

    DPF("!AVISTREAM: Invoke: ");

    if (!m_pAVIStream) {
	DPF("!No stream!\n");
	return ResultFromScode(RPC_E_UNEXPECTED);
    }

#if 0
    if (iid != IID_IAVIStream) {
	DPF("!Wrong interface\n");

	return ResultFromScode(RPC_E_UNEXPECTED);
    }
#endif

    switch (pMessage->iMethod)
    {
	case IAVISTREAM_Info:
	    // format on input: lSize
	    // format on output: hresult, PS_STREAMINFO
	{
	    DWORD lSize;
#ifdef WIN32
	    AVISTREAMINFOW si;
#else
	    AVISTREAMINFO si;
#endif

	    DPF("!Info\n");

	    // need to send a common ansi/unicode version with both strings
	    PS_STREAMINFO psinfo;
	    hrMethod = m_pAVIStream->Info(&si, sizeof(si));

	    // copy all members
	    psinfo.fccType	= si.fccType;
	    psinfo.fccHandler	= si.fccHandler;
	    psinfo.dwFlags	= si.dwFlags;        /* Contains AVITF_* flags */
	    psinfo.dwCaps	= si.dwCaps;
	    psinfo.wPriority	= si.wPriority;
	    psinfo.wLanguage	= si.wLanguage;
	    psinfo.dwScale	= si.dwScale;
	    psinfo.dwRate	= si.dwRate; /* dwRate / dwScale == samples/second */
	    psinfo.dwStart	= si.dwStart;
	    psinfo.dwLength	= si.dwLength; /* In units above... */
	    psinfo.dwInitialFrames	= si.dwInitialFrames;
	    psinfo.dwSuggestedBufferSize	= si.dwSuggestedBufferSize;
	    psinfo.dwQuality	= si.dwQuality;
	    psinfo.dwSampleSize	= si.dwSampleSize;
	    psinfo.dwEditCount	= si.dwEditCount;
	    psinfo.dwFormatChangeCount	= si.dwFormatChangeCount;

	    // RECT is different size, so use POINTS
	    psinfo.ptFrameTopLeft.x = (short) si.rcFrame.left;
	    psinfo.ptFrameTopLeft.y = (short) si.rcFrame.top;
	    psinfo.ptFrameBottomRight.x = (short) si.rcFrame.right;
	    psinfo.ptFrameBottomRight.y = (short) si.rcFrame.bottom;

#ifdef WIN32	
	    // send both UNICODE and ansi
	    hmemcpy(psinfo.szUnicodeName, si.szName, sizeof(psinfo.szUnicodeName));
	    psinfo.bHasUnicode = TRUE;
	    WideCharToMultiByte(CP_ACP, 0,
	    	si.szName,
		-1,
		psinfo.szName,
		NUMELMS(psinfo.szName),
		NULL, NULL);
#else
    	    // just send ansi version for 16-bit stub
	    psinfo.bHasUnicode = FALSE;
	    hmemcpy(psinfo.szName, si.szName, sizeof(si.szName));
#endif

	    lSize = ((DWORD FAR *)pMessage->Buffer)[0];


	    pMessage->cbBuffer = lSize + sizeof(hrMethod);
	
	    if ((hresult = pChannel->GetBuffer(pMessage, IID_IAVIStream)) != NOERROR)
		return PropagateResult(hresult, RPC_E_SERVER_CANTUNMARSHAL_DATA);

	    ((HRESULT FAR *)pMessage->Buffer)[0] = hrMethod;

	    hmemcpy((LPBYTE) pMessage->Buffer + sizeof(hrMethod),
		    &psinfo,
		    lSize);
		
	    return NOERROR;
	}

	case IAVISTREAM_FindSample:
	    // format on input: lPos, lFlags
	    // format on output: hResult, lResult
	{
	    LONG lPos, lFlags, lResult;

	    lPos = ((DWORD FAR *)pMessage->Buffer)[0];
	    lFlags = ((DWORD FAR *)pMessage->Buffer)[1];

	    DPF("!FindSample (%ld)\n", lPos);
	
	    lResult = m_pAVIStream->FindSample(lPos, lFlags);

	    hrMethod = 0; // !!!

	    pMessage->cbBuffer = sizeof(lResult) + sizeof(hrMethod);
	
	    if ((hresult = pChannel->GetBuffer(pMessage, IID_IAVIStream)) != NOERROR)
		return PropagateResult(hresult, RPC_E_SERVER_CANTUNMARSHAL_DATA);

	    ((HRESULT FAR *)pMessage->Buffer)[0] = hrMethod;
	    ((DWORD FAR *)pMessage->Buffer)[1] = lResult;

	    return NOERROR;
	}

	case IAVISTREAM_ReadFormat:
	    // format on input: lPos, cbFormat
	    // format on output: hresult, cbFormat, format
	{

	    LONG cbIn;
	    LONG cb;
	    DWORD lPos;
	    LPVOID lp;

	    lPos = ((DWORD FAR *)pMessage->Buffer)[0];
	    cb = cbIn = ((DWORD FAR *)pMessage->Buffer)[1];
	
	    DPF("!ReadFormat (%ld)\n", lPos);
	
	    pMessage->cbBuffer = sizeof(cbIn) + cbIn + sizeof(hrMethod);
	
	    if ((hresult = pChannel->GetBuffer(pMessage, IID_IAVIStream)) != NOERROR)
		return PropagateResult(hresult, RPC_E_SERVER_CANTUNMARSHAL_DATA);

	    lp = cbIn ? (LPBYTE) pMessage->Buffer + 2 * sizeof(DWORD) : NULL;
	
	    hrMethod = m_pAVIStream->ReadFormat(lPos, lp, &cb);

	    ((HRESULT FAR *)pMessage->Buffer)[0] = hrMethod;
	    ((DWORD FAR *)pMessage->Buffer)[1] = cb;
	    pMessage->cbBuffer = sizeof(cbIn) + sizeof(hrMethod) +
				 ((cb && cbIn) ? cb : 0);

	    return NOERROR;
	}

	case IAVISTREAM_Read:
	    // format on input: lPos, lSamples, cb
	    // format on output: hresult, samples, cb, frame
	{

	    LONG cb;
	    LONG lPos, lSamples;
	    LPVOID lp;


	    lPos = ((DWORD FAR *)pMessage->Buffer)[0];
	    lSamples = ((DWORD FAR *)pMessage->Buffer)[1];
	    cb = ((DWORD FAR *)pMessage->Buffer)[2];
	
	    DPF("!Read (%ld, %ld) ", lPos, lSamples);

	    pMessage->cbBuffer = 3 * sizeof(DWORD) + cb;
	
	    if ((hresult = pChannel->GetBuffer(pMessage, IID_IAVIStream)) != NOERROR)
		return PropagateResult(hresult, RPC_E_SERVER_CANTUNMARSHAL_DATA);

	    lp = cb ? (LPBYTE) pMessage->Buffer + 3 * sizeof(DWORD) : NULL;

            DPF("! %ld bytes ");

	    hrMethod = m_pAVIStream->Read(lPos, lSamples, lp, cb, &cb, &lSamples);

            DPF("! -> %ld bytes\n");

	    ((HRESULT FAR *)pMessage->Buffer)[0] = hrMethod;
	    ((DWORD FAR *)pMessage->Buffer)[1] = cb;
	    ((DWORD FAR *)pMessage->Buffer)[2] = lSamples;

	    return NOERROR;
	}

	default:
	    // unknown method
	
	    DPF("!Unknown method (%d)\n", pMessage->iMethod);

	    return ResultFromScode(RPC_E_UNEXPECTED);
    }
}


// return TRUE if we support given interface
STDMETHODIMP_(IRpcStubBuffer FAR *) CStubAVIStream::IsIIDSupported(REFIID iid)
{
    // if we are connected, we have already checked for this interface;
    // if we are not connected, it doesn't matter.
    return iid == IID_IAVIStream ? (IRpcStubBuffer *) this : 0;
}


// returns number of refs we have to object
STDMETHODIMP_(ULONG) CStubAVIStream::CountRefs(void)
{
    // return 1 if connected; 0 if not.
    return m_pAVIStream != NULL;
}

STDMETHODIMP CStubAVIStream::DebugServerQueryInterface(LPVOID FAR *ppv)
{
    *ppv = m_pAVIStream;

    if (!m_pAVIStream) {
	DPF("!No stream!\n");
	return ResultFromScode(E_UNEXPECTED);
    }

    return NOERROR;
}

STDMETHODIMP_(void) CStubAVIStream::DebugServerRelease(LPVOID pv)
{


}




/*
 *  IMPLEMENTATION of CPrxAVIFile
 *
 */


// create unconnected CPrxAVIFile; return controlling IProxy/IUnknokwn FAR*
IRpcProxyBuffer FAR* CPrxAVIFile::Create(IUnknown FAR* pUnkOuter)
{
    CPrxAVIFile FAR* pPrxAVIFile;

    if ((pPrxAVIFile = new CPrxAVIFile(pUnkOuter)) == NULL)
		return NULL;

    return &pPrxAVIFile->m_Proxy;
}


CPrxAVIFile::CPrxAVIFile(IUnknown FAR* pUnkOuter) : m_Proxy(this)
{
    // NOTE: could assert here since we should always be aggregated
    if (pUnkOuter == NULL)
	pUnkOuter = &m_Proxy;

    m_refs = 1;
    m_pUnkOuter = pUnkOuter;
    m_pRpcChannelBuffer = NULL;
    m_fi.dwStreams = 0;
}


CPrxAVIFile::~CPrxAVIFile(void)
{
    m_Proxy.Disconnect();
}


// Methods for controlling unknown
STDMETHODIMP CPrxAVIFile::CProxyImpl::QueryInterface(REFIID iid, LPVOID FAR* ppv)
{
    if (iid == IID_IUnknown || iid == IID_IRpcProxyBuffer)
	*ppv = (void FAR *)this;
    else if (iid ==  IID_IAVIFile)
	*ppv = (void FAR *)m_pPrxAVIFile;
    else
    {
	*ppv = NULL;
	return ResultFromScode(E_NOINTERFACE);
    }

    // simplest way to be correct: always addref the pointer we will return;
    // easy since all interfaces here are derived from IUnknown.
    ((IUnknown FAR*) *ppv)->AddRef();
    return NOERROR;
}

STDMETHODIMP_(ULONG) CPrxAVIFile::CProxyImpl::AddRef(void)
{
    return ++m_pPrxAVIFile->m_refs;
}

STDMETHODIMP_(ULONG) CPrxAVIFile::CProxyImpl::Release(void)
{
    if (--m_pPrxAVIFile->m_refs == 0)
    {
	delete m_pPrxAVIFile;
	return 0;
    }
    return m_pPrxAVIFile->m_refs;
}


// connect proxy to channel given
STDMETHODIMP CPrxAVIFile::CProxyImpl::Connect(IRpcChannelBuffer FAR* pChannelChannelBuffer)
{
    if (m_pPrxAVIFile->m_pRpcChannelBuffer != NULL)
	return ResultFromScode(E_UNEXPECTED);

    if (pChannelChannelBuffer == NULL)
	return ResultFromScode(E_INVALIDARG);

    (m_pPrxAVIFile->m_pRpcChannelBuffer = pChannelChannelBuffer)->AddRef();
    return NOERROR;
}


// disconnect proxy from any current channel
STDMETHODIMP_(void) CPrxAVIFile::CProxyImpl::Disconnect(void)
{
    if (m_pPrxAVIFile->m_pRpcChannelBuffer)
    {
	m_pPrxAVIFile->m_pRpcChannelBuffer->Release();
	m_pPrxAVIFile->m_pRpcChannelBuffer = NULL;
    }
}



// IUnknown methods for external interface(s); always delegate
STDMETHODIMP CPrxAVIFile::QueryInterface(REFIID iid, LPVOID FAR* ppv)
{
    return m_pUnkOuter->QueryInterface(iid, ppv);
}

STDMETHODIMP_(ULONG) CPrxAVIFile::AddRef(void)
{
    return m_pUnkOuter->AddRef();
}

STDMETHODIMP_(ULONG) CPrxAVIFile::Release(void)
{
    return m_pUnkOuter->Release();
}



// IAVIFile interface methods

#ifdef WIN32
STDMETHODIMP CPrxAVIFile::Info(AVIFILEINFOW FAR * psi, LONG lSize)
#else
STDMETHODIMP CPrxAVIFile::Info(AVIFILEINFO FAR * psi, LONG lSize)
#endif
{
    HRESULT hrMarshal;
    HRESULT hrMethod = NOERROR;
    IRpcChannelBuffer FAR* pChannel = m_pRpcChannelBuffer;

    if (pChannel == NULL)
	return ResultFromScode(RPC_E_CONNECTION_TERMINATED);

    if (m_fi.dwStreams == 0) {
	RPCOLEMESSAGE Message;

	_fmemset(&Message, 0, sizeof(Message));

	// format in: lSize
	// format out: hrMethod, PS_FILEINFO
	Message.cbBuffer = sizeof(lSize);
	Message.iMethod = IAVIFILE_Info;
	
	if ((hrMarshal = pChannel->GetBuffer(&Message, IID_IAVIFile)) != NOERROR)
	    goto ErrExit;

	((DWORD FAR *)Message.Buffer)[0] = sizeof(PS_FILEINFO);
	
	if ((hrMarshal = pChannel->SendReceive(&Message, (ULONG*) &hrMethod)) != NOERROR) {
	    ;
ErrExit:
	    return PropagateResult(hrMarshal, RPC_E_CLIENT_CANTMARSHAL_DATA);
	}

	hrMethod = ((HRESULT FAR *)Message.Buffer)[0];

	PS_FILEINFO FAR * psinfo = (PS_FILEINFO FAR *)
			((LPBYTE)Message.Buffer + sizeof(HRESULT));

	// get the bits we want
	m_fi.dwMaxBytesPerSec	= psinfo->dwMaxBytesPerSec;	// max. transfer rate
	m_fi.dwFlags	= psinfo->dwFlags;		// the ever-present flags
	m_fi.dwCaps	= psinfo->dwCaps;
	m_fi.dwStreams	= psinfo->dwStreams;
	m_fi.dwSuggestedBufferSize = psinfo->dwSuggestedBufferSize;
	m_fi.dwWidth	= psinfo->dwWidth;
	m_fi.dwHeight	= psinfo->dwHeight;
	m_fi.dwScale	= psinfo->dwScale;	
	m_fi.dwRate	= psinfo->dwRate;	/* dwRate / dwScale == samples/second */
	m_fi.dwLength	= psinfo->dwLength;
	m_fi.dwEditCount = psinfo->dwEditCount;


#ifdef WIN32	
	// use unicode if we've been sent it
	if (psinfo->bHasUnicode) {
	    _fmemcpy(m_fi.szFileType,
	    	psinfo->szUnicodeType, sizeof(m_fi.szFileType));
	} else {
	    // need ansi->unicode thunk
	    MultiByteToWideChar(
	    	CP_ACP, 0,
		psinfo->szFileType,
	     	-1,
		m_fi.szFileType,
		NUMELMS(m_fi.szFileType));
	}
#else
    	// we only use the ansi which is always sent
	_fmemcpy(m_fi.szFileType, psinfo->szFileType, sizeof(m_fi.szFileType));
#endif

	pChannel->FreeBuffer(&Message);
    }

    _fmemcpy(psi, &m_fi, min((int) lSize, sizeof(m_fi)));

    return hrMethod;

}

#ifndef WIN32
STDMETHODIMP CPrxAVIFile::Open(LPCTSTR szFile, UINT mode)
{
    return ResultFromScode(E_NOTIMPL);
}
#endif

STDMETHODIMP CPrxAVIFile::GetStream(PAVISTREAM FAR * ppStream,
				     DWORD fccType,
                                     LONG lParam)
{
    HRESULT hrMarshal;
    HRESULT hrMethod = NOERROR;
    IRpcChannelBuffer FAR* pChannel = m_pRpcChannelBuffer;

    if (pChannel == NULL)
	return ResultFromScode(RPC_E_CONNECTION_TERMINATED);

    RPCOLEMESSAGE Message;

    _fmemset(&Message, 0, sizeof(Message));

    // format in: fccType lParam
    // format out: returned interface (marshalled)
    Message.cbBuffer = sizeof(fccType) + sizeof(lParam);
    Message.iMethod = IAVIFILE_GetStream;

    if ((hrMarshal = pChannel->GetBuffer(&Message, IID_IAVIFile)) != NOERROR)
	goto ErrExit;

    ((DWORD FAR *)Message.Buffer)[0] = fccType;
    ((DWORD FAR *)Message.Buffer)[1] = lParam;

    if ((hrMarshal = pChannel->SendReceive(&Message, (ULONG*) &hrMethod)) != NOERROR) {
	;
ErrExit:
	return PropagateResult(hrMarshal, RPC_E_CLIENT_CANTMARSHAL_DATA);
    }

    hrMethod = ((HRESULT FAR *)Message.Buffer)[0];

    if (hrMethod == NOERROR) {
	HGLOBAL	    h;
	LPSTREAM    pstm;

	h = GlobalAlloc(GHND, Message.cbBuffer - sizeof(hrMethod));

	hmemcpy(GlobalLock(h),
		(LPBYTE) Message.Buffer + sizeof(hrMethod),
		Message.cbBuffer - sizeof(hrMethod));

	CreateStreamOnHGlobal(h, FALSE, &pstm);
	
	CoUnmarshalInterface(pstm, IID_IAVIStream, (LPVOID FAR *) ppStream);

	pstm->Release();

	pChannel->FreeBuffer(&Message);
    }

    return hrMethod;
}

STDMETHODIMP CPrxAVIFile::CreateStream(
                                     PAVISTREAM FAR * ppStream,
#ifdef WIN32
                                     AVISTREAMINFOW FAR * psi)
#else
                                     AVISTREAMINFO FAR * psi)
#endif
{
    return ResultFromScode(E_NOTIMPL);
}

#ifndef WIN32
STDMETHODIMP CPrxAVIFile::Save(
                                     LPCTSTR szFile,
                                     AVICOMPRESSOPTIONS FAR *lpOptions,
                                     AVISAVECALLBACK lpfnCallback)
{

    return ResultFromScode(E_NOTIMPL);
}
#endif


STDMETHODIMP CPrxAVIFile::ReadData(DWORD ckid, LPVOID lp, LONG FAR *lpcb)
{
    return ResultFromScode(E_NOTIMPL);
}


STDMETHODIMP CPrxAVIFile::WriteData(DWORD ckid, LPVOID lp, LONG cb)
{
    return ResultFromScode(E_NOTIMPL);
}

STDMETHODIMP CPrxAVIFile::EndRecord()
{
    return ResultFromScode(E_NOTIMPL);
}

#ifdef WIN32
STDMETHODIMP CPrxAVIFile::DeleteStream(DWORD fccType, LONG lParam)
{
    return ResultFromScode(AVIERR_UNSUPPORTED);
}
#else
STDMETHODIMP CPrxAVIFile::Reserved1(void)
{
    return ResultFromScode(E_NOTIMPL);
}


STDMETHODIMP CPrxAVIFile::Reserved2(void)
{
    return ResultFromScode(E_NOTIMPL);
}


STDMETHODIMP CPrxAVIFile::Reserved3(void)
{
    return ResultFromScode(E_NOTIMPL);
}


STDMETHODIMP CPrxAVIFile::Reserved4(void)
{
    return ResultFromScode(E_NOTIMPL);
}


STDMETHODIMP CPrxAVIFile::Reserved5(void)
{
    return ResultFromScode(E_NOTIMPL);
}

#endif


/*
 *  IMPLEMENTATION of CStubAVIFile
 *	
 */

// create connected interface stub
HRESULT CStubAVIFile::Create(IUnknown FAR* pUnkObject, IRpcStubBuffer FAR* FAR* ppStub)
{
	CStubAVIFile FAR* pStubAVIFile;

	*ppStub = NULL;

    if ((pStubAVIFile = new CStubAVIFile()) == NULL)
		return ResultFromScode(E_OUTOFMEMORY);

	HRESULT hresult;
	if ((hresult = pStubAVIFile->Connect(pUnkObject)) != NOERROR)
	{
		pStubAVIFile->Release();
		return hresult;
	}

	*ppStub = pStubAVIFile;
	return NOERROR;
}


CStubAVIFile::CStubAVIFile(void)
{
    m_refs = 1;
    m_pAVIFile = NULL;
    RegisterStubUsage();
}


CStubAVIFile::~CStubAVIFile(void)
{
    UnregisterStubUsage();
    Disconnect();
}


// controling unknown methods for interface stub
STDMETHODIMP CStubAVIFile::QueryInterface(REFIID iid, LPVOID FAR* ppv)
{

    if (iid == IID_IUnknown || iid == IID_IRpcStubBuffer)
    {
	*ppv = this;
	++m_refs;
	return NOERROR;
    }
    else
    {
	*ppv = NULL;
	return ResultFromScode(E_NOINTERFACE);
    }
}

STDMETHODIMP_(ULONG) CStubAVIFile::AddRef(void)
{
	return ++m_refs;
}

STDMETHODIMP_(ULONG) CStubAVIFile::Release(void)
{
	if (--m_refs == 0)
	{
		delete this;
		return 0;
	}

	return m_refs;
}


// connect interface stub to server object
STDMETHODIMP CStubAVIFile::Connect(IUnknown FAR* pUnkObj)
{
	if (m_pAVIFile)
		// call Disconnect first
		return ResultFromScode(E_UNEXPECTED);

	if (pUnkObj == NULL)
		return ResultFromScode(E_INVALIDARG);
		
	// NOTE: QI ensures out param is zero if error
	return pUnkObj->QueryInterface(IID_IAVIFile, (LPVOID FAR*)&m_pAVIFile);
}


// disconnect interface stub from server objec
STDMETHODIMP_(void) CStubAVIFile::Disconnect(void)
{
	if (m_pAVIFile) {
		m_pAVIFile->Release();
		m_pAVIFile = NULL;
	}
}


// remove method call
STDMETHODIMP CStubAVIFile::Invoke
	(RPCOLEMESSAGE FAR *pMessage, IRpcChannelBuffer FAR *pChannel)
{
    HRESULT     hresult;
    HRESULT		hrMethod;
	
    if (!m_pAVIFile)
	return ResultFromScode(RPC_E_UNEXPECTED);

#if 0
    if (iid != IID_IAVIFile)
	return ResultFromScode(RPC_E_UNEXPECTED);
#endif

    switch (pMessage->iMethod)
    {
	case IAVIFILE_Info:
	    // format on input: lSize
	    // format on output: hresult, AVIFILEINFO
	{
	    DWORD lSize;
#ifdef WIN32
	    AVIFILEINFOW si;
#else
	    AVIFILEINFO si;
#endif
	    PS_FILEINFO psinfo;
	    hrMethod = m_pAVIFile->Info(&si, sizeof(si));

	    // copy all members
	    psinfo.dwMaxBytesPerSec	= si.dwMaxBytesPerSec;
	    psinfo.dwFlags	= si.dwFlags;
	    psinfo.dwCaps	= si.dwCaps;
	    psinfo.dwStreams	= si.dwStreams;
	    psinfo.dwSuggestedBufferSize	= si.dwSuggestedBufferSize;
	    psinfo.dwWidth	= si.dwWidth;
	    psinfo.dwHeight	= si.dwHeight;
	    psinfo.dwScale	= si.dwScale;	
	    psinfo.dwRate	= si.dwRate;
	    psinfo.dwLength	= si.dwLength;
	    psinfo.dwEditCount	= si.dwEditCount;

#ifdef WIN32	
	    // send both UNICODE and ansi
	    hmemcpy(psinfo.szUnicodeType, si.szFileType, NUMELMS(psinfo.szFileType));
	    psinfo.bHasUnicode = TRUE;
	    WideCharToMultiByte(CP_ACP, 0,
	    	si.szFileType,
		-1,
		psinfo.szFileType,
		NUMELMS(psinfo.szFileType),
		NULL, NULL);
#else
    	    // just send ansi version for 16-bit stub
	    psinfo.bHasUnicode = FALSE;
	    hmemcpy(psinfo.szFileType, si.szFileType, sizeof(si.szFileType));
#endif

	    lSize = ((DWORD FAR *)pMessage->Buffer)[0];

	    pMessage->cbBuffer = lSize + sizeof(hrMethod);
	
	    if ((hresult = pChannel->GetBuffer(pMessage, IID_IAVIStream)) != NOERROR)
		return PropagateResult(hresult, RPC_E_SERVER_CANTUNMARSHAL_DATA);

	    ((HRESULT FAR *)pMessage->Buffer)[0] = hrMethod;

	    hmemcpy((LPBYTE) pMessage->Buffer + sizeof(hrMethod),
		    &psinfo,
		    lSize);


	    return NOERROR;
	}

	case IAVIFILE_GetStream:
	    // format on input: fccType, lParam
	    // format on output: marshalled IAVIStream pointer
	{
	    DWORD	    lParam, fccType;
	    PAVISTREAM	    ps;
	    HGLOBAL	    h;
	    DWORD	    dwDestCtx = 0;
	    LPVOID	    pvDestCtx = NULL;
	    DWORD	    cb;
	    LPSTREAM	    pstm;
	
	    fccType = ((DWORD FAR *)pMessage->Buffer)[0];
	    lParam = ((DWORD FAR *)pMessage->Buffer)[1];
	
	    hrMethod = m_pAVIFile->GetStream(&ps, fccType, lParam);

	    if (hrMethod == NOERROR) {

		pChannel->GetDestCtx(&dwDestCtx, &pvDestCtx);

#ifdef WIN32
		cb = 0;
		CoGetMarshalSizeMax(&cb, IID_IAVIStream, ps,
				    dwDestCtx, pvDestCtx, MSHLFLAGS_NORMAL);
#else
		cb = 800; // !!!!!!!
#endif

		h = GlobalAlloc(GHND, cb);

		CreateStreamOnHGlobal(h, FALSE, &pstm);

		CoMarshalInterface(pstm, IID_IAVIStream, ps,
				   dwDestCtx, pvDestCtx, MSHLFLAGS_NORMAL);

		pstm->Release();
	    } else
		cb = 0;

	    pMessage->cbBuffer = cb + sizeof(hrMethod);
	
	    if ((hresult = pChannel->GetBuffer(pMessage, IID_IAVIStream)) != NOERROR)
		return PropagateResult(hresult, RPC_E_SERVER_CANTUNMARSHAL_DATA);

	    ((HRESULT FAR *)pMessage->Buffer)[0] = hrMethod;

	    if (cb) {
		hmemcpy((LPBYTE) pMessage->Buffer + sizeof(hrMethod),
			GlobalLock(h), cb);

		GlobalFree(h);
	    }

	    return NOERROR;

	}


	default:
		// unknown method
		return ResultFromScode(RPC_E_UNEXPECTED);
	}
}


// return TRUE if we support given interface
STDMETHODIMP_(IRpcStubBuffer FAR *) CStubAVIFile::IsIIDSupported(REFIID iid)
{
	// if we are connected, we have already checked for this interface;
	// if we are not connected, it doesn't matter.
	return iid == IID_IAVIFile ? (IRpcStubBuffer *) this : 0;
}


// returns number of refs we have to object
STDMETHODIMP_(ULONG) CStubAVIFile::CountRefs(void)
{
	// return 1 if connected; 0 if not.
	return m_pAVIFile != NULL;
}



STDMETHODIMP CStubAVIFile::DebugServerQueryInterface(LPVOID FAR *ppv)
{
    *ppv = m_pAVIFile;

    if (!m_pAVIFile) {
	DPF("!No File!\n");
	return ResultFromScode(E_UNEXPECTED);
    }

    return NOERROR;
}

STDMETHODIMP_(void) CStubAVIFile::DebugServerRelease(LPVOID pv)
{


}



//
// The following functions exist to allow an application to determine
// if another application is using any of its objects.
//
// !!!!!!   I don't know if this really works.
//

#define MAXTASKCACHE	64
HTASK	ahtaskUsed[MAXTASKCACHE];
int	aiRefCount[MAXTASKCACHE];

void RegisterStubUsage(void)
{
    HTASK htask = GetCurrentTask();
    int i;

    for (i = 0; i < MAXTASKCACHE; i++) {
	if (ahtaskUsed[i] == htask) {
	    ++aiRefCount[i];
	    return;
	}
    }

    for (i = 0; i < MAXTASKCACHE; i++) {
	if (ahtaskUsed[i] == NULL) {
	    ahtaskUsed[i] = htask;
	    aiRefCount[i] = 1;
	    return;
	}
    }

    DPF("Ack: Proxy cache full!\n");
}

void UnregisterStubUsage(void)
{
    HTASK htask = GetCurrentTask();
    int i;

    for (i = 0; i < MAXTASKCACHE; i++) {
	if (ahtaskUsed[i] == htask) {
	    if (--aiRefCount[i] <= 0) {
		ahtaskUsed[i] = NULL;
		aiRefCount[i] = 0;
	    }
	    return;
	}
    }

    DPF("Ack: Proxy not in cache!\n");
}

BOOL FAR TaskHasExistingProxies(void)
{
    HTASK htask = GetCurrentTask();
    int i;

    for (i = 0; i < MAXTASKCACHE; i++) {
	if (ahtaskUsed[i] == htask) {
	    return TRUE;
	}
    }

    return FALSE;
}