h264.h

This the source release kit for the following system configuration(s): - AMD Alchemy(TM) DBAu1200(

//------------------------------------------------------------------------------
// File: H264.h
//------------------------------------------------------------------------------


#ifndef __H264_H_
#define __H264_H_

#include "maicomp.h"

// EFB0FBC1-3DD9-466d-BAC9-51E5EBE20260
DEFINE_GUID(CLSID_H264DMO,
0xEFB0FBC1, 0x3DD9, 0x466d, 0xBA, 0xC9, 0x51, 0xE5, 0xEB, 0xE2, 0x02, 0x60);

#define OUTPUT_BUFFER_SIZE (16*1024)

class CDMOAutoLock {
public:
   CDMOAutoLock(CComAutoCriticalSection* pcs)
      : m_pcs(pcs)
   {
      m_pcs->Lock();
   }
   ~CDMOAutoLock() {
      m_pcs->Unlock();
   }
private:
   CComAutoCriticalSection* m_pcs;
};

/////////////////////////////////////////////////////////////////////////////
// CH264Dmo
class ATL_NO_VTABLE CH264Dmo :
  public IMediaObjectImpl<CH264Dmo, 1, 1>,        // 1 input, 1 output
  public IDMOQualityControl,
  public CComObjectRootEx<CComMultiThreadModel>,
  public CComCoClass<CH264Dmo, &CLSID_H264DMO>
{
public:
  CH264Dmo();
  ~CH264Dmo();

DECLARE_REGISTRY_RESOURCEID(IDR_H264DMO)
DECLARE_GET_CONTROLLING_UNKNOWN()

DECLARE_PROTECT_FINAL_CONSTRUCT()

BEGIN_COM_MAP(CH264Dmo)
  COM_INTERFACE_ENTRY(IMediaObject)
  COM_INTERFACE_ENTRY(IDMOQualityControl)
  COM_INTERFACE_ENTRY_AGGREGATE(IID_IMarshal, m_pUnkMarshaler.p)
END_COM_MAP()

  HRESULT FinalConstruct()
  {
    return CoCreateFreeThreadedMarshaler(GetControllingUnknown(), &m_pUnkMarshaler.p);
  }

  void FinalRelease()
  {
    //  Make sure we clean up
    FreeStreamingResources();
    m_pUnkMarshaler.Release();
  }

  //  IMediaObjectImpl callbacks
  HRESULT InternalGetInputStreamInfo(DWORD dwInputStreamIndex, DWORD *pdwFlags);
  HRESULT InternalGetOutputStreamInfo(DWORD dwOutputStreamIndex, DWORD *pdwFlags);
  HRESULT InternalCheckInputType(DWORD dwInputStreamIndex, const DMO_MEDIA_TYPE *pmt);
  HRESULT InternalCheckOutputType(DWORD dwOutputStreamIndex, const DMO_MEDIA_TYPE *pmt);
  HRESULT InternalGetInputType(DWORD dwInputStreamIndex, DWORD dwTypeIndex, DMO_MEDIA_TYPE *pmt);
  HRESULT InternalGetOutputType(DWORD dwOutputStreamIndex, DWORD dwTypeIndex, DMO_MEDIA_TYPE *pmt);
  HRESULT InternalGetInputSizeInfo(DWORD dwInputStreamIndex, DWORD *pcbSize, DWORD *pcbMaxLookahead, DWORD *pcbAlignment);
  HRESULT InternalGetOutputSizeInfo(DWORD dwOutputStreamIndex, DWORD *pcbSize, DWORD *pcbAlignment);
  HRESULT InternalGetInputMaxLatency(DWORD dwInputStreamIndex, REFERENCE_TIME *prtMaxLatency);
  HRESULT InternalSetInputMaxLatency(DWORD dwInputStreamIndex, REFERENCE_TIME rtMaxLatency);
  HRESULT InternalFlush();
  HRESULT InternalDiscontinuity(DWORD dwInputStreamIndex);
  HRESULT InternalAllocateStreamingResources();
  HRESULT InternalFreeStreamingResources();
  HRESULT InternalProcessInput(DWORD dwInputStreamIndex, IMediaBuffer *pBuffer, DWORD dwFlags, REFERENCE_TIME rtTimestamp, REFERENCE_TIME rtTimelength);
  HRESULT InternalProcessOutput(DWORD dwFlags, DWORD cOutputBufferCount, DMO_OUTPUT_DATA_BUFFER *pOutputBuffers, DWORD *pdwStatus);
  HRESULT InternalAcceptingInput(DWORD dwInputStreamIndex);

  CComPtr<IUnknown>     m_pUnkMarshaler;
  DIUCompHandle_t       m_hDecoder;
  CComPtr<IMediaBuffer> m_pBuffer;
  bool                  m_bFrame;
  bool                  m_bDiscontinuity;
  bool                  m_bSentHeader;

  //
  // IDMOQualityControl
  //
  STDMETHODIMP SetNow(REFERENCE_TIME rtNow);
  
  STDMETHODIMP SetStatus(DWORD dwFlags);
  
  STDMETHODIMP GetStatus(DWORD *pdwFlags) {
    // Any point in grabbing the object lock here ?
    if (m_bQualityControlEnabled)
      *pdwFlags = DMO_QUALITY_STATUS_ENABLED;
    else
      *pdwFlags = 0;
    return NOERROR;
  }
protected:
  HRESULT Init() {
    m_bQualityControlEnabled = FALSE;
    return NOERROR;
  }
  
private:
  // variables used by quality control code
  CComAutoCriticalSection m_cs;
  BOOL                    m_bQualityControlEnabled;
  REFERENCE_TIME          m_rtNow;
  REFERENCE_TIME          m_rtOld;
};

#endif //__H264_H_