//------------------------------------------------------------------------------
// Deliver
// Attach the supplied buffer to a free media sample.  Add media sample to delivery
// queue so that the streaming thread can deliver the sample downstream.  If there
// are no free samples, all have been delivered downstream, block until one is returned
// to the free list.  If the streaming thread is blocked, waiting for a sample to
// become available on the delivery queue, signal the thread when a new sample is added.
STDMETHODIMP CCustomAllocator::Deliver(unsigned char* pBuffer)
{
	HRESULT hr = S_OK;

	if (pBuffer)
	{
		CMediaSample* pSample = NULL;

	    for (;;)
		{
			{  // scope for lock
				CAutoLock cObjectLock(this);

	            /* Check we are committed */
		        if (!m_bCommitted)
			    {
				    return VFW_E_NOT_COMMITTED;
				}
				pSample = (CMediaSample*)m_lFree.RemoveHead();
				if (pSample == NULL)
				{
					SetWaitingFree();
	            }
		    }

		    if (pSample)
			{
				hr = pSample->SetPointer(pBuffer, m_lSize);
				if (SUCCEEDED(hr))
				{
					CAutoLock cObjectLock(this);
					m_lDeliver.AddTail(pSample);
					NotifySample();
					DbgLog((LOG_TRACE, DBG_MEM, TEXT("CCustomAllocator::Deliver(): m_lFree: %d  m_lDeliver: %d"), m_lFree.GetCount(), m_lDeliver.GetCount()));
				}
				break;
	        }

	        /* If we didn't get a sample then wait for the list to signal */
	        ASSERT(m_hSemFree);
		    WaitForSingleObject(m_hSemFree, INFINITE);
		}
	}
	else
	{
		hr = E_POINTER;
	}
	
	return hr;
}

//----------------------------------------------------------------------------
//! @brief	  	要求するメモリの詳細を設定する。
//! @param		pRequest : バッファ要求を含む ALLOCATOR_PROPERTIES 構造体のポインタ
//! @param		pActual : 実際のバッファ プロパティを受け取る ALLOCATOR_PROPERTIES 構造体のポインタ
//! @return		エラーコード
//----------------------------------------------------------------------------
STDMETHODIMP TBufferRendererAllocator::SetProperties( ALLOCATOR_PROPERTIES* pRequest, ALLOCATOR_PROPERTIES* pActual )
{
	CheckPointer( pActual, E_POINTER );
	ValidateReadWritePtr( pActual, sizeof(ALLOCATOR_PROPERTIES) );
	CAutoLock	cObjectLock(this);

    ZeroMemory( pActual, sizeof(ALLOCATOR_PROPERTIES) );

	if( m_bCommitted == TRUE)
		return VFW_E_ALREADY_COMMITTED;

	if( m_lFree.GetCount() < m_lAllocated )	// m_lAllocatedが1個以上の時はエラーにした方がよい？
		return VFW_E_BUFFERS_OUTSTANDING;

	if( pRequest->cBuffers == 1 && pRequest->cbBuffer == m_pRenderer->GetBufferSize() &&
		pRequest->cbAlign == 1 && pRequest->cbPrefix == 0 )
	{
		*pActual = *pRequest;
		m_lSize = pRequest->cbBuffer;
		m_lCount = pRequest->cBuffers;
		m_lAlignment = pRequest->cbAlign;
		m_lPrefix = pRequest->cbPrefix;
		m_bChanged = TRUE;
		return S_OK;
	}

	return VFW_E_BADALIGN;
}

//
// Run
//
STDMETHODIMP CDVBSub::Run( REFERENCE_TIME tStart )
{
  CAutoLock cObjectLock( m_pLock );
  LogDebug( "CDVBSub::Run" );
  m_startTimestamp = tStart;

  HRESULT hr = CBaseFilter::Run( tStart );

  if( hr != S_OK )
  {
    LogDebug( "CDVBSub::Run - BaseFilter returned %i", hr );
    return hr;
  }

  // Get media seeking interface if missing
  if( !m_pIMediaSeeking )
  {
    IFilterGraph *pGraph = GetFilterGraph();    
    if( pGraph )
    {
      pGraph->QueryInterface( &m_pIMediaSeeking );
      pGraph->Release();
    }
  }

  LogDebug( "CDVBSub::Run - done" );
  return hr; 
}

STDMETHODIMP CWavPackSplitterFilter::Pause(void)
{
	CAutoLock cObjectLock(m_pLock);

	// notify all pins of the change to active state
	if (m_State == State_Stopped) {
		// Order is important, the output pin allocator need to be commited
		// when we activate the input pin

		// First the output pin
		if (m_pOutputPin->IsConnected()) {
			HRESULT hr = m_pOutputPin->Active();
			if (FAILED(hr)) {
				return hr;
			}
		}
		// Then the input pin
		if (m_pInputPin->IsConnected()) {
			HRESULT hr = m_pInputPin->Active();
			if (FAILED(hr)) {
				return hr;
			}
		}
	}

	m_State = State_Paused;
	return S_OK;
}

