///////////////////////////////////////////////////////////////////////////// // INTEL Corporation Proprietary Information // This listing is supplied under the terms of a license agreement with Intel // Corporation and many not be copied nor disclosed except in accordance // with the terms of that agreement. // Copyright (c) 1995, 1996 Intel Corporation. // // // Module Name: PPMSnd.h // Abstract: Header file for PPM Send COM Object // Environment: MSVC 4.0, OLE 2 ///////////////////////////////////////////////////////////////////////////////// // NOTES: // // The three functions that are members of the IUnknown interface need to be // implemented in the most derived class. (Generally the class derived from // this one.) This is done because if one of your super classes // is derived from more than one interface, each of which derive from IUnknown, // the compiler will be confused as to which implementation of the IUnknown // interface to use. So, by requiring that only the most derived class implement // these functions then you will never run into this problem. // // /////////////////////////////////////////////////////////////////////////////// // //This code goes into your class declaration, it defines three functions // //IUnknown Functions (Overrides) // // STDMETHODIMP GetInterface( REFIID riid, LPVOID FAR* ppvObj ); // STDMETHODIMP_( ULONG )AddRef( void ); // STDMETHODIMP_( ULONG )Release( void ); // /////////////////////////////////////////////////////////////////////////////// // This code is the implementation of // CUnknown Functions (Overrides) // // //Three Cases: // // // //1. If you multiply derive from ppmSend and another interface you would have to // //write your own QueryInterface and call CUnknown::QueryInterface AND handle // //the interface you derived from. As well as having the GetInterface function // //as shown below. // // //2. If you derive from another object and ppmSend you would need to write your // //own QueryInterface to call CUnknown::QueryInterface and // //OtherObject::QueryInterface. As well as having the GetInterface function shown // //below. // // //3. If you are only derived from ppmSend then all you need is the code below. // // STDMETHODIMP GetInterface( void REFIID riid, LPVOID FAR* ppvObj ) // { // return ppmSend::GetInterface( riid, ppvObj ); // } // // STDMETHODIMP_( ULONG )AddRef( void ) // { // return CUnknown::AddRef(); // } // // STDMETHODIMP_( ULONG )Release( void ) // { // return CUnknown::Release(); // } // ///////////////////////////////////////////////////////////////////////////// #ifndef PPMSEND_H #define PPMSEND_H #include "isubmit.h" #include "ippm.h" #include "ppm.h" #include "freelist.h" #include "core.h" #include "que.h" class ppmSend : public ppm, public IPPMSend, public IPPMSendExperimental, public IPPMSendSession, public ISubmit, public ISubmitCallback , public ISubmitUser, public CUnknown { protected: /////////////////////// //Members ISubmit *m_pSubmit; ISubmitCallback *m_pSubmitCallback; IMalloc *m_pIMalloc; FreeList *m_pRTPHeaders; WORD m_SequenceNum; const int m_Frequency; int m_MaxPacketSize; //Max size the packet should be int m_MaxDataSize; //Max amount of bytes of data in a packet //i.e. MaxPacketSize-Headers int m_reg_NumMsgDescriptors; //Number of BufDescriptors. int m_reg_NumFragDescriptors; //Number of FragDescriptors. //Things only accessed in internal functions. BOOL m_inFlushMode; BOOL m_DropBufferFlag; MsgDescriptor *m_pCurrentBuffer; DWORD m_CurrentOffset; DWORD m_CurrentFragSize; BOOL m_lastBufSilence; BOOL m_markTalkSpurt; DWORD m_dwStartTime; DWORD m_dwBase; DWORD m_dwLastTime; DWORD m_dwFreq; ///////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////// //External PPMSend Functions ///////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////// public: ////////////////////////////////////////////////////////////////////////////// // PPMSend Functions //constructor: ppmSend(int PayloadTypeArg, int ProfileHdrSizeArg, int FreqArg, IUnknown* pUnkOuter, IUnknown** ppUnkInner); //destructor ~ppmSend(); ////////////////////////////////////////////////////////////////////////////// // IPPMSend Functions (Overrides) STDMETHOD(InitPPMSend)(THIS_ int MaxBufferSize, int iBuffers, int iPackets, DWORD dwCookie); STDMETHOD(InitPPMSend)(THIS_ int MaxBufferSize, DWORD dwCookie) { m_LimitBuffers = FALSE; return InitPPMSend(MaxBufferSize, DEFAULT_MSG_COUNT_SND, DEFAULT_FRAG_COUNT, dwCookie); } STDMETHOD(SetSession)(THIS_ PPMSESSPARAM_T *pSessparam); STDMETHOD(SetAlloc)(THIS_ IMalloc *pIMalloc); //see documentation (PHEPS.DOC) ////////////////////////////////////////////////////////////////////////////// // IPPMSendSession Functions (Overrides) //see documentation (PHEPS.DOC) STDMETHOD(GetPayloadType)(THIS_ LPBYTE lpcPayloadType); STDMETHOD(SetPayloadType)(THIS_ BYTE cPayloadType); ////////////////////////////////////////////////////////////////////////////// // ISubmit Functions (Overrides) //see documentation (PHEPS.DOC) STDMETHOD(InitSubmit)(ISubmitCallback *pSubmitCallback); //see documentation (PHEPS.DOC) STDMETHOD(Submit)(WSABUF *pWSABuffer, DWORD BufferCount, void *pUserToken, HRESULT Error); //see documentation (PHEPS.DOC) //Stubs for now; overriding both ISubmit calls and ISubmitCallback //calls for ReportError STDMETHOD_(void,ReportError)(THIS_ HRESULT Error){} STDMETHOD(Flush)(THIS); ////////////////////////////////////////////////////////////////////////////// // ISubmitCallback Functions (Overrides) //see documentation (PHEPS.DOC) STDMETHOD_(void,SubmitComplete)(void *pUserToken, HRESULT Error); STDMETHOD_(void,ReportError)(THIS_ HRESULT Error, int=0){} ////////////////////////////////////////////////////////////////////////////// // ISubmitUser Functions (Overrides) STDMETHOD(SetOutput)(THIS_ IUnknown *pSubmit); ///////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////// //Internal PPMSend Functions ///////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////// protected: ///////////////////////////////////////////////////////////////////////////// // CUnknown Functions (Overrides) // // Call this method to get interface pointers supported by derived objects // called by CInnerUnknown::QueryInterface; should return S_FALSE // if interface is AddRef'd, S_OK if caller needs to AddRef the interface. STDMETHOD(GetInterface)( REFIID riid, LPVOID FAR* ppvObj ); ///////////////////////////////////////////////////////////////////////////// // ppm Functions (Overrides) // //Need to override this so we can delete memory when a frag descriptor is deleted. //It has already been declared as virtual in ppm.h HRESULT FreeFragDescriptor(FragDescriptor* frag); ///////////////////////////////////////////////////////////////////////////// // ppmSend Functions // ////////////////////////////////////////////////////////////////////////////////////////// //MakeFragments: Intelligently calls the rest of the internal functions. ////////////////////////////////////////////////////////////////////////////////////////// HRESULT MakeFragments(void); ////////////////////////////////////////////////////////////////////////////////////////// //InitFragStatus: Initializes values needed for fragmenting. ////////////////////////////////////////////////////////////////////////////////////////// virtual HRESULT InitFragStatus(MsgDescriptor *pMsgDescrip); ////////////////////////////////////////////////////////////////////////////////////////// //AllocFrag: Allcates memory for FragDescriptor and all things it points to. ////////////////////////////////////////////////////////////////////////////////////////// virtual FragDescriptor * AllocFrag(); ////////////////////////////////////////////////////////////////////////////////////////// //DeleteFrag: Virtual This function does the opposite of AllocFrag, it deletes any memory allocated // by AllocFrag. ////////////////////////////////////////////////////////////////////////////////////////// virtual void DeleteFrag(FragDescriptor *pFragDescrip, HRESULT Error); ////////////////////////////////////////////////////////////////////////////////////////// //FragStatus: This funtion returns TRUE if still fragmenting, FALSE if fragmenting is done. ////////////////////////////////////////////////////////////////////////////////////////// virtual BOOL FragStatus(); ////////////////////////////////////////////////////////////////////////////////////////// //MakeFrag: This function should get the next fragment from the buffer and fill in the // RTP header and payload header. ////////////////////////////////////////////////////////////////////////////////////////// virtual HRESULT MakeFrag(FragDescriptor *pFragDescrip); //fills in fields, including data of fragment class. ////////////////////////////////////////////////////////////////////////////////////////// //SetMarkerBit: Determines whether to set the marker bit or not. lastPacket is TRUE if // this is the last packet of the frame; FALSE if not. ////////////////////////////////////////////////////////////////////////////////////////// virtual BOOL SetMarkerBit(BOOL lastPacket); ////////////////////////////////////////////////////////////////////////////////////////// //SendFrag: Puts the pieces of the packet into a WSABUF and sends the packet to the client // with the callback supplied by the client. ////////////////////////////////////////////////////////////////////////////////////////// virtual HRESULT SendFrag(FragDescriptor *pFragDescrip); ////////////////////////////////////////////////////////////////////////////////////////// //MakeTimeStamp: Generate a time stamp ////////////////////////////////////////////////////////////////////////////////////////// virtual DWORD MakeTimeStamp(MsgDescriptor* pMsgDescrip, BOOL bStartStream, BOOL bUseInputTime); ////////////////////////////////////////////////////////////////////////////////////////// //FreeProfileHeader: Given a buffer as type void, frees up a profile header. ////////////////////////////////////////////////////////////////////////////////////////// virtual void FreeProfileHeader(void *pBuffer); ////////////////////////////////////////////////////////////////////////////////////////// //ReadProfileHeader: Given a buffer as type void, returns the data for a profile header. // Does nothing for the Generic case. Intended for overrides for various // payloads. ////////////////////////////////////////////////////////////////////////////////////////// virtual void *ReadProfileHeader(void *pProfileHeader); }; //end of ppmSend class #endif