HRESULT
CPullPin::StopThread()
{
    CAutoLock lock(&m_AccessLock);

    if (!ThreadExists()) {
	return S_FALSE;
    }

    // need to flush to ensure the thread is not blocked
    // in WaitForNext
    HRESULT hr = m_pReader->BeginFlush();
    if (FAILED(hr)) {
	return hr;
    }

    m_State = TM_Exit;
    hr = CallWorker(TM_Exit);

    m_pReader->EndFlush();

    // wait for thread to completely exit
    Close();

    // decommit allocator
    if (m_pAlloc) {
	m_pAlloc->Decommit();
    }

    return S_OK;
}

HRESULT CAMROutputPin::Active()
{
	if (active) {
		return NOERROR;
	}
	
	FlushQueue();
	if (!IsConnected()) {
		return VFW_E_NOT_CONNECTED;
	}

	ev_abort.Reset();

	HRESULT hr = CBaseOutputPin::Active();
	if (FAILED(hr)) {
		active = FALSE;
		return hr;
	}

	// new segment
	DoNewSegment(rtStart, rtStop, rate);

	// vytvorime novu queue
	if (!ThreadExists()) {
		Create();
		CallWorker(CMD_RUN);
	}

	active = TRUE;
	return hr;
}

STDMETHODIMP CAMRSplitter::Pause()
{
	CAutoLock lck(&lock_filter);

	if (m_State == State_Stopped) {

		ev_abort.Reset();

		// activate pins
		for (int i=0; i<output.GetCount(); i++) {
			output[i]->Active();
		}

		if (input) {
			input->Active();
		}

		// seekneme na danu poziciu
		DoNewSeek();

		// pustime parser thread
		if (!ThreadExists()) {
			Create();
			CallWorker(CMD_RUN);
		}
	}

	m_State = State_Paused;
	return NOERROR;
}

STDMETHODIMP OggDemuxFilter::Pause() 
{
	CAutoLock locLock(m_pLock);
    LOG(logDEBUG) << __FUNCTIONW__;

	if (m_State == State_Stopped) 
    {
        LOG(logDEBUG) <<L"Pause -- was stopped";

		if (ThreadExists() == FALSE) 
        {
            LOG(logDEBUG) << L"Pause -- CREATING THREAD";
			Create();
		}

        LOG(logDEBUG) << L"Pause -- RUNNING THREAD";
		CallWorker(THREAD_RUN);
	}

	HRESULT hr = CBaseFilter::Pause();

    LOG(logDEBUG) << __FUNCTIONW__ << L"Base class returned: 0x" << std::hex << hr;
	
	return hr;	
}

HRESULT CTTASplitterInputPin::Active()
{
	HRESULT hr;

	if (m_pParentFilter->IsActive()) {
		return S_FALSE;
	}

	if (!IsConnected()) {
		return NOERROR;
	}

	hr = CBaseInputPin::Active();
	if (FAILED(hr)) {
		return hr;
	}

	if (!Create()) {
		return E_FAIL;
	}

	CallWorker(CMD_RUN);

	return NOERROR;
}

HRESULT CBaseSplitterOutputPin::Inactive()
{
    CAutoLock cAutoLock(m_pLock);

	if(ThreadExists())
		CallWorker(CMD_EXIT);

	return __super::Inactive();
}

HRESULT CWavPackSplitterFilterInputPin::Inactive()
{
	// Stop the thread
	if (ThreadExists()) {
		m_bAbort = TRUE;
		CallWorker(CMD_EXIT);
		Close();
	}

	return CBasePin::Inactive();
}

STDMETHODIMP CBaseMuxerFilter::Stop()
{
	CAutoLock cAutoLock(this);

	HRESULT hr = __super::Stop();
	if(FAILED(hr)) return hr;

	CallWorker(CMD_EXIT);

	return hr;
}

CAsyncUrlReader::~CAsyncUrlReader()
{
    if (ThreadExists()) {
        CallWorker(CMD_EXIT);
    }

    if (!m_fn.IsEmpty()) {
        CMultiFiles::Close();
        DeleteFile(m_fn);
    }
}

STDMETHODIMP CStreamDriveThruFilter::Pause()
{
	HRESULT hr;
	
	if(FAILED(hr = __super::Pause()))
		return hr;

	CallWorker(CMD_PAUSE);

	return S_OK;
}

CAsyncUrlReader::CAsyncUrlReader(CString url, HRESULT& hr) 
	: CAsyncFileReader(url, hr)
{
	if(SUCCEEDED(hr)) return;

	m_url = url;

	if(CAMThread::Create())
		CallWorker(CMD_INIT);

	hr = Open(m_fn, modeRead|shareDenyRead|typeBinary|osSequentialScan) ? S_OK : E_FAIL;
	m_len = (ULONGLONG)-1; // force GetLength() return actual length always
}

STDMETHODIMP CWavPackDSSplitterInputPin::EndFlush()
{
    HRESULT hr = CBaseInputPin::EndFlush();
    if (FAILED(hr))
        return hr;

    DebugLog("CWavPackDSSplitterInputPin::EndFlush 0x%08X", GetCurrentThreadId());

    if (ThreadExists())
        CallWorker(CMD_RUN);

    return NOERROR; 
}

HRESULT CAVISplitter::PauseThread()
{
	CAutoLock lock(&m_AccessLock);

	if (!ThreadExists()) {
		return E_UNEXPECTED;
	}

	HRESULT hr = S_OK;

	// Need to flush to ensure the thread is not blocked
	// in WaitForNext
	m_scanner.BeginFlush();
	m_thread_state = tm_pause;
	hr = CallWorker(tm_pause);
	//WriteToLog("<CAVISplitter::PauseThread> CallWorker(tm_pause)");
	m_scanner.EndFlush();
	return hr;
}

HRESULT
CPullPin::PauseThread() {
    CAutoLock lock(&m_AccessLock);

    if(!ThreadExists()) {
        return E_UNEXPECTED;
    }

    // need to flush to ensure the thread is not blocked
    // in WaitForNext
    HRESULT hr = m_pReader->BeginFlush();
    if(FAILED(hr)) {
        return hr;
    }

    m_State = TM_Pause;
    hr = CallWorker(TM_Pause);

    m_pReader->EndFlush();
    return hr;
}

HRESULT CAMROutputPin::Inactive()
{
	if (!active) {
		return NOERROR;
	}
	active = FALSE;

	// destroy everything
	ev_abort.Set();
	HRESULT hr = CBaseOutputPin::Inactive();
	ASSERT(SUCCEEDED(hr));

	if (ThreadExists()) {
		CallWorker(CMD_EXIT);
		Close();
	}
	FlushQueue();
	ev_abort.Reset();

	return NOERROR;
}