STDMETHODIMP CBDReaderFilter::Stop()
{
  CAutoLock cObjectLock(m_pLock);
  m_bStopping = true;

  LogDebug("CBDReaderFilter::Stop()");

  lib.SetState(State_Stopped);

  if (!m_bRebuildOngoing)
  {
    if (m_pSubtitlePin)
      m_pSubtitlePin->SetRunningStatus(false);

    m_demultiplexer.m_bVideoRequiresRebuild = false;
    m_demultiplexer.m_bAudioRequiresRebuild = false;
    m_demultiplexer.m_bVideoClipSeen = false;

    if (m_pVideoPin)
      m_pVideoPin->StopWait();

    if (m_demultiplexer.m_eAudioClipSeen)
      m_demultiplexer.m_eAudioClipSeen->Set();
  }
  
  LogDebug("CBDReaderFilter::Stop()  -stop source");
  HRESULT hr = CSource::Stop();
  LogDebug("CBDReaderFilter::Stop()  -stop source done");

  m_bStopping = false;

  LogDebug("CBDReaderFilter::Stop() done");

  return hr;
}

//------------------------------------------------------------------------------
// GetFreeCount
//
STDMETHODIMP CCustomAllocator::GetFreeCount(LONG* plBuffersFree)
{
    ASSERT(m_fEnableReleaseCallback);
    CAutoLock cObjectLock(this);
    *plBuffersFree = m_lCount - m_lAllocated + m_lFree.GetCount();
    return NOERROR;
}

//
// Run
//
// Overriden to open the dump file
//
STDMETHODIMP CMpTsFilter::Run(REFERENCE_TIME tStart)
{
	LogDebug("CMpTsFilter::Run()");
  CAutoLock cObjectLock(m_pLock);

  return CBaseFilter::Run(tStart);
}

STDMETHODIMP CTransInPlaceInputPin::GetAllocator(IMemAllocator ** ppAllocator)
{
    CheckPointer(ppAllocator,E_POINTER);
    ValidateReadWritePtr(ppAllocator,sizeof(IMemAllocator *));
    CAutoLock cObjectLock(m_pLock);

    HRESULT hr;

    if ( m_pTIPFilter->m_pOutput->IsConnected() ) {
        //  Store the allocator we got
        hr = m_pTIPFilter->OutputPin()->ConnectedIMemInputPin()
                                        ->GetAllocator( ppAllocator );
        if (SUCCEEDED(hr)) {
            m_pTIPFilter->OutputPin()->SetAllocator( *ppAllocator );
        }
    }
    else {
        //  Help upstream filter (eg TIP filter which is having to do a copy)
        //  by providing a temp allocator here - we'll never use
        //  this allocator because when our output is connected we'll
        //  reconnect this pin
        hr = CTransformInputPin::GetAllocator( ppAllocator );
    }
    return hr;

} // GetAllocator

STDMETHODIMP CTTASplitter::Pause(void)
{
	CAutoLock cObjectLock(m_pLock); 

	if (m_State == State_Stopped) {

		if (m_pOutputPin->IsConnected()) {
			HRESULT hr = m_pOutputPin->Active();

			if (FAILED(hr)) {
				return hr;
			}
		}

		if (m_pInputPin->IsConnected()) {
			HRESULT hr = m_pInputPin->Active();

			if (FAILED(hr)) {
				return hr;
			}
		}
	}

	m_State = State_Paused;

	return S_OK;
}

int CDictionary::Load(LOADINFO* pInfo)
{
	CAutoLock cObjectLock(this);

	if (!pInfo) {
		return E_FAIL;
	}

	if (IsLoaded(pInfo->pDictionaryName)) {
		return S_OK;
	}

	CSubDictionary* pSD = new CSubDictionary(pInfo->pDictionaryName);
	AssertValid(pSD);
	if (pSD->Load(pInfo) != S_OK) {
		delete pSD;
		Log("Can't load %s\n", pInfo->pDictionaryName);
		return E_FAIL;
	}

	m_vecDicts.push_back(pSD);
	Log("Load %s successful!\n", pInfo->pDictionaryName);

	return S_OK;
}

//
// Stop
//
// Overriden to close the dump file
//
STDMETHODIMP CNetworkProviderFilter::Stop()
{
	CAutoLock cObjectLock(m_pLock);
	LOG4CPLUS_DEBUG(logger,"CNetworkProviderFilter::Stop()");
	HRESULT result =  CBaseFilter::Stop();
	LOG4CPLUS_DEBUG(logger,"CNetworkProviderFilter::Stop() completed");
	return result;
}

