/* 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