//*@@@+++@@@@****************************************************************** // // Microsoft Windows Media Foundation // Copyright (C) Microsoft Corporation. All rights reserved. // //*@@@---@@@@****************************************************************** // #include "stdafx.h" #include "multipinmft.h" #ifdef MF_WPP #include "multipinmft.tmh" //--REF_ANALYZER_DONT_REMOVE-- #endif // //Note since MFT_UNIQUE_METHOD_NAMES is defined all the functions of IMFTransform have the Mft suffix.. // extern const CLSID CLSID_HwMFTActivate; #if _NEED_MFTLOCKING_ #define MFTLOCKED() {\ UINT32 punValue = FALSE; \ hr = GetUINT32(MF_TRANSFORM_ASYNC_UNLOCK, &punValue);\ if (FAILED(hr) || punValue == FALSE){\ return MF_E_TRANSFORM_ASYNC_LOCKED; \ }\ } #else #define MFTLOCKED() #endif CMultipinMft::CMultipinMft() : m_nRefCount( 0 ), m_InputPinCount( 0 ), m_OutputPinCount( 0 ), m_dwWorkQueueId ( MFASYNC_CALLBACK_QUEUE_MULTITHREADED ), m_lWorkQueuePriority ( 0 ), m_spAttributes( nullptr ), m_spSourceTransform( nullptr ), m_PhotoTriggerSent(false), m_filterHasIndependentPin( false ), m_FilterInPhotoSequence( false ), m_filterInWarmStart(false) #if defined (MF_DEVICEMFT_PHTOTOCONFIRMATION) , m_spPhotoConfirmationCallback(nullptr) #endif { ComPtr pAttributes = nullptr; MFCreateAttributes( &pAttributes, 0 ); pAttributes->SetUINT32( MF_TRANSFORM_ASYNC, TRUE ); pAttributes->SetUINT32( MFT_SUPPORT_DYNAMIC_FORMAT_CHANGE, TRUE ); pAttributes->SetUINT32( MF_SA_D3D_AWARE, TRUE ); pAttributes->SetString( MFT_ENUM_HARDWARE_URL_Attribute, L"SampleMultiPinMft" ); m_spAttributes = pAttributes; #if defined (MF_DEVICEMFT_PHTOTOCONFIRMATION) m_guidPhotoConfirmationSubtype = MFVideoFormat_NV12; #endif } CMultipinMft::~CMultipinMft( ) { CBasePin *pioPin = NULL; for ( ULONG ulIndex = 0, ulSize = (ULONG) m_InPins.size(); ulIndex < ulSize; ulIndex++ ) { pioPin = m_InPins[ ulIndex ]; SAFERELEASE( pioPin ); } m_InPins.clear(); for (ULONG ulIndex = 0, ulSize = (ULONG) m_OutPins.size(); ulIndex < ulSize; ulIndex++) { pioPin = m_OutPins[ ulIndex ]; SAFERELEASE( pioPin ); } m_OutPins.clear(); m_spSourceTransform = nullptr; } STDMETHODIMP_(ULONG) CMultipinMft::AddRef( void ) { return InterlockedIncrement(&m_nRefCount); } STDMETHODIMP_(ULONG) CMultipinMft::Release( void ) { ULONG uCount = InterlockedDecrement(&m_nRefCount); if ( uCount == 0 ) { delete this; } return uCount; } STDMETHODIMP CMultipinMft::QueryInterface( _In_ REFIID iid, _COM_Outptr_ void** ppv ) { HRESULT hr = S_OK; *ppv = NULL; if ((iid == __uuidof(IMFDeviceTransform)) || (iid == __uuidof(IUnknown))) { *ppv = static_cast< IMFDeviceTransform* >(this); AddRef(); } else if ( iid == __uuidof( IMFMediaEventGenerator ) ) { *ppv = static_cast< IMFMediaEventGenerator* >(this); AddRef(); } else if ( iid == __uuidof( IMFShutdown ) ) { *ppv = static_cast< IMFShutdown* >( this ); AddRef(); } #if defined (MF_DEVICEMFT_ALLOW_MFT0_LOAD) && defined (MFT_UNIQUE_METHOD_NAMES) else if (iid == __uuidof(IMFTransform)) { *ppv = static_cast< IMFTransform* >(this); AddRef(); } #endif else if ( iid == __uuidof( IKsControl ) ) { *ppv = static_cast< IKsControl* >( this ); AddRef(); } else if ( iid == __uuidof( IMFRealTimeClientEx ) ) { *ppv = static_cast< IMFRealTimeClientEx* >( this ); AddRef(); } #if defined (MF_DEVICEMFT_PHTOTOCONFIRMATION) else if (iid == __uuidof(IMFCapturePhotoConfirmation)) { *ppv = static_cast< IMFCapturePhotoConfirmation* >(this); AddRef(); } else if (iid == __uuidof(IMFGetService)) { *ppv = static_cast< IMFGetService* >(this); AddRef(); } #endif else { hr = E_NOINTERFACE; } return hr; } /*++ Description: This function is the entry point of the transform The following things may be initialized here 1) Query for MF_DEVICEMFT_CONNECTED_FILTER_KSCONTROL on the attributes supplied 2) From the IUnknown acquired get the IMFTransform interface. 3) Get the stream count.. The output streams are of consequence to the tranform. The input streams should correspond to the output streams exposed by the source transform acquired from the Attributes supplied. 4) Get the IKSControl which is used to send KSPROPERTIES, KSEVENTS and KSMETHODS to the driver for the filer level. Store it in your filter class 5) Get the OutPutStreamAttributes for the output pins of the source transform. This can further be used to QI and acquire the IKSControl related to the specific pin. This can be used to send PIN level KSPROPERTIES, EVENTS and METHODS to the pins 6) Create the output pins --*/ STDMETHODIMP CMultipinMft::InitializeTransform ( _In_ IMFAttributes *pAttributes ) { HRESULT hr = S_OK; ComPtr spFilterUnk = nullptr; DWORD *pcInputStreams = NULL, *pcOutputStreams = NULL; DWORD inputStreams = 0; DWORD outputStreams = 0; GUID* outGuids = NULL; GUID streamCategory = GUID_NULL; DMFTCHECKNULL_GOTO( pAttributes, done, E_INVALIDARG ); // //The attribute passed with MF_DEVICEMFT_CONNECTED_FILTER_KSCONTROL is the source transform. This generally represents a filter //This needs to be stored so that we know the device properties. We cache it. We query for the IKSControl which is used to send //controls to the driver. // DMFTCHECKHR_GOTO( pAttributes->GetUnknown( MF_DEVICEMFT_CONNECTED_FILTER_KSCONTROL,IID_PPV_ARGS( &spFilterUnk ) ),done ); DMFTCHECKHR_GOTO( spFilterUnk.As( &m_spSourceTransform ), done ); DMFTCHECKHR_GOTO( m_spSourceTransform.As( &m_spIkscontrol ), done ); DMFTCHECKHR_GOTO( m_spSourceTransform->MFTGetStreamCount( &inputStreams, &outputStreams ), done ); spFilterUnk = nullptr; // //The number of input pins created by the device transform should match the pins exposed by //the source transform i.e. outputStreams from SourceTransform or DevProxy = Input pins of the Device MFT // if ( inputStreams > 0 || outputStreams > 0 ) { pcInputStreams = new DWORD[ inputStreams ]; DMFTCHECKNULL_GOTO( pcInputStreams, done, E_OUTOFMEMORY); pcOutputStreams = new DWORD[ outputStreams ]; DMFTCHECKNULL_GOTO( pcOutputStreams, done, E_OUTOFMEMORY ); DMFTCHECKHR_GOTO( m_spSourceTransform->MFTGetStreamIDs( inputStreams, pcInputStreams, outputStreams, pcOutputStreams ),done ); // // Output pins from DevProxy = Input pins of device MFT.. We are the first transform in the pipeline before MFT0 // for ( ULONG ulIndex = 0; ulIndex < outputStreams; ulIndex++ ) { ComPtr pInAttributes = nullptr; DMFTCHECKHR_GOTO( m_spSourceTransform->GetOutputStreamAttributes(pcOutputStreams[ulIndex], pInAttributes.GetAddressOf()), done); DMFTCHECKHR_GOTO( pInAttributes->GetGUID(MF_DEVICESTREAM_STREAM_CATEGORY, &streamCategory), done); if ( IsEqualCLSID( streamCategory, PINNAME_IMAGE ) ) { //We have independent pins.. m_filterHasIndependentPin = true; } CInPin *pInPin = nullptr; if (IsEqualCLSID(streamCategory, AVSTREAM_CUSTOM_PIN_IMAGE)) { pInPin = new CCustomPin( pInAttributes.Get(), pcOutputStreams[ulIndex], this); DMFTCHECKNULL_GOTO( pInPin, done, E_OUTOFMEMORY); // // Since the custom pin is an input pin too we will push it // in the input pins list. This is however not being connected // to the output in this sample. m_CustomPinCount++; } else { pInPin = new CInPin( pInAttributes.Get(), pcOutputStreams[ulIndex], this); DMFTCHECKNULL_GOTO(pInPin, done, E_OUTOFMEMORY); } hr = ExceptionBoundary([this,pInPin]() { m_InPins.push_back(pInPin); }); DMFTCHECKHR_GOTO(hr, done); DMFTCHECKHR_GOTO( pInPin->Init(m_spSourceTransform.Get() ), done); pInPin->AddRef(); } // // If we have just one output stream exposed off the source transform create a one to three pin // if ( ( outputStreams == 1 ) && IsEqualGUID( streamCategory, PINNAME_VIDEO_CAPTURE ) ) { outputStreams = 3; outGuids = new GUID [ outputStreams ]; DMFTCHECKNULL_GOTO(outGuids, done, E_OUTOFMEMORY); m_OutPins.resize(outputStreams, nullptr); CInPin *piPin = (CInPin *)m_InPins[0]; *outGuids = PINNAME_VIDEO_CAPTURE; *( outGuids + 1 ) = PINNAME_VIDEO_PREVIEW; *(outGuids + 2) = PINNAME_IMAGE; //PINNAME_IMAGE for independent pin and PINNAME_VIDEO_STILL for dependent pin!! for ( ULONG ulIndex = 0; ulIndex < outputStreams; ulIndex++ ) { ComPtr pKsControl = NULL; COutPin *poPin = nullptr; DMFTCHECKHR_GOTO( piPin->QueryInterface(IID_PPV_ARGS( &pKsControl ) ), done); hr = ExceptionBoundary([&]() { poPin = new COutPin(ulIndex, this, pKsControl.Get()); }); DMFTCHECKHR_GOTO(hr, done); DMFTCHECKNULL_GOTO( poPin,done, E_OUTOFMEMORY ); DMFTCHECKHR_GOTO( BridgeInputPinOutputPin( piPin, poPin ),done ); DMFTCHECKHR_GOTO( poPin->SetGUID( MF_DEVICESTREAM_STREAM_CATEGORY, outGuids[ ulIndex ] ),done ); DMFTCHECKHR_GOTO( poPin->SetUINT32( MF_DEVICESTREAM_STREAM_ID, ulIndex ),done ); m_OutPins[ ulIndex ] = poPin; poPin->AddRef(); } } else { // //Create one on one mapping // for (ULONG ulIndex = 0; ulIndex < m_InPins.size(); ulIndex++) { ULONG ulPinIndex = 0; GUID pinGuid = GUID_NULL; ComPtr< IKsControl > pKsControl = nullptr; CInPin *piPin = ( CInPin * )m_InPins[ ulIndex ]; if (piPin) { BOOL isCustom = false; if ( SUCCEEDED( CheckCustomPin( piPin, &isCustom )) && ( isCustom ) ) { // // In this sample we are not connecting the custom pin to the output // This is because we really have no way of testing the custom pin with the // pipeline. // This however can be changed if the custom media type is converted here in // the device MFT and later exposed to the pipeline.. // continue; } ulPinIndex = piPin->streamId(); DMFTCHECKHR_GOTO(piPin->GetGUID(MF_DEVICESTREAM_STREAM_CATEGORY, &pinGuid), done); DMFTCHECKHR_GOTO(piPin->QueryInterface(IID_PPV_ARGS(&pKsControl)), done); COutPin *poPin = new COutPin(ulPinIndex, this, pKsControl.Get()); DMFTCHECKNULL_GOTO(poPin, done, E_OUTOFMEMORY); DMFTCHECKHR_GOTO(poPin->SetGUID(MF_DEVICESTREAM_STREAM_CATEGORY, pinGuid), done); DMFTCHECKHR_GOTO(poPin->SetUINT32(MF_DEVICESTREAM_STREAM_ID, ulPinIndex), done); #if defined (MF_DEVICEMFT_ALLOW_MFT0_LOAD) && defined (MFT_UNIQUE_METHOD_NAMES) // // If we wish to load MFT0 as well as Device MFT then we should be doing the following // Copy over the GUID attribute MF_DEVICESTREAM_EXTENSION_PLUGIN_CLSID from the input // pin to the output pin. This is because Device MFT is the new face of the filter now // and MFT0 will now get loaded for the output pins exposed from Device MFT rather than // DevProxy! // GUID guidMFT0 = GUID_NULL; hr = piPin->GetGUID(MF_DEVICESTREAM_EXTENSION_PLUGIN_CLSID, &guidMFT0); if (SUCCEEDED(hr)) { // // This stream has an MFT0 .. Attach the GUID to the Outpin pin attribute // The downstream will query this attribute on the pins exposed from device MFT // DMFTRACE(DMFT_GENERAL, TRACE_LEVEL_INFORMATION, "%!FUNC! setting Mft0 guid on pin %d", ulIndex); DMFTCHECKHR_GOTO(poPin->SetGUID(MF_DEVICESTREAM_EXTENSION_PLUGIN_CLSID, guidMFT0), done); DMFTCHECKHR_GOTO(poPin->SetUnknown(MF_DEVICESTREAM_EXTENSION_PLUGIN_CONNECTION_POINT, static_cast< IUnknown* >(static_cast < IKsControl * >(this))), done); } else { // Reset Error.. MFT0 absence should not be an error hr = S_OK; } #endif DMFTCHECKHR_GOTO(BridgeInputPinOutputPin(piPin, poPin), done); hr = ExceptionBoundary([&]() { m_OutPins.push_back(poPin); }); DMFTCHECKHR_GOTO(hr, done); } } } } m_InputPinCount = ULONG ( m_InPins.size() ); m_OutputPinCount = ULONG ( m_OutPins.size() ); done: DMFTRACE(DMFT_GENERAL, TRACE_LEVEL_INFORMATION, "%!FUNC! exiting %x = %!HRESULT!",hr,hr); if ( pcInputStreams ) { delete[ ] ( pcInputStreams ); } if ( pcOutputStreams ) { delete[ ] ( pcOutputStreams ); } if ( outGuids ) { delete [] ( outGuids ); } if ( FAILED( hr ) ) { //Release the pins and the resources acquired while ( m_InPins.size() > 0 ) { CInPin *pInPin = nullptr; pInPin = ( CInPin* )m_InPins.back(); m_InPins.pop_back(); SAFERELEASE( pInPin ); } while ( m_OutPins.size() > 0 ) { COutPin *pin = nullptr; pin = ( COutPin* )m_OutPins.back(); m_OutPins.pop_back(); SAFERELEASE( pin ); } // // Simply clear the custom pins since the input pins must have deleted the pin // m_spSourceTransform = nullptr; } return hr; } STDMETHODIMP CMultipinMft::SetWorkQueueEx( _In_ DWORD dwWorkQueueId, _In_ LONG lWorkItemBasePriority ) /*++ Description: Implements IMFRealTimeClientEx::SetWorkQueueEx function --*/ { CAutoLock lock( m_critSec ); // // Cache the WorkQueuId and WorkItemBasePriority // m_dwWorkQueueId = dwWorkQueueId; m_lWorkQueuePriority = lWorkItemBasePriority; return S_OK; } // // IMFDeviceTransform functions // STDMETHODIMP CMultipinMft::GetStreamCount( _Inout_ DWORD *pdwInputStreams, _Inout_ DWORD *pdwOutputStreams ) /*++ Description: Implements IMFTransform::GetStreamCount function --*/ { HRESULT hr = S_OK; CAutoLock lock(m_critSec); *pdwInputStreams = m_InputPinCount; *pdwOutputStreams = m_OutputPinCount; DMFTRACE( DMFT_GENERAL, TRACE_LEVEL_INFORMATION, "%!FUNC! exiting %x = %!HRESULT!", hr, hr ); return hr; } // //Doesn't striclt conform to GetStreamIDs on IMFTransform Interface! // STDMETHODIMP CMultipinMft::GetStreamIDs( _In_ DWORD dwInputIDArraySize, _When_(dwInputIDArraySize >= m_InputPinCount, _Out_writes_(dwInputIDArraySize)) DWORD* pdwInputIDs, _In_ DWORD dwOutputIDArraySize, _When_(dwOutputIDArraySize >= m_OutputPinCount && (pdwInputIDs && (dwInputIDArraySize > 0)), _Out_writes_(dwOutputIDArraySize)) _On_failure_(_Valid_) DWORD* pdwOutputIDs ) /*++ Description: Implements IMFTransform::GetStreamIDs function --*/ { HRESULT hr = S_OK; CAutoLock lock(m_critSec); MFTLOCKED(); if ( ( dwInputIDArraySize < m_InputPinCount ) && ( dwOutputIDArraySize < m_OutputPinCount ) ) { hr = MF_E_BUFFERTOOSMALL; goto done; } if ( dwInputIDArraySize ) { DMFTCHECKNULL_GOTO( pdwInputIDs, done, E_POINTER ); for ( DWORD dwIndex = 0; dwIndex < ((dwInputIDArraySize > m_InputPinCount) ? m_InputPinCount: dwInputIDArraySize); dwIndex++ ) { pdwInputIDs[ dwIndex ] = ( m_InPins[dwIndex] )->streamId(); } } if ( dwOutputIDArraySize ) { DMFTCHECKNULL_GOTO( pdwOutputIDs, done, E_POINTER ); for ( DWORD dwIndex = 0; dwIndex < ((dwOutputIDArraySize > m_OutputPinCount)? m_OutputPinCount: dwOutputIDArraySize); dwIndex++ ) { pdwOutputIDs[ dwIndex ] = (m_OutPins[ dwIndex ])->streamId(); } } done: return hr; } /*++ Name: CMultipinMft::GetInputAvailableType Description: Implements IMFTransform::GetInputAvailableType function. This function gets the media type supported by the specified stream based on the index dwTypeIndex. --*/ STDMETHODIMP CMultipinMft::GetInputAvailableType( _In_ DWORD dwInputStreamID, _In_ DWORD dwTypeIndex, _Out_ IMFMediaType** ppMediaType ) { HRESULT hr = S_OK; MFTLOCKED(); CInPin *piPin = ( CInPin* )GetInPin( dwInputStreamID ); DMFTCHECKNULL_GOTO( piPin, done, MF_E_INVALIDSTREAMNUMBER ); *ppMediaType = nullptr; hr = piPin->GetOutputAvailableType( dwTypeIndex,ppMediaType ); if (FAILED(hr)) { DMFTRACE( DMFT_GENERAL, TRACE_LEVEL_INFORMATION, "%!FUNC! Pin: %d Index: %d exiting %!HRESULT!", dwInputStreamID, dwTypeIndex, hr); } done: return hr; } STDMETHODIMP CMultipinMft::GetOutputAvailableType( _In_ DWORD dwOutputStreamID, _In_ DWORD dwTypeIndex, _Out_ IMFMediaType** ppMediaType ) /*++ Description: Implements IMFTransform::GetOutputAvailableType function. This function gets the media type supported by the specified stream based on the index dwTypeIndex. --*/ { HRESULT hr = S_OK; MFTLOCKED(); DMFTCHECKNULL_GOTO(ppMediaType, done, E_INVALIDARG); COutPin*poPin = ( COutPin* )GetOutPin( dwOutputStreamID ); DMFTCHECKNULL_GOTO( poPin, done, MF_E_INVALIDSTREAMNUMBER ); *ppMediaType = nullptr; hr = poPin->GetOutputAvailableType( dwTypeIndex, ppMediaType ); if ( FAILED( hr ) ) { DMFTRACE( DMFT_GENERAL, TRACE_LEVEL_INFORMATION, "%!FUNC! Pin: %d Index: %d exiting %!HRESULT!", dwOutputStreamID, dwTypeIndex, hr ); } done: return hr; } STDMETHODIMP CMultipinMft::GetInputCurrentType( _In_ DWORD dwInputStreamID, _COM_Outptr_result_maybenull_ IMFMediaType** ppMediaType ) /*++ Description: Implements IMFTransform::GetInputCurrentType function. This function returns the current media type set on the specified stream. --*/ { // //The input current types will not come to this transform. //The outputs of this transform matter. The DTM manages the //output of this transform and the inptuts of the source transform // UNREFERENCED_PARAMETER(dwInputStreamID); UNREFERENCED_PARAMETER(ppMediaType); return S_OK; } STDMETHODIMP CMultipinMft::GetOutputCurrentType( _In_ DWORD dwOutputStreamID, _Out_ IMFMediaType** ppMediaType ) /*++ Description: Implements IMFTransform::GetOutputCurrentType function. This function returns the current media type set on the specified stream. --*/ { HRESULT hr = S_OK; MFTLOCKED(); CAutoLock lock( m_critSec ); DMFTCHECKNULL_GOTO( ppMediaType, done, E_INVALIDARG ); *ppMediaType = nullptr; COutPin *poPin = ( COutPin* )GetOutPin( dwOutputStreamID ); DMFTCHECKNULL_GOTO( poPin, done, MF_E_INVALIDSTREAMNUMBER ); DMFTCHECKHR_GOTO( poPin->getMediaType( ppMediaType ),done ); DMFTCHECKNULL_GOTO( *ppMediaType, done, MF_E_TRANSFORM_TYPE_NOT_SET ); done: DMFTRACE( DMFT_GENERAL, TRACE_LEVEL_INFORMATION, "%!FUNC! exiting %x = %!HRESULT!", hr, hr ); return hr; } STDMETHODIMP CMultipinMft::ProcessEvent( _In_ DWORD dwInputStreamID, _In_ IMFMediaEvent* pEvent ) /*++ Description: Implements IMFTransform::ProcessEvent function. This function processes events that come to the MFT. --*/ { UNREFERENCED_PARAMETER(dwInputStreamID); UNREFERENCED_PARAMETER(pEvent); return S_OK; } STDMETHODIMP CMultipinMft::ProcessMessage( _In_ MFT_MESSAGE_TYPE eMessage, _In_ ULONG_PTR ulParam ) /*++ Description: Implements IMFTransform::ProcessMessage function. This function processes messages coming to the MFT. --*/ { HRESULT hr = S_OK; MFTLOCKED(); UNREFERENCED_PARAMETER(ulParam); CAutoLock _lock( m_critSec ); printMessageEvent( eMessage ); switch ( eMessage ) { case MFT_MESSAGE_COMMAND_FLUSH: // //This is MFT wide flush.. Flush all output pins // (VOID)FlushAllStreams(); break; case MFT_MESSAGE_COMMAND_DRAIN: // //There is no draining for Device MFT. Just kept here for reference // break; case MFT_MESSAGE_NOTIFY_START_OF_STREAM: // //No op for device MFTs // break; case MFT_MESSAGE_SET_D3D_MANAGER: { if ( ulParam ) { ComPtr< IDirect3DDeviceManager9 > spD3D9Manager; ComPtr< IMFDXGIDeviceManager > spDXGIManager; hr = ( ( IUnknown* ) ulParam )->QueryInterface( IID_PPV_ARGS( &spD3D9Manager ) ); if ( SUCCEEDED( hr ) ) { m_spDeviceManagerUnk = ( IUnknown* )ulParam; DMFTRACE( DMFT_GENERAL, TRACE_LEVEL_INFORMATION, "%!FUNC! IDirect3DDeviceManager9 %p, is passed", spD3D9Manager.Get() ); } else { hr = ( ( IUnknown* ) ulParam )->QueryInterface( IID_PPV_ARGS( &spDXGIManager ) ); if ( SUCCEEDED(hr) ) { m_spDeviceManagerUnk = (IUnknown*)ulParam; DMFTRACE( DMFT_GENERAL, TRACE_LEVEL_INFORMATION, "%!FUNC! IMFDXGIDeviceManager %p, is passed", spDXGIManager.Get()); } } } else { m_spDeviceManagerUnk = nullptr; hr = S_OK; DMFTRACE( DMFT_GENERAL, TRACE_LEVEL_INFORMATION, "%!FUNC!IDirect3DDeviceManager9 was not passed in"); } } break; case MFT_MESSAGE_NOTIFY_BEGIN_STREAMING: { SetStreamingState( DeviceStreamState_Run ); // // Start Streaming custom pins if the device transfrom has any // SetStreamingStateCustomPins( DeviceStreamState_Run ); } break; case MFT_MESSAGE_NOTIFY_END_STREAMING: { SetStreamingState(DeviceStreamState_Stop); // // Stop streaming custom pins if the device transform has any // SetStreamingStateCustomPins( DeviceStreamState_Stop ); } break; case MFT_MESSAGE_NOTIFY_END_OF_STREAM: { SetStreamingState(DeviceStreamState_Stop); } break; default: ; } DMFTRACE( DMFT_GENERAL, TRACE_LEVEL_INFORMATION, "%!FUNC! exiting %x = %!HRESULT!", hr, hr ); return hr; } STDMETHODIMP CMultipinMft::ProcessInput( _In_ DWORD dwInputStreamID, _In_ IMFSample* pSample, _In_ DWORD dwFlags ) /*++ Description: Implements IMFTransform::ProcessInput function.This function is called when the sourcetransform has input to feed. the pins will try to deliver the samples to the active output pins conencted. if none are connected then just returns the sample back to the source transform --*/ { HRESULT hr = S_OK; UNREFERENCED_PARAMETER( dwFlags ); MFTLOCKED(); CInPin *inPin = ( CInPin* )GetInPin( dwInputStreamID ); DMFTCHECKNULL_GOTO( inPin, done, E_INVALIDARG ); if ( !IsStreaming() ) { goto done; } DMFTCHECKHR_GOTO( inPin->SendSample( pSample ), done ); QueueEvent( METransformHaveOutput, GUID_NULL, S_OK, NULL ); done: SAFERELEASE( pSample ); DMFTRACE( DMFT_GENERAL, TRACE_LEVEL_INFORMATION, "%!FUNC! exiting %x = %!HRESULT!", hr, hr ); return hr; } STDMETHODIMP CMultipinMft::ProcessOutput( _In_ DWORD dwFlags, _In_ DWORD cOutputBufferCount, _Inout_updates_(cOutputBufferCount) MFT_OUTPUT_DATA_BUFFER *pOutputSamples, _Out_ DWORD *pdwStatus ) /*++ Description: Implements IMFTransform::ProcessOutput function. This is called by the DTM when the DT indicates it has samples to give. The DTM will send enough MFT_OUTPUT_DATA_BUFFER pointers to be filled up as is the number of output pins available. The DT should traverse its output pins and populate the corresponding MFT_OUTPUT_DATA_BUFFER with the samples available --*/ { HRESULT hr = S_OK; BOOL gotOne = false; MFTLOCKED(); UNREFERENCED_PARAMETER( dwFlags ); if (cOutputBufferCount > m_OutputPinCount ) { DMFTCHECKHR_GOTO( E_INVALIDARG, done ); } *pdwStatus = 0; for ( DWORD i = 0; i < cOutputBufferCount; i++ ) { DWORD dwStreamID = pOutputSamples[i].dwStreamID; COutPin *poPin = ( COutPin * )GetOutPin( dwStreamID ); DMFTCHECKNULL_GOTO( poPin, done, E_INVALIDARG ); if ( SUCCEEDED( poPin->ProcessOutput( dwFlags, &pOutputSamples[i], pdwStatus ) ) ) { gotOne = true; } } if (gotOne) { hr = S_OK; } done: DMFTRACE(DMFT_GENERAL, TRACE_LEVEL_INFORMATION, "%!FUNC! exiting %x = %!HRESULT!", hr, hr); return hr; } STDMETHODIMP CMultipinMft::GetInputStreamAttributes( _In_ DWORD dwInputStreamID, _COM_Outptr_result_maybenull_ IMFAttributes** ppAttributes ) /*++ Description: Implements IMFTransform::GetInputStreamAttributes function. This function gets the specified input stream's attributes. --*/ { HRESULT hr = S_OK; MFTLOCKED(); DMFTCHECKNULL_GOTO( ppAttributes, done, E_INVALIDARG ); *ppAttributes = nullptr; CInPin *piPin = static_cast(GetInPin( dwInputStreamID )); DMFTCHECKNULL_GOTO( piPin, done, E_INVALIDARG ); hr = piPin->getPinAttributes(ppAttributes); done: DMFTRACE(DMFT_GENERAL, TRACE_LEVEL_INFORMATION, "%!FUNC! exiting %x = %!HRESULT!", hr, hr); return hr; } STDMETHODIMP CMultipinMft::GetOutputStreamAttributes( _In_ DWORD dwOutputStreamID, _Out_ IMFAttributes** ppAttributes ) /*++ Description: Implements IMFTransform::GetOutputStreamAttributes function. This function gets the specified output stream's attributes. --*/ { HRESULT hr = S_OK; MFTLOCKED(); DMFTCHECKNULL_GOTO(ppAttributes, done, E_INVALIDARG); *ppAttributes = nullptr; COutPin *poPin = (COutPin *)GetOutPin(dwOutputStreamID); DMFTCHECKNULL_GOTO( poPin, done, E_INVALIDARG ); DMFTCHECKHR_GOTO( poPin->getPinAttributes(ppAttributes), done ); done: DMFTRACE(DMFT_GENERAL, TRACE_LEVEL_INFORMATION, "%!FUNC! exiting %x = %!HRESULT!", hr, hr); return hr; } _Requires_no_locks_held_ STDMETHODIMP CMultipinMft::SetInputStreamState( _In_ DWORD dwStreamID, _In_ IMFMediaType *pMediaType, _In_ DeviceStreamState value, _In_ DWORD dwFlags ) /*++ Description: Implements IMFdeviceTransform::SetInputStreamState function. Sets the input stream state. The control lock is not taken here. The lock is taken for operations on output pins. This operation is a result of the DT notifying the DTM that output pin change has resulted in the need for the input to be changed. In this case the DTM sends a getpreferredinputstate and then this call --*/ { HRESULT hr = S_OK; CInPin *piPin = (CInPin*)GetInPin(dwStreamID); DMFTCHECKNULL_GOTO(piPin, done, MF_E_INVALIDSTREAMNUMBER); DMFTCHECKHR_GOTO(piPin->SetInputStreamState(pMediaType, value, dwFlags),done); done: DMFTRACE(DMFT_GENERAL, TRACE_LEVEL_INFORMATION, "%!FUNC! exiting %x = %!HRESULT!", hr, hr); return hr; } STDMETHODIMP CMultipinMft::GetInputStreamState( _In_ DWORD dwStreamID, _Out_ DeviceStreamState *value ) { HRESULT hr = S_OK; CInPin *piPin = (CInPin*)GetInPin(dwStreamID); DMFTCHECKNULL_GOTO(piPin, done, MF_E_INVALIDSTREAMNUMBER); *value = piPin->GetState(); done: DMFTRACE(DMFT_GENERAL, TRACE_LEVEL_INFORMATION, "%!FUNC! exiting %x = %!HRESULT!", hr, hr); return hr; } STDMETHODIMP CMultipinMft::SetOutputStreamState( _In_ DWORD dwStreamID, _In_ IMFMediaType *pMediaType, _In_ DeviceStreamState state, _In_ DWORD dwFlags ) /*++ Description: Implements IMFdeviceTransform::SetOutputStreamState function. Sets the output stream state. This is called whenever the stream is selected or deslected i.e. started or stopped. The control lock taken here and this operation should be atomic. This function should check the input pins connected to the output pin switch off the state of the input pin. Check if any other Pin connected to the input pin is in a conflicting state with the state requested on this output pin. Accordinly it calculates the media type to be set on the input pin and the state to transition into. It then might recreate the other output pins connected to it --*/ { HRESULT hr = S_OK; UNREFERENCED_PARAMETER(dwFlags); CAutoLock Lock(m_critSec); DMFTCHECKHR_GOTO(ChangeMediaTypeEx(dwStreamID, pMediaType, state),done); done: DMFTRACE(DMFT_GENERAL, TRACE_LEVEL_INFORMATION, "%!FUNC! exiting %x = %!HRESULT!", hr, hr); return hr; } STDMETHODIMP CMultipinMft::GetOutputStreamState( _In_ DWORD dwStreamID, _Out_ DeviceStreamState *value ) /*++ Description: Implements IMFdeviceTransform::GetOutputStreamState function. Gets the output stream state. Called by the DTM to checks states. Atomic operation. needs a lock --*/ { HRESULT hr = S_OK; CAutoLock lock(m_critSec); COutPin *poPin = (COutPin *)GetOutPin(dwStreamID); DMFTCHECKNULL_GOTO(poPin, done, MF_E_INVALIDSTREAMNUMBER); *value = poPin->GetState(); done: DMFTRACE(DMFT_GENERAL, TRACE_LEVEL_INFORMATION, "%!FUNC! exiting %x = %!HRESULT!", hr, hr); return hr; } STDMETHODIMP CMultipinMft::GetInputStreamPreferredState( _In_ DWORD dwStreamID, _Inout_ DeviceStreamState *value, _Outptr_opt_result_maybenull_ IMFMediaType **ppMediaType ) /*++ Description: Implements IMFdeviceTransform::GetInputStreamPreferredState function. Gets the preferred state and the media type to be set on the input pin. The lock is not held as this will always be called only when we notify DTM to call us. We notify DTM only from the context on operations happening on the output pin --*/ { HRESULT hr = S_OK; CInPin *piPin = (CInPin*)GetInPin(dwStreamID); DMFTCHECKNULL_GOTO(piPin, done, MF_E_INVALIDSTREAMNUMBER); piPin->GetInputStreamPreferredState(value, ppMediaType); done: DMFTRACE(DMFT_GENERAL, TRACE_LEVEL_INFORMATION, "%!FUNC! exiting %x = %!HRESULT!", hr, hr); return hr; } STDMETHODIMP CMultipinMft::FlushInputStream( _In_ DWORD dwStreamIndex, _In_ DWORD dwFlags ) /*++ Description: Implements IMFdeviceTransform::FlushInputStream function. --*/ { HRESULT hr = S_OK; UNREFERENCED_PARAMETER(dwStreamIndex); UNREFERENCED_PARAMETER(dwFlags); DMFTRACE(DMFT_GENERAL, TRACE_LEVEL_INFORMATION, "%!FUNC! exiting %x = %!HRESULT!", hr, hr); return hr; } STDMETHODIMP CMultipinMft::FlushOutputStream( _In_ DWORD dwStreamIndex, _In_ DWORD dwFlags ) /*++ Description: Implements IMFdeviceTransform::FlushOutputStream function. Called by the DTM to flush streams --*/ { HRESULT hr = S_OK; UNREFERENCED_PARAMETER(dwFlags); CAutoLock Lock(m_critSec); COutPin *poPin = (COutPin*)GetOutPin(dwStreamIndex); DMFTCHECKNULL_GOTO(poPin, done, E_INVALIDARG); DeviceStreamState oldState = poPin->SetState(DeviceStreamState_Disabled); hr = poPin->FlushQueues(); if (FAILED(hr)) { DMFTRACE(DMFT_GENERAL, TRACE_LEVEL_INFORMATION, "%!FUNC! failed %x = %!HRESULT!", hr, hr); } // //Restore state // poPin->SetState(oldState); done: DMFTRACE(DMFT_GENERAL, TRACE_LEVEL_INFORMATION, "%!FUNC! exiting %x = %!HRESULT!", hr, hr); return hr; } /*++ Description: Called when the Device Transform gets a MFT_MESSAGE_COMMAND_FLUSH. We drain all the queues. This is called in device source when the source gets end of streaming. --*/ STDMETHODIMP_(VOID) CMultipinMft::FlushAllStreams( VOID ) { DeviceStreamState oldState; for ( DWORD dwIndex = 0, dwSize = (DWORD)m_OutPins.size(); dwIndex < dwSize; dwIndex++ ) { COutPin *poPin = (COutPin *)m_OutPins[dwIndex]; oldState = poPin->SetState(DeviceStreamState_Disabled); poPin->FlushQueues(); // //Restore state // poPin->SetState(oldState); } } // // IKsControl interface functions // STDMETHODIMP CMultipinMft::KsProperty( _In_reads_bytes_(ulPropertyLength) PKSPROPERTY pProperty, _In_ ULONG ulPropertyLength, _Inout_updates_bytes_(ulDataLength) LPVOID pvPropertyData, _In_ ULONG ulDataLength, _Inout_ ULONG* pulBytesReturned ) /*++ Description: Implements IKSProperty::KsProperty function. used to pass control commands to the driver (generally) This can be used to intercepted the control to figure out if it needs to be propogated to the driver or not --*/ { HRESULT hr = S_OK; UNREFERENCED_PARAMETER(pulBytesReturned); DMFTCHECKNULL_GOTO(pProperty, done, E_INVALIDARG); DMFTCHECKNULL_GOTO(pulBytesReturned, done, E_INVALIDARG); // // Enable Warm Start on All filters for the sample. Please comment out this // section if this is not needed // if (IsEqualCLSID(pProperty->Set, KSPROPERTYSETID_ExtendedCameraControl) && (pProperty->Id == KSPROPERTY_CAMERACONTROL_EXTENDED_WARMSTART)) { DMFTCHECKHR_GOTO(WarmStartHandler(pProperty, ulPropertyLength, pvPropertyData, ulDataLength, pulBytesReturned),done); goto done; } if (IsEqualCLSID(pProperty->Set, KSPROPERTYSETID_ExtendedCameraControl) && (pProperty->Id == KSPROPERTY_CAMERACONTROL_EXTENDED_PHOTOTHUMBNAIL)) { DMFTRACE(DMFT_GENERAL, TRACE_LEVEL_INFORMATION, "%!FUNC! Thumbnail sent %d",pProperty->Flags); } if (IsEqualCLSID(pProperty->Set, KSPROPERTYSETID_ExtendedCameraControl) &&(!filterHasIndependentPin())) { DMFTRACE(DMFT_GENERAL, TRACE_LEVEL_INFORMATION, "%!FUNC! Extended Control %d Passed ",pProperty->Id); switch (pProperty->Id) { case KSPROPERTY_CAMERACONTROL_EXTENDED_PHOTOMODE: hr = ExtendedPhotoModeHandler(pProperty, ulPropertyLength, pvPropertyData, ulDataLength, pulBytesReturned); goto done; break; case KSPROPERTY_CAMERACONTROL_EXTENDED_PHOTOMAXFRAMERATE: hr = ExtendedPhotoMaxFrameRate(pProperty, ulPropertyLength, pvPropertyData, ulDataLength, pulBytesReturned); goto done; break; case KSPROPERTY_CAMERACONTROL_EXTENDED_MAXVIDFPS_PHOTORES: hr = MaxVidFPS_PhotoResHandler(pProperty, ulPropertyLength, pvPropertyData, ulDataLength, pulBytesReturned); goto done; break; case KSPROPERTY_CAMERACONTROL_EXTENDED_PHOTOTRIGGERTIME: hr = QPCTimeHandler(pProperty, ulPropertyLength, pvPropertyData, ulDataLength, pulBytesReturned); goto done; break; case KSPROPERTY_CAMERACONTROL_EXTENDED_PHOTOFRAMERATE: hr = PhotoFrameRateHandler(pProperty, ulPropertyLength, pvPropertyData, ulDataLength, pulBytesReturned); goto done; break; } } else if ((IsEqualCLSID(pProperty->Set, PROPSETID_VIDCAP_VIDEOCONTROL)) && (pProperty->Id == KSPROPERTY_VIDEOCONTROL_MODE)) { // //A photo trigger was sent!!! //We need to set the event haveoutput // PKSPROPERTY_VIDEOCONTROL_MODE_S VideoControl = NULL; if (sizeof(KSPROPERTY_VIDEOCONTROL_MODE_S) == ulDataLength) { VideoControl = (PKSPROPERTY_VIDEOCONTROL_MODE_S)pvPropertyData; m_PhotoModeIsPhotoSequence = false; if (VideoControl->Mode == KS_VideoControlFlag_StartPhotoSequenceCapture) { // //Signalling start of photo sequence // DMFTRACE(DMFT_GENERAL, TRACE_LEVEL_INFORMATION, "%!FUNC! Starting PhotoSequence Trigger"); m_PhotoModeIsPhotoSequence = true; setPhotoTriggerSent(true); } else if (VideoControl->Mode == KS_VideoControlFlag_StopPhotoSequenceCapture) { DMFTRACE(DMFT_GENERAL, TRACE_LEVEL_INFORMATION, "%!FUNC! Stopping PhotoSequence Trigger"); m_PhotoModeIsPhotoSequence = false; setPhotoTriggerSent(false); } else { // //Normal trigger sent for single photo acquisition! // DMFTRACE(DMFT_GENERAL, TRACE_LEVEL_INFORMATION, "%!FUNC! Take Single Photo Trigger"); setPhotoTriggerSent(true); } } if (!filterHasIndependentPin()) { goto done; } } hr = m_spIkscontrol->KsProperty(pProperty, ulPropertyLength, pvPropertyData, ulDataLength, pulBytesReturned); done: LPSTR guidStr = DumpGUIDA(pProperty->Set); DMFTRACE(DMFT_GENERAL, TRACE_LEVEL_INFORMATION, "%!FUNC! g:%s p:%d exiting %x = %!HRESULT!", guidStr, pProperty->Id, hr, hr); delete(guidStr); return hr; } STDMETHODIMP CMultipinMft::KsMethod( _In_reads_bytes_(ulPropertyLength) PKSMETHOD pMethod, _In_ ULONG ulPropertyLength, _Inout_updates_bytes_(ulDataLength) LPVOID pvPropertyData, _In_ ULONG ulDataLength, _Inout_ ULONG* pulBytesReturned ) /*++ Description: Implements IKSProperty::KsMethod function. --*/ { return m_spIkscontrol->KsMethod( pMethod, ulPropertyLength, pvPropertyData, ulDataLength, pulBytesReturned ); } STDMETHODIMP CMultipinMft::KsEvent( _In_reads_bytes_(ulEventLength) PKSEVENT pEvent, _In_ ULONG ulEventLength, _Inout_updates_bytes_opt_(ulDataLength) LPVOID pEventData, _In_ ULONG ulDataLength, _Inout_ ULONG* pBytesReturned ) /*++ Description: Implements IKSProperty::KsEvent function. --*/ { HRESULT hr = S_OK; if (pEvent && (pEvent->Set == KSEVENTSETID_ExtendedCameraControl) && (pEvent->Id == KSPROPERTY_CAMERACONTROL_EXTENDED_WARMSTART)) { DMFTRACE(DMFT_GENERAL, TRACE_LEVEL_INFORMATION, "%!FUNC! Acquiring Event for Async Extended Control"); // // For the Sample the warmstate handlers are supported by Device MFT and not passed to driver // hr = m_eventHandler.KSEvent(pEvent, ulEventLength, pEventData, ulDataLength, pBytesReturned ); goto done; } if ((pEvent && (pEvent->Set == KSEVENTSETID_ExtendedCameraControl)) && (!filterHasIndependentPin())) { // // Important: Extended controls will send events which are strictly // One shot. The event comes first where it should be duped and stored, // the control comes next. The event should be set after control completes // and it should be then closed. // The below code handles only certain events needed for // implementing photo sequence. For a complete exhaustive // list refer documentation. // switch (pEvent->Id) { case KSPROPERTY_CAMERACONTROL_EXTENDED_PHOTOMODE: case KSPROPERTY_CAMERACONTROL_EXTENDED_PHOTOMAXFRAMERATE: case KSPROPERTY_CAMERACONTROL_EXTENDED_MAXVIDFPS_PHOTORES: case KSPROPERTY_CAMERACONTROL_EXTENDED_PHOTOTRIGGERTIME: case KSPROPERTY_CAMERACONTROL_EXTENDED_PHOTOFRAMERATE: { DMFTRACE(DMFT_GENERAL, TRACE_LEVEL_INFORMATION, "%!FUNC! Acquiring Event for Async Extended Control"); // // Let the event handler handle the event // DMFTCHECKHR_GOTO(m_eventHandler.KSEvent(pEvent, ulEventLength, pEventData, ulDataLength, pBytesReturned ),done); goto done; } } } // // All the Events we don't handle should be sent to the driver! // hr = m_spIkscontrol->KsEvent(pEvent, ulEventLength, pEventData, ulDataLength, pBytesReturned); done: DMFTRACE(DMFT_GENERAL, TRACE_LEVEL_INFORMATION, "%!FUNC! exiting %x = %!HRESULT!", hr, hr); return hr; } #if defined (MF_DEVICEMFT_PHTOTOCONFIRMATION) // //IMFGetService functions // STDMETHODIMP CMultipinMft::GetService( __in REFGUID guidService, __in REFIID riid, __deref_out LPVOID* ppvObject ) { // //This doesn't necessarily need to be a GetService function, but this is just so that the //pipeline implementation and the Device transform implementation is consistent. //In this sample the photoconfirmation interface is implementated by the same class //we can delegate it later to any of the pins if needed // UNREFERENCED_PARAMETER(guidService); if (riid == __uuidof(IMFCapturePhotoConfirmation)) { return QueryInterface(riid, ppvObject); } else return MF_E_UNSUPPORTED_SERVICE; } // //IMFCapturePhotoConfirmation functions implemented // STDMETHODIMP CMultipinMft::SetPhotoConfirmationCallback( _In_ IMFAsyncCallback* pNotificationCallback ) { CAutoLock Lock(m_critSec); DMFTRACE(DMFT_GENERAL, TRACE_LEVEL_INFORMATION, "%!FUNC! Setting PhotoConfirmation %p, is passed", pNotificationCallback); m_spPhotoConfirmationCallback = pNotificationCallback; return S_OK; } STDMETHODIMP CMultipinMft::SetPixelFormat( _In_ GUID subtype ) { m_guidPhotoConfirmationSubtype = subtype; return S_OK; } STDMETHODIMP CMultipinMft::GetPixelFormat( _Out_ GUID* subtype ) { *subtype = m_guidPhotoConfirmationSubtype; return S_OK; } #endif #if defined (MF_DEVICEMFT_ALLOW_MFT0_LOAD) && defined (MFT_UNIQUE_METHOD_NAMES) // // IMFTransform function(s). // // // Note: This is the only IMFTransform function which is not a redirector to the // DeviceTransform functions. The rest of IMFTransform functions are in the file common.h // This function returns the IMFAttribute created for Device MFT. If DMFT is // not loaded (usually )MFT0's call to GetAttributes will get the Attribute store of DevProxy. // A device MFT loaded will not pass through the devproxy attribute store, but it will pass // the device MFT attributes. This should be similar to the singular DevProxy attribute // which the MFT0 providers can use to synchronize across various MFT0's // STDMETHODIMP CMultipinMft::GetAttributes( _COM_Outptr_opt_result_maybenull_ IMFAttributes** ppAttributes ) { HRESULT hr = S_OK; DMFTCHECKNULL_GOTO(ppAttributes, done, E_INVALIDARG); *ppAttributes = nullptr; if (m_spAttributes != nullptr) { m_spAttributes.CopyTo(ppAttributes); } else { hr = E_OUTOFMEMORY; } done: return hr; } #endif // //HELPER FUNCTIONS // STDMETHODIMP_(CBasePin*) CMultipinMft::GetInPin( _In_ DWORD dwStreamId ) { CInPin *inPin = NULL; for (DWORD dwIndex = 0, dwSize = (DWORD)m_InPins.size(); dwIndex < dwSize; dwIndex++) { inPin = (CInPin *)m_InPins[dwIndex]; if (dwStreamId == inPin->streamId()) { break; } inPin = NULL; } return inPin; } STDMETHODIMP_(CBasePin*) CMultipinMft::GetOutPin( _In_ DWORD dwStreamId ) { COutPin *outPin = NULL; for ( DWORD dwIndex = 0, dwSize = (DWORD) m_OutPins.size(); dwIndex < dwSize; dwIndex++ ) { outPin = ( COutPin * )m_OutPins[ dwIndex ]; if ( dwStreamId == outPin->streamId() ) { break; } outPin = NULL; } return outPin; } /*++ Description: This is a critical function which changes the state on an output pin This should be called under the control lock of the DT. Here the --*/ STDMETHODIMP CMultipinMft::ChangeMediaTypeEx( _In_ ULONG pinId, _In_opt_ IMFMediaType *pMediaType, _In_ DeviceStreamState reqState ) { HRESULT hr = S_OK; DeviceStreamState oldOutPinState; DeviceStreamState newOutStreamState; ComPtr pFullType = nullptr; COutPin *poPin = static_cast( GetOutPin(pinId) ); MMFTMMAPITERATOR inputPinPos; DMFTCHECKNULL_GOTO( poPin, done, E_INVALIDARG ); // //Check if the media type requested is a supported type // if ( pMediaType ) { if ( !poPin->IsMediaTypeSupported( pMediaType, &pFullType ) ) { DMFTCHECKHR_GOTO(MF_E_INVALIDMEDIATYPE, done); } } // //First step disable the output pin. store the old state // oldOutPinState = poPin->SetState( DeviceStreamState_Disabled ); (void)poPin->FlushQueues(); newOutStreamState = pinStateTransition[oldOutPinState][reqState]; //New state needed // //Go through the output pins' maps that has the conencted input pin to the output pin // inputPinPos = m_outputPinMap.equal_range( pinId ); for (std::multimap::iterator piterator = inputPinPos.first; piterator != inputPinPos.second;piterator++) { // //Get the output pins connected to the input pin. The input pin map consists of the output pins connected // ULONG connectedInputPin = (*piterator).second; BOOL isAnyConnectedOutPinActive = false; BOOL isAnyConnectedOutPinPaused = false; BOOL isAnyConnectedOutPinRunning = false; BOOL doWeWaitForSetInput = false; DeviceStreamState oldInputStreamState; MF_TRANSFORM_XVP_OPERATION operation = DeviceMftTransformXVPIllegal; ComPtr pInputMediaType = nullptr; CInPin *pconnectedInPin = (CInPin*)GetInPin( connectedInputPin ); oldInputStreamState = pconnectedInPin->SetState( DeviceStreamState_Disabled ); DeviceStreamState newRequestedInPinState = pinStateTransition[oldInputStreamState][newOutStreamState]; if (pFullType) { pconnectedInPin->getMediaType( &pInputMediaType ); } // // Check if we need an XVP to be inserted between this input and output pins. // CompareMediaTypesForXVP( pInputMediaType.Get(), pFullType.Get(), &operation ); DMFTCHECKHR_GOTO( GetConnectOutPinStatus( connectedInputPin, pinId, // pinId = stream which should be excluded from the search. This function searches if &isAnyConnectedOutPinPaused, // there are any other output pins connected other than the ouput pin (on which the change media type is requested) &isAnyConnectedOutPinRunning, //, which is streaming, paused. This way if the output pin is requested to go to Pause, Stop and if any of the &isAnyConnectedOutPinActive ),done ); //other connected output pins are active, then input it not deactivated // //Check if we are asked to go to an active state //Check for the new media type. if // if ( !IsPinStateInActive( newRequestedInPinState ) ) { // //We are being told to go active //We will request a change in input stream state. // DMFTRACE( DMFT_GENERAL, TRACE_LEVEL_INFORMATION, "%!FUNC! %p Going active IN: %d OUT: %d ", this, connectedInputPin, pinId ); doWeWaitForSetInput = true; if ( !pFullType ) { DMFTCHECKHR_GOTO(MF_E_INVALIDMEDIATYPE, done); } if ( (! pInputMediaType ) || ( operation == DeviceMftTransformXVPDisruptiveIn ) ) { pInputMediaType = pFullType; } if ( newRequestedInPinState == DeviceStreamState_Pause && isAnyConnectedOutPinRunning ) { newRequestedInPinState = DeviceStreamState_Run; } } else { // //We have been requested to go inactive // DMFTRACE( DMFT_GENERAL, TRACE_LEVEL_INFORMATION, "%!FUNC! %p Going Inactive IN: %d OUT: %d ", this, connectedInputPin, pinId ); if ( operation == DeviceMftTransformXVPDisruptiveIn ) { // //Only where we recieve a disruptive media type change and a media type along with it, which is unlikely!! // pInputMediaType = pFullType; doWeWaitForSetInput = true; } if ( isAnyConnectedOutPinActive ) { newRequestedInPinState = ( isAnyConnectedOutPinRunning ) ? DeviceStreamState_Run : DeviceStreamState_Pause; } else { //Switch over to the new media type.. pInputMediaType = pFullType; if ( !IsPinStateInActive( oldInputStreamState ) ) { //It was originall active.. now going down doWeWaitForSetInput = true; } } } // // This will happen if we need a change in Input media type, We will send an event // METransformInputStreamStateChanged to the Device transform manager. This will result // in the Device Transform manager calling us back in getprefferedinputstate where // we will give it back the state of the input and the media type to be set. // All this happens when we are holding a lock here in Change output media type. Hence during the // input media type change we don't hold a lock. THE DTM takes care not to send you any more media // type change operations that can cause a deadlock. // if ( doWeWaitForSetInput ) { pconnectedInPin->setPreferredMediaType( pInputMediaType.Get() ); pconnectedInPin->setPreferredStreamState( newRequestedInPinState ); SendEventToManager( METransformInputStreamStateChanged, GUID_NULL, pconnectedInPin->streamId() ); // //The media type will be set on the input pin by the time we return from the wait // DMFTCHECKHR_GOTO( pconnectedInPin->WaitForSetInputPinMediaChange(), done ); } else { pconnectedInPin->SetState( oldInputStreamState ); pconnectedInPin->setMediaType( pInputMediaType.Get() ); } //Now the input type is all set.. pInputMediaType = nullptr; (VOID)pconnectedInPin->getMediaType( &pInputMediaType ); // //Now propogate the media type change to the output pins // MMFTMMAPITERATOR outputPinPos = m_inputPinMap.equal_range(pconnectedInPin->streamId()); for ( std::multimap::iterator poutPinsIterator = outputPinPos.first; poutPinsIterator != outputPinPos.second; poutPinsIterator++ ) { ComPtr pOutMediatype = nullptr; DeviceStreamState outPinState; ULONG connectedoutPin = (*poutPinsIterator).second; COutPin* pIoPin = static_cast( GetOutPin ( connectedoutPin ) ); (VOID)pIoPin->getMediaType( &pOutMediatype ); outPinState = pIoPin->GetState(); if ( pIoPin->streamId() != pinId) { // //This is the pin other than the output pin where the original change media type was recieved. // if ( pInputMediaType != nullptr && pOutMediatype != nullptr ) { DMFTCHECKHR_GOTO( pIoPin->ChangeMediaTypeFromInpin(pconnectedInPin, pInputMediaType.Get(), pOutMediatype.Get(), outPinState ),done); } } else { // //Change the media type of the requested output pin // DMFTCHECKHR_GOTO( pIoPin->ChangeMediaTypeFromInpin(pconnectedInPin, pInputMediaType.Get(), pFullType.Get(), newOutStreamState), done); //Also signal to the manager that a stream state change has happened SendEventToManager( MEUnknown, MEDeviceStreamCreated, pIoPin->streamId()); // //Set the First Sample Flag. this will get reset when the first sample comes in. We will signal the discontinuity //when we get a Processoutput from the Device Transform Manager // pIoPin->SetFirstSample(TRUE); } pOutMediatype = nullptr; } } done: DMFTRACE(DMFT_GENERAL, TRACE_LEVEL_INFORMATION, "%!FUNC! exiting %x = %!HRESULT!", hr, hr); return hr; } STDMETHODIMP CMultipinMft::SendEventToManager( _In_ MediaEventType eventType, _In_ REFGUID pGuid, _In_ UINT32 context ) /*++ Description: Used to send the event to DTM. --*/ { HRESULT hr = S_OK; ComPtr pEvent = nullptr; DMFTCHECKHR_GOTO(MFCreateMediaEvent(eventType, pGuid, S_OK, NULL, &pEvent ),done); DMFTCHECKHR_GOTO(pEvent->SetUINT32(MF_EVENT_MFT_INPUT_STREAM_ID, (ULONG)context),done); DMFTCHECKHR_GOTO(QueueEvent(pEvent.Get()),done); done: return hr; } STDMETHODIMP CMultipinMft::GetConnectOutPinStatus( _In_ ULONG ulPinId, _In_ ULONG ulOutPinId, _Inout_ PBOOL pAnyInPauseState, _Inout_ PBOOL pAnyInRunState, _Inout_ PBOOL pAnyActive ) /*++ Description: This function gets the statuses of the output pins other than the one specified The arguments are as follows ulPinId: The input pins which are connected to the ouput pin ulOutPinId ulOutPinId: The pin to be excluded from the check i.e. the input pin from which the request is usually sent. --*/ { HRESULT hr = S_OK; MMFTMMAPITERATOR outputPinPos; CInPin *pconnectedInPin = (CInPin*)GetInPin(ulPinId); DMFTCHECKNULL_GOTO( pconnectedInPin, done, E_INVALIDARG ); outputPinPos = m_inputPinMap.equal_range( pconnectedInPin->streamId() ); DMFTCHECKNULL_GOTO( pconnectedInPin, done, E_FAIL ); *pAnyActive = *pAnyInPauseState = *pAnyInRunState = false; for ( std::multimap::iterator poutPosIterator = outputPinPos.first; poutPosIterator != outputPinPos.second; poutPosIterator++ ) { ULONG connectedoutPin = (*poutPosIterator).second; COutPin* pconnectedOutPin = ( COutPin * )GetOutPin( connectedoutPin ); if (pconnectedOutPin->streamId() != ulOutPinId) { //This is excluding the outpin which requested pin state change *pAnyActive |= !IsPinStateInActive( pconnectedOutPin->GetState() ); *pAnyInPauseState |= ( pconnectedOutPin->GetState() == DeviceStreamState_Pause ); *pAnyInRunState |= ( pconnectedOutPin->GetState() == DeviceStreamState_Run ); } } done: return S_OK; } /*++ Description: This function connects the input and output pins. Any media type filtering can happen here --*/ STDMETHODIMP CMultipinMft::BridgeInputPinOutputPin( _In_ CInPin* piPin, _In_ COutPin* poPin ) { HRESULT hr = S_OK; ULONG ulIndex = 0; ComPtr pMediaType = nullptr; DMFTCHECKNULL_GOTO( piPin, done, E_INVALIDARG ); DMFTCHECKNULL_GOTO( poPin, done, E_INVALIDARG ); // // Copy over the media types from input pin to output pin. Since there is no // decoder support, only the uncompressed media types are inserted. Please make // sure any pin advertised supports at least one media type. The pipeline doesn't // like pins with no media types // while ( SUCCEEDED( hr = piPin->GetMediaTypeAt( ulIndex++, &pMediaType ))) { GUID subType = GUID_NULL; DMFTCHECKHR_GOTO( pMediaType->GetGUID(MF_MT_SUBTYPE,&subType), done ); if ( IsKnownUncompressedVideoType( subType ) ) { DMFTCHECKHR_GOTO( poPin->AddMediaType(NULL, pMediaType.Get() ), done ); } pMediaType = nullptr; } // //Add the Input Pin to the output Pin // DMFTCHECKHR_GOTO(poPin->AddPin(piPin->streamId()), done); hr = ExceptionBoundary([&](){ // //Add the output pin to the input pin. // piPin->ConnectPin(poPin); }); DMFTCHECKHR_GOTO(hr, done); // //Create the map. This will be useful when we have to decide the state transitions of the pins // m_inputPinMap.insert ( std::pair< int,int >( piPin->streamId(), poPin->streamId()) ); m_outputPinMap.insert ( std::pair< int, int >( poPin->streamId(), piPin->streamId()) ); done: // //Failed adding media types // if (FAILED(hr)) { DMFTRACE(DMFT_GENERAL, TRACE_LEVEL_ERROR, "%!FUNC! exiting %x = %!HRESULT!", hr, hr); } return hr; } // //The below routines are used to implement the extended controls needed to implement the photo sequence //The photo sequence is enabled for cameras with no independent image pins //The extended controls needed to enable photo sequence are discussed in detail in the photo sequence document // /*++ Extended Photo Mode handler is the extended property handler dealing with the photosequence and single mode capabilities of the camera --*/ STDMETHODIMP CMultipinMft::ExtendedPhotoModeHandler( _In_ PKSPROPERTY Property, _In_ ULONG ulPropertyLength, _In_ LPVOID pData, _In_ ULONG ulOutputBufferLength, _Inout_ PULONG pulBytesReturned ) { HRESULT hr = S_OK; UNREFERENCED_PARAMETER( ulPropertyLength ); if ( Property->Flags & KSPROPERTY_TYPE_SET ) { if ( ulOutputBufferLength == 0 ) { *pulBytesReturned = sizeof( KSCAMERA_EXTENDEDPROP_HEADER )+sizeof( KSCAMERA_EXTENDEDPROP_PHOTOMODE ); DMFTCHECKHR_GOTO( HRESULT_FROM_WIN32( ERROR_MORE_DATA ), done ); } else if ( ulOutputBufferLength < sizeof( KSCAMERA_EXTENDEDPROP_HEADER )+sizeof( KSCAMERA_EXTENDEDPROP_PHOTOMODE ) ) { DMFTCHECKHR_GOTO( HRESULT_FROM_WIN32( ERROR_MORE_DATA ), done ); } else if ( pData && ulOutputBufferLength >= sizeof( KSCAMERA_EXTENDEDPROP_HEADER )+sizeof( KSCAMERA_EXTENDEDPROP_PHOTOMODE ) ) { PBYTE pPayload = ( PBYTE )pData; PKSCAMERA_EXTENDEDPROP_HEADER pExtendedHeader = ( PKSCAMERA_EXTENDEDPROP_HEADER )( pPayload ); // //Use the below structure to make changes to the Property and thus affect the configuration //PKSCAMERA_EXTENDEDPROP_PHOTOMODE pExtendedValue = (PKSCAMERA_EXTENDEDPROP_PHOTOMODE)(pPayload + sizeof(KSCAMERA_EXTENDEDPROP_HEADER)); // m_FilterInPhotoSequence = pExtendedHeader->Flags & KSCAMERA_EXTENDEDPROP_PHOTOMODE_SEQUENCE; DMFTCHECKHR_GOTO(m_eventHandler.SetOneShot(KSPROPERTY_CAMERACONTROL_EXTENDED_PHOTOMODE), done); } else { DMFTCHECKHR_GOTO(E_INVALIDARG, done); } } else if ( Property->Flags & KSPROPERTY_TYPE_GET ) { if ( ulOutputBufferLength == 0 ) { *pulBytesReturned = sizeof( KSCAMERA_EXTENDEDPROP_HEADER )+sizeof( KSCAMERA_EXTENDEDPROP_PHOTOMODE ); hr = HRESULT_FROM_WIN32(ERROR_MORE_DATA); } else if ( pData && ulOutputBufferLength >= sizeof( KSCAMERA_EXTENDEDPROP_HEADER )+sizeof( KSCAMERA_EXTENDEDPROP_PHOTOMODE ) ) { PBYTE pPayload = (PBYTE)pData; PKSCAMERA_EXTENDEDPROP_HEADER pExtendedHeader = ( PKSCAMERA_EXTENDEDPROP_HEADER )( pPayload ); PKSCAMERA_EXTENDEDPROP_PHOTOMODE pExtendedValue = ( PKSCAMERA_EXTENDEDPROP_PHOTOMODE )( pPayload + sizeof( KSCAMERA_EXTENDEDPROP_HEADER ) ); pExtendedHeader->Capability = ( KSCAMERA_EXTENDEDPROP_CAPS_ASYNCCONTROL | KSCAMERA_EXTENDEDPROP_PHOTOMODE_SEQUENCE ); pExtendedHeader->Flags = ( m_FilterInPhotoSequence ) ? KSCAMERA_EXTENDEDPROP_PHOTOMODE_SEQUENCE : KSCAMERA_EXTENDEDPROP_PHOTOMODE_NORMAL; pExtendedHeader->Result = 0; pExtendedHeader->Size = sizeof( KSCAMERA_EXTENDEDPROP_HEADER )+sizeof( KSCAMERA_EXTENDEDPROP_PHOTOMODE ); pExtendedHeader->Version = 1; pExtendedValue->MaxHistoryFrames = 10; pExtendedValue->RequestedHistoryFrames = 0 ; pExtendedValue->SubMode = 0 ; *pulBytesReturned = sizeof( KSCAMERA_EXTENDEDPROP_HEADER )+sizeof( KSCAMERA_EXTENDEDPROP_PHOTOMODE ); } else { DMFTCHECKHR_GOTO( E_INVALIDARG, done ); } } done: DMFTRACE( DMFT_GENERAL, TRACE_LEVEL_INFORMATION, "%!FUNC! exiting %x = %!HRESULT!", hr, hr); return hr; } /*++ The Extended Max Frame rate is self explanatory --*/ STDMETHODIMP CMultipinMft::ExtendedPhotoMaxFrameRate( _In_ PKSPROPERTY Property, _In_ ULONG ulPropertyLength, _In_ LPVOID pData, _In_ ULONG ulOutputBufferLength, _Inout_ PULONG pulBytesReturned ) { HRESULT hr = S_OK; UNREFERENCED_PARAMETER( ulPropertyLength ); if ( Property->Flags & KSPROPERTY_TYPE_SET ) { if ( ulOutputBufferLength == 0 ) { *pulBytesReturned = sizeof( KSCAMERA_EXTENDEDPROP_HEADER )+sizeof( KSCAMERA_EXTENDEDPROP_VALUE ); DMFTCHECKHR_GOTO(HRESULT_FROM_WIN32(ERROR_MORE_DATA), done); } else if (ulOutputBufferLength < sizeof(KSCAMERA_EXTENDEDPROP_HEADER)+sizeof(KSCAMERA_EXTENDEDPROP_VALUE)) { DMFTCHECKHR_GOTO(HRESULT_FROM_WIN32(ERROR_MORE_DATA), done); } else if (pData && ulOutputBufferLength >= sizeof(KSCAMERA_EXTENDEDPROP_HEADER)+sizeof(KSCAMERA_EXTENDEDPROP_VALUE)) { // //This is for setting the Max frame rate.. // //PBYTE pPayload = (PBYTE)pData; //PKSCAMERA_EXTENDEDPROP_HEADER pExtendedHeader = (PKSCAMERA_EXTENDEDPROP_HEADER)(pPayload); //PKSCAMERA_EXTENDEDPROP_VALUE pExtendedValue = (PKSCAMERA_EXTENDEDPROP_VALUE)(pPayload + sizeof(KSCAMERA_EXTENDEDPROP_HEADER)); // DMFTCHECKHR_GOTO(m_eventHandler.SetOneShot(KSPROPERTY_CAMERACONTROL_EXTENDED_PHOTOMAXFRAMERATE), done); } else { DMFTCHECKHR_GOTO(E_INVALIDARG, done); } } else if ( Property->Flags & KSPROPERTY_TYPE_GET ) { if ( ulOutputBufferLength == 0 ) { *pulBytesReturned = sizeof( KSCAMERA_EXTENDEDPROP_HEADER )+sizeof( KSCAMERA_EXTENDEDPROP_VALUE ); hr = HRESULT_FROM_WIN32( ERROR_MORE_DATA ); } else if ( pData && ulOutputBufferLength >= sizeof( KSCAMERA_EXTENDEDPROP_HEADER )+sizeof( KSCAMERA_EXTENDEDPROP_VALUE )) { PBYTE pPayload = ( PBYTE )pData; PKSCAMERA_EXTENDEDPROP_HEADER pExtendedHeader = ( PKSCAMERA_EXTENDEDPROP_HEADER )( pPayload ); PKSCAMERA_EXTENDEDPROP_VALUE pExtendedValue = ( PKSCAMERA_EXTENDEDPROP_VALUE )( pPayload + sizeof( KSCAMERA_EXTENDEDPROP_HEADER ) ); pExtendedHeader->Capability = KSCAMERA_EXTENDEDPROP_CAPS_ASYNCCONTROL; pExtendedHeader->Flags = 0; pExtendedHeader->Result = 0; pExtendedHeader->Size = sizeof(KSCAMERA_EXTENDEDPROP_HEADER)+sizeof(KSCAMERA_EXTENDEDPROP_VALUE); pExtendedHeader->Version = 1; pExtendedValue->Value.ratio.HighPart = 30; pExtendedValue->Value.ratio.LowPart = 1; *pulBytesReturned = sizeof(KSCAMERA_EXTENDEDPROP_HEADER)+sizeof(KSCAMERA_EXTENDEDPROP_VALUE); } else { DMFTCHECKHR_GOTO(E_INVALIDARG, done); } } done: DMFTRACE(DMFT_GENERAL, TRACE_LEVEL_INFORMATION, "%!FUNC! exiting %x = %!HRESULT!", hr, hr); return hr; } STDMETHODIMP CMultipinMft::MaxVidFPS_PhotoResHandler( _In_ PKSPROPERTY Property, _In_ ULONG ulPropertyLength, _In_ LPVOID pData, _In_ ULONG ulOutputBufferLength, _Inout_ PULONG pulBytesReturned ) { HRESULT hr = S_OK; UNREFERENCED_PARAMETER( ulPropertyLength ); if ( Property->Flags & KSPROPERTY_TYPE_SET ) { if ( ulOutputBufferLength == 0 ) { *pulBytesReturned = sizeof( KSCAMERA_EXTENDEDPROP_HEADER )+ sizeof( KSCAMERA_MAXVIDEOFPS_FORPHOTORES ); DMFTCHECKHR_GOTO(HRESULT_FROM_WIN32(ERROR_MORE_DATA), done); } else if ( ulOutputBufferLength < sizeof( KSCAMERA_EXTENDEDPROP_HEADER )+ sizeof( KSCAMERA_MAXVIDEOFPS_FORPHOTORES ) ) { DMFTCHECKHR_GOTO( HRESULT_FROM_WIN32( ERROR_MORE_DATA ), done ); } else if (pData && ulOutputBufferLength >= sizeof( KSCAMERA_EXTENDEDPROP_HEADER )+sizeof( KSCAMERA_MAXVIDEOFPS_FORPHOTORES )) { PBYTE pPayload = (PBYTE)pData; PKSCAMERA_EXTENDEDPROP_HEADER pExtendedHeader = ( PKSCAMERA_EXTENDEDPROP_HEADER )( pPayload ); // //Use the extended value to make changes to the property.. refer documentation //PKSCAMERA_MAXVIDEOFPS_FORPHOTORES pExtendedValue = (PKSCAMERA_MAXVIDEOFPS_FORPHOTORES)(pPayload + sizeof(KSCAMERA_EXTENDEDPROP_HEADER)); // pExtendedHeader->Capability = 0; pExtendedHeader->Flags = 0; pExtendedHeader->Result = 0; pExtendedHeader->Size = sizeof( KSCAMERA_EXTENDEDPROP_HEADER )+sizeof( KSCAMERA_EXTENDEDPROP_VALUE ); pExtendedHeader->Version = 1; *pulBytesReturned = sizeof( KSCAMERA_EXTENDEDPROP_HEADER )+sizeof( KSCAMERA_MAXVIDEOFPS_FORPHOTORES ); } else { hr = E_INVALIDARG; } } else if (Property->Flags & KSPROPERTY_TYPE_GET) { if (ulOutputBufferLength == 0) { *pulBytesReturned = sizeof(KSCAMERA_EXTENDEDPROP_HEADER)+sizeof(KSCAMERA_MAXVIDEOFPS_FORPHOTORES); DMFTCHECKHR_GOTO(HRESULT_FROM_WIN32(ERROR_MORE_DATA), done); } else if (ulOutputBufferLength < sizeof(KSCAMERA_EXTENDEDPROP_HEADER)+sizeof(KSCAMERA_MAXVIDEOFPS_FORPHOTORES)) { DMFTCHECKHR_GOTO(HRESULT_FROM_WIN32(ERROR_MORE_DATA), done); } else if (pData && ulOutputBufferLength >= sizeof(KSCAMERA_EXTENDEDPROP_HEADER)+sizeof(KSCAMERA_MAXVIDEOFPS_FORPHOTORES)) { PBYTE pPayload = (PBYTE)pData; PKSCAMERA_EXTENDEDPROP_HEADER pExtendedHeader = ( PKSCAMERA_EXTENDEDPROP_HEADER )(pPayload ); PKSCAMERA_MAXVIDEOFPS_FORPHOTORES pExtendedValue = (PKSCAMERA_MAXVIDEOFPS_FORPHOTORES)(pPayload + sizeof(KSCAMERA_EXTENDEDPROP_HEADER)); pExtendedHeader->Capability = 0; pExtendedHeader->Flags = 0; pExtendedHeader->Result = 0; pExtendedHeader->Size = sizeof(KSCAMERA_EXTENDEDPROP_HEADER) + sizeof(PKSCAMERA_MAXVIDEOFPS_FORPHOTORES); pExtendedHeader->Version = 1; pExtendedValue->PreviewFPSNum = 30; pExtendedValue->PreviewFPSDenom = 1; pExtendedValue->CaptureFPSNum = 30; pExtendedValue->CaptureFPSDenom = 1; pExtendedValue->PhotoResHeight = 240; pExtendedValue->PhotoResWidth = 320; *pulBytesReturned = sizeof(KSCAMERA_EXTENDEDPROP_HEADER) + sizeof(KSCAMERA_MAXVIDEOFPS_FORPHOTORES); } else { hr = E_INVALIDARG; } } done: DMFTRACE(DMFT_GENERAL, TRACE_LEVEL_INFORMATION, "%!FUNC! exiting %x = %!HRESULT!", hr, hr); return hr; } STDMETHODIMP CMultipinMft::QPCTimeHandler( _In_ PKSPROPERTY Property, _In_ ULONG ulPropertyLength, _In_ LPVOID pData, _In_ ULONG ulOutputBufferLength, _Inout_ PULONG pulBytesReturned ) { HRESULT hr = S_OK; UNREFERENCED_PARAMETER( ulPropertyLength ); if ( Property->Flags & KSPROPERTY_TYPE_SET ) { if ( ulOutputBufferLength == 0 ) { *pulBytesReturned = sizeof( KSCAMERA_EXTENDEDPROP_HEADER )+sizeof( KSCAMERA_EXTENDEDPROP_VALUE ); DMFTCHECKHR_GOTO( HRESULT_FROM_WIN32( ERROR_MORE_DATA ), done ); } else if ( ulOutputBufferLength < sizeof( KSCAMERA_EXTENDEDPROP_HEADER )+sizeof( KSCAMERA_EXTENDEDPROP_VALUE ) ) { DMFTCHECKHR_GOTO(HRESULT_FROM_WIN32(ERROR_MORE_DATA), done); } else if ( pData && ulOutputBufferLength >= sizeof( KSCAMERA_EXTENDEDPROP_HEADER )+sizeof( KSCAMERA_EXTENDEDPROP_VALUE ) ) { //PBYTE pPayload = (PBYTE)pData; // //If the payload is to be used.. use the below structures // //PKSCAMERA_EXTENDEDPROP_HEADER pExtendedHeader = (PKSCAMERA_EXTENDEDPROP_HEADER)(pPayload); //Use the extended value to make changes to the property.. refer documentation //PKSCAMERA_EXTENDEDPROP_VALUE pExtendedValue = (PKSCAMERA_EXTENDEDPROP_VALUE)(pPayload +sizeof(KSCAMERA_EXTENDEDPROP_HEADER)); // *pulBytesReturned = sizeof( PKSCAMERA_EXTENDEDPROP_HEADER )+sizeof( KSCAMERA_EXTENDEDPROP_VALUE ); } else { hr = E_INVALIDARG; } } else if ( Property->Flags & KSPROPERTY_TYPE_GET ) { if ( ulOutputBufferLength == 0 ) { *pulBytesReturned = sizeof( KSCAMERA_EXTENDEDPROP_HEADER )+sizeof( KSCAMERA_EXTENDEDPROP_VALUE ); DMFTCHECKHR_GOTO(HRESULT_FROM_WIN32(ERROR_MORE_DATA), done); } else if ( ulOutputBufferLength < sizeof( KSCAMERA_EXTENDEDPROP_HEADER ) + sizeof( KSCAMERA_EXTENDEDPROP_VALUE ) ) { DMFTCHECKHR_GOTO( HRESULT_FROM_WIN32( ERROR_MORE_DATA ), done ); } else if ( pData && ulOutputBufferLength >= sizeof( KSCAMERA_EXTENDEDPROP_HEADER ) + sizeof( KSCAMERA_EXTENDEDPROP_VALUE ) ) { PBYTE pPayload = (PBYTE)pData; PKSCAMERA_EXTENDEDPROP_HEADER pExtendedHeader = ( PKSCAMERA_EXTENDEDPROP_HEADER )( pPayload ); PKSCAMERA_EXTENDEDPROP_VALUE pExtendedValue = ( PKSCAMERA_EXTENDEDPROP_VALUE )( pPayload + sizeof( KSCAMERA_EXTENDEDPROP_HEADER ) ); pExtendedHeader->Capability = 0; pExtendedHeader->Flags = KSPROPERTY_CAMERA_PHOTOTRIGGERTIME_SET; pExtendedHeader->Result = 0; pExtendedHeader->Size = sizeof( KSCAMERA_EXTENDEDPROP_HEADER ) + sizeof( KSCAMERA_EXTENDEDPROP_VALUE ); pExtendedHeader->Version = 1; pExtendedValue->Value.ull = 0; *pulBytesReturned = sizeof( KSCAMERA_EXTENDEDPROP_HEADER )+ sizeof( KSCAMERA_EXTENDEDPROP_VALUE ); } else { hr = E_INVALIDARG; } } done: DMFTRACE( DMFT_GENERAL, TRACE_LEVEL_INFORMATION, "%!FUNC! exiting %x = %!HRESULT!", hr, hr ); return hr; } STDMETHODIMP CMultipinMft::PhotoFrameRateHandler( _In_ PKSPROPERTY Property, _In_ ULONG ulPropertyLength, _In_ LPVOID pData, _In_ ULONG ulOutputBufferLength, _Inout_ PULONG pulBytesReturned ) { HRESULT hr = S_OK; UNREFERENCED_PARAMETER( ulPropertyLength ); if ( Property->Flags & KSPROPERTY_TYPE_SET ) { // //This is a read only property!!! // hr = E_INVALIDARG; } else if ( Property->Flags & KSPROPERTY_TYPE_GET ) { if ( ulOutputBufferLength < sizeof( KSCAMERA_EXTENDEDPROP_HEADER )+sizeof( KSCAMERA_EXTENDEDPROP_VALUE )) { *pulBytesReturned = sizeof( KSCAMERA_EXTENDEDPROP_HEADER )+sizeof( KSCAMERA_EXTENDEDPROP_VALUE ); DMFTCHECKHR_GOTO( HRESULT_FROM_WIN32( ERROR_MORE_DATA ), done ); } PBYTE pPayload = (PBYTE)pData; PKSCAMERA_EXTENDEDPROP_HEADER pExtendedHeader = ( PKSCAMERA_EXTENDEDPROP_HEADER )( pPayload ); PKSCAMERA_EXTENDEDPROP_VALUE pExtendedValue = ( PKSCAMERA_EXTENDEDPROP_VALUE )( pPayload + sizeof( KSCAMERA_EXTENDEDPROP_HEADER ) ); pExtendedHeader->Capability = 0; pExtendedHeader->Flags = 0; pExtendedHeader->Result = 0; pExtendedHeader->Size = sizeof( KSCAMERA_EXTENDEDPROP_HEADER )+sizeof( KSCAMERA_EXTENDEDPROP_VALUE ); pExtendedHeader->Version = 1; pExtendedValue->Value.ratio.HighPart = 30; pExtendedValue->Value.ratio.LowPart = 1; *pulBytesReturned = sizeof( KSCAMERA_EXTENDEDPROP_HEADER )+sizeof( KSCAMERA_EXTENDEDPROP_VALUE ); } done: DMFTRACE( DMFT_GENERAL, TRACE_LEVEL_INFORMATION, "%!FUNC! exiting %x = %!HRESULT!", hr, hr ); return hr; } STDMETHODIMP CMultipinMft::WarmStartHandler( _In_ PKSPROPERTY Property, _In_ ULONG ulPropertyLength, _In_ LPVOID pData, _In_ ULONG ulOutputBufferLength, _Inout_ PULONG pulBytesReturned ) { HRESULT hr = S_OK; UNREFERENCED_PARAMETER( ulPropertyLength ); *pulBytesReturned = 0; if ( Property->Flags & KSPROPERTY_TYPE_SET ) { if ( ulOutputBufferLength == 0 ) { *pulBytesReturned = sizeof( KSCAMERA_EXTENDEDPROP_HEADER )+sizeof( KSCAMERA_EXTENDEDPROP_VALUE ); DMFTCHECKHR_GOTO( HRESULT_FROM_WIN32( ERROR_MORE_DATA ), done); } else if (ulOutputBufferLength < sizeof( KSCAMERA_EXTENDEDPROP_HEADER )+sizeof( KSCAMERA_EXTENDEDPROP_VALUE )) { DMFTCHECKHR_GOTO( HRESULT_FROM_WIN32( ERROR_MORE_DATA ), done); } else if ( pData && ulOutputBufferLength >= sizeof( KSCAMERA_EXTENDEDPROP_HEADER )+sizeof( KSCAMERA_EXTENDEDPROP_VALUE )) { PBYTE pPayload = ( PBYTE )pData; PKSCAMERA_EXTENDEDPROP_HEADER pExtendedHeader = ( PKSCAMERA_EXTENDEDPROP_HEADER )pPayload; // //Use the extended value to make changes to the property.. refer documentation //PKSCAMERA_EXTENDEDPROP_VALUE pExtendedValue = (PKSCAMERA_EXTENDEDPROP_VALUE)(pPayload + sizeof(KSCAMERA_EXTENDEDPROP_HEADER)); // if ( pExtendedHeader->Flags & KSCAMERA_EXTENDEDPROP_WARMSTART_MODE_ENABLED ) { m_filterInWarmStart = true; } else { m_filterInWarmStart = false; } *pulBytesReturned = sizeof( PKSCAMERA_EXTENDEDPROP_HEADER )+sizeof( KSCAMERA_EXTENDEDPROP_VALUE ); m_eventHandler.SetOneShot(KSPROPERTY_CAMERACONTROL_EXTENDED_WARMSTART); } else { hr = S_OK; } } else if (Property->Flags & KSPROPERTY_TYPE_GET) { if (ulOutputBufferLength == 0) { *pulBytesReturned = sizeof( KSCAMERA_EXTENDEDPROP_HEADER )+sizeof( KSCAMERA_EXTENDEDPROP_VALUE ); DMFTCHECKHR_GOTO(HRESULT_FROM_WIN32(ERROR_MORE_DATA), done); } else if (ulOutputBufferLength < sizeof( KSCAMERA_EXTENDEDPROP_HEADER )+sizeof( KSCAMERA_EXTENDEDPROP_VALUE )) { DMFTCHECKHR_GOTO( HRESULT_FROM_WIN32( ERROR_MORE_DATA ), done ); } else if (pData && ulOutputBufferLength >= sizeof( KSCAMERA_EXTENDEDPROP_HEADER )+sizeof( KSCAMERA_EXTENDEDPROP_VALUE )) { PBYTE pPayload = ( PBYTE )pData; PKSCAMERA_EXTENDEDPROP_HEADER pExtendedHeader = ( PKSCAMERA_EXTENDEDPROP_HEADER )( pPayload ); // //Use the extended value to make changes to the property.. refer documentation //PKSCAMERA_EXTENDEDPROP_VALUE pExtendedValue = (PKSCAMERA_EXTENDEDPROP_VALUE)(pPayload +sizeof(KSCAMERA_EXTENDEDPROP_HEADER)); // pExtendedHeader->Capability = KSCAMERA_EXTENDEDPROP_CAPS_ASYNCCONTROL | KSCAMERA_EXTENDEDPROP_WARMSTART_MODE_ENABLED; pExtendedHeader->Flags = 0; if (m_filterInWarmStart) { pExtendedHeader->Flags |= KSCAMERA_EXTENDEDPROP_WARMSTART_MODE_ENABLED; } pExtendedHeader->Result = 0; pExtendedHeader->Size = sizeof( KSCAMERA_EXTENDEDPROP_HEADER )+sizeof( KSCAMERA_EXTENDEDPROP_VALUE ); pExtendedHeader->Version = 1; *pulBytesReturned = sizeof( KSCAMERA_EXTENDEDPROP_HEADER )+sizeof( KSCAMERA_EXTENDEDPROP_VALUE ); hr = S_OK; } else { hr = S_OK; } } done: DMFTRACE( DMFT_GENERAL, TRACE_LEVEL_INFORMATION, "%!FUNC! exiting %x = %!HRESULT!", hr, hr ); return hr; } // // IMFShutdown interface functions // /*++ Description: Implements the Shutdown from IMFShutdown --*/ STDMETHODIMP CMultipinMft::Shutdown( void ) { CAutoLock Lock(m_critSec); (VOID) m_eventHandler.Clear(); return ShutdownEventGenerator(); } // // Static method to create an instance of the MFT. // HRESULT CMultipinMft::CreateInstance(REFIID iid, void **ppMFT) { HRESULT hr = S_OK; CMultipinMft *pMFT = NULL; DMFTCHECKNULL_GOTO(ppMFT, done, E_POINTER); pMFT = new (std::nothrow) CMultipinMft(); DMFTCHECKNULL_GOTO(pMFT, done, E_OUTOFMEMORY); DMFTCHECKHR_GOTO(pMFT->QueryInterface(iid, ppMFT), done); done: if (FAILED(hr)) { SAFERELEASE(pMFT); } DMFTRACE(DMFT_GENERAL, TRACE_LEVEL_INFORMATION, "%!FUNC! exiting %x = %!HRESULT!", hr, hr); return hr; } #if defined (MF_DEVICEMFT_PHTOTOCONFIRMATION) /* Desciption: This function will be called by the preview pin to execute the photo confirmation stored with the MFT. */ STDMETHODIMP CMultipinMft::ProcessCapturePhotoConfirmationCallBack( _In_ IMFMediaType* pMediaType, _In_ IMFSample* pSample ) { // //PhotoConfirmation Implementation //Note this function doesn't scan the metadata as the pipeline does to find out which buffer is the photoconfirmation buffer //The pipeline treats the preview buffer as the photo confirmation buffer and the driver marks the metadata on the buffer as being so. //This example treats every buffer coming on the pin as the confirmation buffer. // HRESULT hr = S_OK; ComPtr spMediaType = nullptr; LONGLONG timeStamp = 0; DMFTCHECKHR_GOTO(MFCreateMediaType(&spMediaType), done); DMFTCHECKHR_GOTO(pMediaType->CopyAllItems(spMediaType.Get()), done); DMFTCHECKHR_GOTO(pSample->SetUnknown(MFSourceReader_SampleAttribute_MediaType_priv, spMediaType.Get()), done); DMFTCHECKHR_GOTO(pSample->GetSampleTime(&timeStamp), done); DMFTCHECKHR_GOTO(pSample->SetUINT64(MFSampleExtension_DeviceReferenceSystemTime, timeStamp), done); if (m_spPhotoConfirmationCallback) { // //We are directly sending the photo sample over to the consumers of the photoconfirmation interface. // ComPtr spResult; DMFTCHECKHR_GOTO(MFCreateAsyncResult(pSample, m_spPhotoConfirmationCallback.Get(), NULL, &spResult), done); DMFTCHECKHR_GOTO(MFInvokeCallback(spResult.Get()), done); } done: DMFTRACE(DMFT_GENERAL, TRACE_LEVEL_INFORMATION, "%!FUNC! exiting %x = %!HRESULT!", hr, hr); return hr; } #endif // // Only worry about this if you have customs pins defined in the driver // STDMETHODIMP CMultipinMft::SetStreamingStateCustomPins( DeviceStreamState State ) { HRESULT hr = S_OK; if ( m_CustomPinCount > 0 ) { DMFTRACE(DMFT_GENERAL, TRACE_LEVEL_INFORMATION, "%!FUNC! Custom Pin State changing to %d", State); for (ULONG ulIndex = 0; ulIndex < m_InPins.size(); ulIndex++) { BOOL isCustom = false; CInPin* pInPin = static_cast(m_InPins[ulIndex]); if ( SUCCEEDED( CheckCustomPin(pInPin, &isCustom) ) && ( isCustom ) ) { pInPin->SetState(State); } } } DMFTRACE(DMFT_GENERAL, TRACE_LEVEL_INFORMATION, "%!FUNC! exiting %x = %!HRESULT!", hr, hr); return hr; }