STDMETHODIMP
CBasePin::SetSink(IQualityControl * piqc)
{
	CComAutoLock cObjectLock(m_pLock);
	if (piqc) ValidateReadPtr(piqc,sizeof(IQualityControl));
	m_pQSink = piqc;
	return NOERROR;
} // SetSink

// Run
//
    // the start parameter is the difference to be added to the
    // sample's stream time to get the reference time for
    // its presentation
STDMETHODIMP CWasapiFilter::Run(REFERENCE_TIME tStart)
{
	bStarted=true;
 	DebugPrintf(L"CWasapiFilter::Run \n");
    CAutoLock cObjectLock(m_pLock);
	HRESULT hr=CBaseFilter::Run(tStart);
	m_pManager->StartRendering();
    return hr;
}

//
// Stop
//
// Overriden to close the dump file
//
STDMETHODIMP CDumpFilter::Stop()
{
    CAutoLock cObjectLock(m_pLock);

    if (m_pDump)
        m_pDump->CloseFile();

    return CBaseFilter::Stop();
}

//
// Run
//
// Overriden to open the dump file
//
STDMETHODIMP EMReadFrameFilter::Run(REFERENCE_TIME tStart)
{
	IReferenceClock *pClock = m_pClock;
    CAutoLock cObjectLock(m_pLock);
	CRefTime agnusStreamTimeObject;
	StreamTime(agnusStreamTimeObject);
	long millisekunder = agnusStreamTimeObject.Millisecs();
    return CBaseFilter::Run(tStart);
}

//
// Run
//
// Overriden to open the dump file
//
STDMETHODIMP CNetworkProviderFilter::Run(REFERENCE_TIME tStart)
{
	LOG4CPLUS_DEBUG(logger,"CNetworkProviderFilter::Run()");
	CAutoLock cObjectLock(m_pLock);
	if(m_pNetworkProvider!=NULL){
		m_pNetworkProvider->Retune();
	}
	return CBaseFilter::Run(tStart);
}

STDMETHODIMP CMPEGFilter::Stop()
{
	TraceVerbose("Entered CMPEGFilter::Stop\n");
    CAutoLock cObjectLock(m_pLock);
	HRESULT hr = m_pMPEGObj->Stop();
    hr = CBaseFilter::Stop();
	TraceVerbose("Exited CMPEGFilter::Stop\n");
	return hr;
}

HRESULT CSyncClock::Reset(REFERENCE_TIME tStart)
{
  CAutoLock cObjectLock(this);
  m_SynchCorrection.Reset(m_dBias, tStart);
  m_SynchCorrection.SetPresenterInducedAudioDelay(m_dEVRDelay);
  m_bDiscontinuity = true;

  return S_OK;
}

//------------------------------------------------------------------------------
// IDecklinkPushSource2 interface
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
// GetFrameBuffer
// Provide the caller with a free media sample.  If there are no free samples,
// all have been delivered downstream, block until one is returned to the free list.  
STDMETHODIMP CCustomAllocator::GetFrameBuffer(IMediaSample** ppSample)
{
	HRESULT hr = S_OK;

	if (ppSample)
	{
		CAutoLock lck(this);
		unsigned char* pBuffer = m_lBuffers.RemoveHead();	// retrieve a frame buffer
		if (pBuffer)
		{
			// attempt to retrieve a free media sample
			CMediaSample* pSample = NULL;
			for (;;)
			{
				{  // scope for lock
					CAutoLock cObjectLock(this);

					/* Check we are committed */
					if (!m_bCommitted)
					{
						return VFW_E_NOT_COMMITTED;
					}
					pSample = (CMediaSample*)m_lFree.RemoveHead();
					if (pSample == NULL)
					{
						SetWaitingFree();
					}
				}

				if (pSample)
				{
					// return the sample to the caller
					hr = pSample->SetPointer(pBuffer, m_lSize);
					*ppSample = pSample;
					break;
				}

				/* If we didn't get a sample then wait for the list to signal */
				ASSERT(m_hSemFree);
				WaitForSingleObject(m_hSemFree, INFINITE);
			}
		}
		else
		{
			hr = E_FAIL;
		}
	}
	else
	{
		hr = E_POINTER;
	}

	return hr;
}

HRESULT CBaseReferenceClock::GetDefaultTimerResolution(
        __out REFERENCE_TIME* pTimerResolution // in 100ns
    )
{
    if( !pTimerResolution ) {
        return E_POINTER;
    }
    CAutoLock cObjectLock(this);
    *pTimerResolution = m_TimerResolution * 10000;
    return S_OK;
}