t_root.cpp

Multimedia Programming

    return NOERROR;
}

//
// GetMediaType
//
// Returns the supported media types in order of preferred  types (starting with iPosition=0)
//
HRESULT C[!output PROJECT_NAME]::GetMediaType(int iPosition, CMediaType *pMediaType)
{
    // Is the input pin connected
    if (m_pInput->IsConnected() == FALSE)
        return E_UNEXPECTED;

    // This should never happen
    if (iPosition < 0)
        return E_INVALIDARG;

    // Do we have more items to offer
    if (iPosition > 0)
        return VFW_S_NO_MORE_ITEMS;

	// get input dimensions
	CMediaType inMediaType = m_pInput->CurrentMediaType();
	VIDEOINFOHEADER *vihIn = (VIDEOINFOHEADER *)inMediaType.Format();
	int bytesPerPixel = vihIn->bmiHeader.biBitCount / 8;

	pMediaType->SetFormatType(&FORMAT_VideoInfo);
	pMediaType->SetType(&MEDIATYPE_Video);
	if (bytesPerPixel == 3)
		pMediaType->SetSubtype(&MEDIASUBTYPE_RGB24);
	else
		pMediaType->SetSubtype(&MEDIASUBTYPE_RGB32);
	pMediaType->SetSampleSize(RowWidth(vihIn->bmiHeader.biWidth * bytesPerPixel) * vihIn->bmiHeader.biHeight);
	pMediaType->SetTemporalCompression(FALSE);
	pMediaType->ReallocFormatBuffer(sizeof(VIDEOINFOHEADER));

	// set VIDEOINFOHEADER
	VIDEOINFOHEADER *vihOut = (VIDEOINFOHEADER *)pMediaType->Format();
	vihOut->rcSource.top = 0;
	vihOut->rcSource.left = 0;
	vihOut->rcSource.bottom = 0;
	vihOut->rcSource.right = 0;
	vihOut->rcTarget.top = 0;
	vihOut->rcTarget.left = 0;
	vihOut->rcTarget.bottom = 0;
	vihOut->rcTarget.right = 0;
	double frameRate = vihIn->AvgTimePerFrame / 10000000.0;
	vihOut->dwBitRate = (int)(frameRate * vihIn->bmiHeader.biWidth * vihIn->bmiHeader.biHeight * bytesPerPixel);
	vihOut->dwBitErrorRate = 0;
	vihOut->AvgTimePerFrame = vihIn->AvgTimePerFrame;

	// set BITMAPINFOHEADER
	vihOut->bmiHeader.biBitCount = bytesPerPixel * 8;
	vihOut->bmiHeader.biClrImportant = 0;
	vihOut->bmiHeader.biClrUsed = 0;
	vihOut->bmiHeader.biCompression = BI_RGB;
	vihOut->bmiHeader.biHeight = vihIn->bmiHeader.biHeight;
	vihOut->bmiHeader.biPlanes = 1;
	vihOut->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
	int lineSize = RowWidth(vihIn->bmiHeader.biWidth * bytesPerPixel);
	vihOut->bmiHeader.biSizeImage = lineSize * vihIn->bmiHeader.biHeight;
	vihOut->bmiHeader.biWidth = vihIn->bmiHeader.biWidth;
	vihOut->bmiHeader.biXPelsPerMeter = 0;
	vihOut->bmiHeader.biYPelsPerMeter = 0;

    return NOERROR;
}

//
// CanPerform[!output PROJECT_NAME]
//
// We support RGB24 and RGB32 input
//
BOOL C[!output PROJECT_NAME]::CanPerformTransform(const CMediaType *pMediaType) const
{
    if (IsEqualGUID(*pMediaType->Type(), MEDIATYPE_Video)) {
        if (IsEqualGUID(*pMediaType->Subtype(), MEDIASUBTYPE_RGB24)) {
            VIDEOINFOHEADER *pvi = (VIDEOINFOHEADER *) pMediaType->Format();
            return (pvi->bmiHeader.biBitCount == 24);
        }
        if (IsEqualGUID(*pMediaType->Subtype(), MEDIASUBTYPE_RGB32)) {
            VIDEOINFOHEADER *pvi = (VIDEOINFOHEADER *) pMediaType->Format();
            return (pvi->bmiHeader.biBitCount == 32);
        }
    }
    return FALSE;
} 

#define WRITEOUT(var)  hr = pStream->Write(&var, sizeof(var), NULL); \
		       if (FAILED(hr)) return hr;

#define READIN(var)    hr = pStream->Read(&var, sizeof(var), NULL); \
		       if (FAILED(hr)) return hr;

//
// GetClassID
//
// This is the only method of IPersist
//
STDMETHODIMP C[!output PROJECT_NAME]::GetClassID(CLSID *pClsid)
{
    return CBaseFilter::GetClassID(pClsid);
}

