| /* This file is part of the KDE project. |
| |
| Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). |
| |
| This library is free software: you can redistribute it and/or modify |
| it under the terms of the GNU Lesser General Public License as published by |
| the Free Software Foundation, either version 2.1 or 3 of the License. |
| |
| This library is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| GNU Lesser General Public License for more details. |
| |
| You should have received a copy of the GNU Lesser General Public License |
| along with this library. If not, see <http://www.gnu.org/licenses/>. |
| */ |
| |
| #include "qmeminputpin.h" |
| #include "qbasefilter.h" |
| #include "compointer.h" |
| |
| #include <QtCore/QDebug> |
| |
| QT_BEGIN_NAMESPACE |
| |
| namespace Phonon |
| { |
| namespace DS9 |
| { |
| |
| QMemInputPin::QMemInputPin(QBaseFilter *parent, const QVector<AM_MEDIA_TYPE> &mt, bool transform, QPin *output) : |
| QPin(parent, PINDIR_INPUT, mt), m_shouldDuplicateSamples(true), m_transform(transform), m_output(output) |
| { |
| } |
| |
| QMemInputPin::~QMemInputPin() |
| { |
| } |
| |
| STDMETHODIMP QMemInputPin::QueryInterface(REFIID iid, void **out) |
| { |
| if (!out) { |
| return E_POINTER; |
| } |
| |
| if (iid == IID_IMemInputPin) { |
| *out = static_cast<IMemInputPin*>(this); |
| AddRef(); |
| return S_OK; |
| } else { |
| return QPin::QueryInterface(iid, out); |
| } |
| } |
| |
| STDMETHODIMP_(ULONG) QMemInputPin::AddRef() |
| { |
| return QPin::AddRef(); |
| } |
| |
| STDMETHODIMP_(ULONG) QMemInputPin::Release() |
| { |
| return QPin::Release(); |
| } |
| |
| STDMETHODIMP QMemInputPin::EndOfStream() |
| { |
| //this allows to serialize with Receive calls |
| QMutexLocker locker(&m_mutexReceive); |
| IPin *conn = m_output ? m_output->connected() : 0; |
| if (conn) { |
| conn->EndOfStream(); |
| } |
| return S_OK; |
| } |
| |
| STDMETHODIMP QMemInputPin::BeginFlush() |
| { |
| //pass downstream |
| IPin *conn = m_output ? m_output->connected() : 0; |
| if (conn) { |
| conn->BeginFlush(); |
| } |
| QMutexLocker locker(&m_mutex); |
| m_flushing = true; |
| return S_OK; |
| } |
| |
| STDMETHODIMP QMemInputPin::EndFlush() |
| { |
| //pass downstream |
| IPin *conn = m_output ? m_output->connected() : 0; |
| if (conn) { |
| conn->EndFlush(); |
| } |
| QMutexLocker locker(&m_mutex); |
| m_flushing = false; |
| return S_OK; |
| } |
| |
| STDMETHODIMP QMemInputPin::NewSegment(REFERENCE_TIME start, REFERENCE_TIME stop, double rate) |
| { |
| if (m_output) |
| m_output->NewSegment(start, stop, rate); |
| return S_OK; |
| } |
| |
| //reimplementation to set the type for the output pin |
| //no need to make a deep copy here |
| STDMETHODIMP QMemInputPin::ReceiveConnection(IPin *pin ,const AM_MEDIA_TYPE *mt) |
| { |
| HRESULT hr = QPin::ReceiveConnection(pin, mt); |
| if (hr == S_OK && |
| mt->majortype != MEDIATYPE_NULL && |
| mt->subtype != MEDIASUBTYPE_NULL && |
| mt->formattype != GUID_NULL && m_output) { |
| //we tell the output pin that it should connect with this type |
| hr = m_output->setAcceptedMediaType(connectedType()); |
| } |
| return hr; |
| } |
| |
| STDMETHODIMP QMemInputPin::GetAllocator(IMemAllocator **alloc) |
| { |
| if (!alloc) { |
| return E_POINTER; |
| } |
| |
| *alloc = memoryAllocator(true); |
| if (*alloc) { |
| return S_OK; |
| } |
| |
| return VFW_E_NO_ALLOCATOR; |
| } |
| |
| STDMETHODIMP QMemInputPin::NotifyAllocator(IMemAllocator *alloc, BOOL readonly) |
| { |
| if (!alloc) { |
| return E_POINTER; |
| } |
| |
| { |
| QMutexLocker locker(&m_mutex); |
| m_shouldDuplicateSamples = m_transform && readonly; |
| } |
| |
| setMemoryAllocator(alloc); |
| |
| if (m_output) { |
| ComPointer<IMemInputPin> input(m_output, IID_IMemInputPin); |
| input->NotifyAllocator(alloc, m_shouldDuplicateSamples); |
| } |
| |
| return S_OK; |
| } |
| |
| STDMETHODIMP QMemInputPin::GetAllocatorRequirements(ALLOCATOR_PROPERTIES *prop) |
| { |
| if (!prop) { |
| return E_POINTER; |
| } |
| |
| //we have no particular requirements |
| return E_NOTIMPL; |
| } |
| |
| STDMETHODIMP QMemInputPin::Receive(IMediaSample *sample) |
| { |
| QMutexLocker locker(&m_mutexReceive); |
| if (!sample) { |
| return E_POINTER; |
| } |
| |
| if (filterState() == State_Stopped) { |
| return VFW_E_WRONG_STATE; |
| } |
| |
| if (isFlushing()) { |
| return S_FALSE; //we are still flushing |
| } |
| |
| if (!m_shouldDuplicateSamples) { |
| //we do it just once |
| HRESULT hr = m_parent->processSample(sample); |
| if (!SUCCEEDED(hr)) { |
| return hr; |
| } |
| } |
| |
| if (m_output) { |
| IMediaSample *outSample = m_shouldDuplicateSamples ? |
| duplicateSampleForOutput(sample, m_output->memoryAllocator()) |
| : sample; |
| |
| if (m_shouldDuplicateSamples) { |
| m_parent->processSample(outSample); |
| } |
| |
| ComPointer<IMemInputPin> input(m_output->connected(), IID_IMemInputPin); |
| if (input) { |
| input->Receive(outSample); |
| } |
| |
| if (m_shouldDuplicateSamples) { |
| outSample->Release(); |
| } |
| } |
| return S_OK; |
| } |
| |
| STDMETHODIMP QMemInputPin::ReceiveMultiple(IMediaSample **samples,long count,long *nbDone) |
| { |
| //no need to lock here: there is no access to member data |
| if (!samples || !nbDone) { |
| return E_POINTER; |
| } |
| |
| *nbDone = 0; //initialization |
| while( *nbDone != count) { |
| HRESULT hr = Receive(samples[*nbDone]); |
| if (FAILED(hr)) { |
| return hr; |
| } |
| (*nbDone)++; |
| } |
| |
| return S_OK; |
| } |
| |
| STDMETHODIMP QMemInputPin::ReceiveCanBlock() |
| { |
| //we test the output to see if it can block |
| if (m_output) { |
| ComPointer<IMemInputPin> meminput(m_output->connected(), IID_IMemInputPin); |
| if (meminput && meminput->ReceiveCanBlock() != S_FALSE) { |
| return S_OK; |
| } |
| } |
| return S_FALSE; |
| } |
| |
| |
| ALLOCATOR_PROPERTIES QMemInputPin::getDefaultAllocatorProperties() const |
| { |
| //those values reduce buffering a lot (good for the volume effect) |
| ALLOCATOR_PROPERTIES prop = {4096, 1, 1, 0}; |
| return prop; |
| } |
| |
| |
| IMediaSample *QMemInputPin::duplicateSampleForOutput(IMediaSample *sample, IMemAllocator *alloc) |
| { |
| LONG length = sample->GetActualDataLength(); |
| |
| HRESULT hr = alloc->Commit(); |
| if (hr == HRESULT(VFW_E_SIZENOTSET)) { |
| ALLOCATOR_PROPERTIES prop = getDefaultAllocatorProperties(); |
| prop.cbBuffer = qMax(prop.cbBuffer, length); |
| ALLOCATOR_PROPERTIES actual; |
| //we just try to set the properties... |
| alloc->SetProperties(&prop, &actual); |
| hr = alloc->Commit(); |
| } |
| |
| Q_ASSERT(SUCCEEDED(hr)); |
| |
| IMediaSample *out; |
| hr = alloc->GetBuffer(&out, 0, 0, AM_GBF_NOTASYNCPOINT); |
| Q_ASSERT(SUCCEEDED(hr)); |
| |
| //let's copy the sample |
| { |
| REFERENCE_TIME start, end; |
| sample->GetTime(&start, &end); |
| out->SetTime(&start, &end); |
| } |
| |
| hr = out->SetActualDataLength(length); |
| Q_ASSERT(SUCCEEDED(hr)); |
| hr = out->SetDiscontinuity(sample->IsDiscontinuity()); |
| Q_ASSERT(SUCCEEDED(hr)); |
| |
| { |
| LONGLONG start, end; |
| hr = sample->GetMediaTime(&start, &end); |
| if (hr != HRESULT(VFW_E_MEDIA_TIME_NOT_SET)) { |
| hr = out->SetMediaTime(&start, &end); |
| Q_ASSERT(SUCCEEDED(hr)); |
| } |
| } |
| |
| AM_MEDIA_TYPE *type = 0; |
| hr = sample->GetMediaType(&type); |
| Q_ASSERT(SUCCEEDED(hr)); |
| hr = out->SetMediaType(type); |
| Q_ASSERT(SUCCEEDED(hr)); |
| |
| hr = out->SetPreroll(sample->IsPreroll()); |
| Q_ASSERT(SUCCEEDED(hr)); |
| hr = out->SetSyncPoint(sample->IsSyncPoint()); |
| Q_ASSERT(SUCCEEDED(hr)); |
| |
| BYTE *dest = 0, *src = 0; |
| hr = out->GetPointer(&dest); |
| Q_ASSERT(SUCCEEDED(hr)); |
| hr = sample->GetPointer(&src); |
| Q_ASSERT(SUCCEEDED(hr)); |
| |
| qMemCopy(dest, src, sample->GetActualDataLength()); |
| |
| return out; |
| } |
| } |
| } |
| |
| QT_END_NAMESPACE |