//
// ScribbleToStream
//
// Overriden to write our state into a stream
//
HRESULT C[!output PROJECT_NAME]::ScribbleToStream(IStream *pStream)
{
	// TODO: write transform parameters to stream
    HRESULT hr;
    WRITEOUT(m_[!output PROJECT_NAME]Parameters.param1);
    WRITEOUT(m_[!output PROJECT_NAME]Parameters.param2);
    return NOERROR;

}

//
// ReadFromStream
//
// Likewise overriden to restore our state from a stream
//
HRESULT C[!output PROJECT_NAME]::ReadFromStream(IStream *pStream)
{
	// TODO: read transform parameters from stream
    HRESULT hr;
    READIN(m_[!output PROJECT_NAME]Parameters.param1);
    READIN(m_[!output PROJECT_NAME]Parameters.param2);
    return NOERROR;
}

//
// GetPages
//
// Returns the clsid's of the property pages we support
//
STDMETHODIMP C[!output PROJECT_NAME]::GetPages(CAUUID *pPages)
{
    pPages->cElems = 1;
    pPages->pElems = (GUID *) CoTaskMemAlloc(sizeof(GUID));
    if (pPages->pElems == NULL) {
        return E_OUTOFMEMORY;
    }
    *(pPages->pElems) = CLSID_[!output PROJECT_NAME]PropertyPage;
    return NOERROR;
}

//
// get_[!output PROJECT_NAME]
//
// Copies the transform parameters to the given destination.
//
STDMETHODIMP C[!output PROJECT_NAME]::get_[!output PROJECT_NAME]([!output PROJECT_NAME]Parameters *irp)
{
    CAutoLock cAutolock(&m_[!output PROJECT_NAME]Lock);
    CheckPointer(irp,E_POINTER);

	*irp = m_[!output PROJECT_NAME]Parameters;

    return NOERROR;
}

//
// put_[!output PROJECT_NAME]
//
// Copies the transform parameters from the given source.
//
STDMETHODIMP C[!output PROJECT_NAME]::put_[!output PROJECT_NAME]([!output PROJECT_NAME]Parameters irp)
{
    CAutoLock cAutolock(&m_[!output PROJECT_NAME]Lock);

	m_[!output PROJECT_NAME]Parameters = irp;
    SetDirty(TRUE);

	// reconnect
	CMediaType &mt = m_pOutput->CurrentMediaType();
    VIDEOINFOHEADER *pVihOut = (VIDEOINFOHEADER *)mt.pbFormat;
	if (!pVihOut)
		return NOERROR;
	// TODO: modify pVihOut if output resolution or type has changed
	HRESULT hr = ReconnectPin(m_pOutput, &mt);

    return NOERROR;
} 

//
// Copy
//
// Make destination an identical copy of source
//
HRESULT C[!output PROJECT_NAME]::Copy(IMediaSample *pSource, IMediaSample *pDest) const
{
    // Copy the sample data

    BYTE *pSourceBuffer, *pDestBuffer;
    long lSourceSize = pSource->GetActualDataLength();
    long lDestSize	= pDest->GetSize();

    ASSERT(lDestSize >= lSourceSize);

    pSource->GetPointer(&pSourceBuffer);
    pDest->GetPointer(&pDestBuffer);

    CopyMemory( (PVOID) pDestBuffer,(PVOID) pSourceBuffer,lSourceSize);

    // Copy the sample times

    REFERENCE_TIME TimeStart, TimeEnd;
    if (NOERROR == pSource->GetTime(&TimeStart, &TimeEnd)) {
        pDest->SetTime(&TimeStart, &TimeEnd);
    }

    LONGLONG MediaStart, MediaEnd;
    if (pSource->GetMediaTime(&MediaStart,&MediaEnd) == NOERROR) {
        pDest->SetMediaTime(&MediaStart,&MediaEnd);
    }

    // Copy the Sync point property

    HRESULT hr = pSource->IsSyncPoint();
    if (hr == S_OK) {
        pDest->SetSyncPoint(TRUE);
    }
    else if (hr == S_FALSE) {
        pDest->SetSyncPoint(FALSE);
    }
    else {  // an unexpected error has occured...
        return E_UNEXPECTED;
    }

    // Copy the media type

    AM_MEDIA_TYPE *pMediaType;
    pSource->GetMediaType(&pMediaType);
    pDest->SetMediaType(pMediaType);
    DeleteMediaType(pMediaType);

    // Copy the preroll property

    hr = pSource->IsPreroll();
    if (hr == S_OK) {
        pDest->SetPreroll(TRUE);
    }
    else if (hr == S_FALSE) {
        pDest->SetPreroll(FALSE);
    }
    else {  // an unexpected error has occured...
        return E_UNEXPECTED;
    }

    // Copy the discontinuity property

    hr = pSource->IsDiscontinuity();
    if (hr == S_OK) {
	pDest->SetDiscontinuity(TRUE);
    }
    else if (hr == S_FALSE) {
        pDest->SetDiscontinuity(FALSE);
    }
    else {  // an unexpected error has occured...
        return E_UNEXPECTED;
    }

    // Copy the actual data length

    long lDataLength = pSource->GetActualDataLength();
    pDest->SetActualDataLength(lDataLength);

    return NOERROR;
}