| /**************************************************************************** |
| ** |
| ** Copyright (C) 2016 The Qt Company Ltd. |
| ** Contact: https://www.qt.io/licensing/ |
| ** |
| ** This file is part of the Qt Toolkit. |
| ** |
| ** $QT_BEGIN_LICENSE:LGPL$ |
| ** Commercial License Usage |
| ** Licensees holding valid commercial Qt licenses may use this file in |
| ** accordance with the commercial license agreement provided with the |
| ** Software or, alternatively, in accordance with the terms contained in |
| ** a written agreement between you and The Qt Company. For licensing terms |
| ** and conditions see https://www.qt.io/terms-conditions. For further |
| ** information use the contact form at https://www.qt.io/contact-us. |
| ** |
| ** GNU Lesser General Public License Usage |
| ** Alternatively, this file may be used under the terms of the GNU Lesser |
| ** General Public License version 3 as published by the Free Software |
| ** Foundation and appearing in the file LICENSE.LGPL3 included in the |
| ** packaging of this file. Please review the following information to |
| ** ensure the GNU Lesser General Public License version 3 requirements |
| ** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. |
| ** |
| ** GNU General Public License Usage |
| ** Alternatively, this file may be used under the terms of the GNU |
| ** General Public License version 2.0 or (at your option) the GNU General |
| ** Public license version 3 or any later version approved by the KDE Free |
| ** Qt Foundation. The licenses are as published by the Free Software |
| ** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 |
| ** included in the packaging of this file. Please review the following |
| ** information to ensure the GNU General Public License requirements will |
| ** be met: https://www.gnu.org/licenses/gpl-2.0.html and |
| ** https://www.gnu.org/licenses/gpl-3.0.html. |
| ** |
| ** $QT_END_LICENSE$ |
| ** |
| ****************************************************************************/ |
| |
| #include "directshowioreader.h" |
| |
| #include "directshoweventloop.h" |
| #include "directshowglobal.h" |
| #include "directshowiosource.h" |
| |
| #include <QtCore/qcoreapplication.h> |
| #include <QtCore/qcoreevent.h> |
| #include <QtCore/qiodevice.h> |
| #include <QtCore/qthread.h> |
| |
| QT_BEGIN_NAMESPACE |
| |
| class DirectShowSampleRequest |
| { |
| public: |
| DirectShowSampleRequest( |
| IMediaSample *sample, DWORD_PTR userData, LONGLONG position, LONG length, BYTE *buffer) |
| : sample(sample) |
| , userData(userData) |
| , position(position) |
| , length(length) |
| , buffer(buffer) |
| { |
| } |
| |
| DirectShowSampleRequest *remove() { DirectShowSampleRequest *n = next; delete this; return n; } |
| |
| DirectShowSampleRequest *next = nullptr; |
| IMediaSample *sample; |
| DWORD_PTR userData; |
| LONGLONG position; |
| LONG length; |
| BYTE *buffer; |
| HRESULT result = S_FALSE; |
| }; |
| |
| DirectShowIOReader::DirectShowIOReader( |
| QIODevice *device, DirectShowIOSource *source, DirectShowEventLoop *loop) |
| : m_source(source) |
| , m_device(device) |
| , m_loop(loop) |
| { |
| moveToThread(device->thread()); |
| |
| connect(device, &QIODevice::readyRead, this, &DirectShowIOReader::readyRead); |
| } |
| |
| DirectShowIOReader::~DirectShowIOReader() |
| { |
| flushRequests(); |
| } |
| |
| HRESULT DirectShowIOReader::QueryInterface(REFIID riid, void **ppvObject) |
| { |
| return m_source->QueryInterface(riid, ppvObject); |
| } |
| |
| ULONG DirectShowIOReader::AddRef() |
| { |
| return m_source->AddRef(); |
| } |
| |
| ULONG DirectShowIOReader::Release() |
| { |
| return m_source->Release(); |
| } |
| |
| // IAsyncReader |
| HRESULT DirectShowIOReader::RequestAllocator( |
| IMemAllocator *pPreferred, ALLOCATOR_PROPERTIES *pProps, IMemAllocator **ppActual) |
| { |
| if (!ppActual || !pProps) |
| return E_POINTER; |
| |
| ALLOCATOR_PROPERTIES actualProperties; |
| |
| if (pProps->cbAlign == 0) |
| pProps->cbAlign = 1; |
| |
| if (pPreferred && pPreferred->SetProperties(pProps, &actualProperties) == S_OK) { |
| pPreferred->AddRef(); |
| |
| *ppActual = pPreferred; |
| m_source->setAllocator(*ppActual); |
| return S_OK; |
| } |
| |
| *ppActual = com_new<IMemAllocator>(CLSID_MemoryAllocator); |
| if (*ppActual) { |
| if ((*ppActual)->SetProperties(pProps, &actualProperties) == S_OK) { |
| m_source->setAllocator(*ppActual); |
| return S_OK; |
| } |
| (*ppActual)->Release(); |
| } |
| ppActual = nullptr; |
| return E_FAIL; |
| } |
| |
| HRESULT DirectShowIOReader::Request(IMediaSample *pSample, DWORD_PTR dwUser) |
| { |
| QMutexLocker locker(&m_mutex); |
| |
| if (!pSample) |
| return E_POINTER; |
| if (m_flushing) |
| return VFW_E_WRONG_STATE; |
| |
| REFERENCE_TIME startTime = 0; |
| REFERENCE_TIME endTime = 0; |
| BYTE *buffer; |
| |
| if (pSample->GetTime(&startTime, &endTime) != S_OK |
| || pSample->GetPointer(&buffer) != S_OK) { |
| return VFW_E_SAMPLE_TIME_NOT_SET; |
| } |
| LONGLONG position = startTime / 10000000; |
| LONG length = qMin<qint64>((endTime - startTime) / 10000000, m_availableLength); |
| |
| auto request = new DirectShowSampleRequest(pSample, dwUser, position, length, buffer); |
| |
| if (m_pendingTail) { |
| m_pendingTail->next = request; |
| } else { |
| m_pendingHead = request; |
| m_loop->postEvent(this, new QEvent(QEvent::User)); |
| } |
| m_pendingTail = request; |
| |
| return S_OK; |
| } |
| |
| HRESULT DirectShowIOReader::WaitForNext( |
| DWORD dwTimeout, IMediaSample **ppSample, DWORD_PTR *pdwUser) |
| { |
| if (!ppSample || !pdwUser) |
| return E_POINTER; |
| |
| QMutexLocker locker(&m_mutex); |
| |
| do { |
| if (m_readyHead) { |
| DirectShowSampleRequest *request = m_readyHead; |
| |
| *ppSample = request->sample; |
| *pdwUser = request->userData; |
| |
| HRESULT hr = request->result; |
| |
| m_readyHead = request->next; |
| |
| if (!m_readyHead) |
| m_readyTail = nullptr; |
| |
| delete request; |
| |
| return hr; |
| } |
| if (m_flushing) { |
| *ppSample = nullptr; |
| *pdwUser = 0; |
| |
| return VFW_E_WRONG_STATE; |
| } |
| } while (m_wait.wait(&m_mutex, dwTimeout)); |
| |
| *ppSample = nullptr; |
| *pdwUser = 0; |
| |
| return VFW_E_TIMEOUT; |
| } |
| |
| HRESULT DirectShowIOReader::SyncReadAligned(IMediaSample *pSample) |
| { |
| if (!pSample) |
| return E_POINTER; |
| |
| REFERENCE_TIME startTime = 0; |
| REFERENCE_TIME endTime = 0; |
| BYTE *buffer; |
| |
| if (pSample->GetTime(&startTime, &endTime) != S_OK |
| || pSample->GetPointer(&buffer) != S_OK) { |
| return VFW_E_SAMPLE_TIME_NOT_SET; |
| } |
| LONGLONG position = startTime / 10000000; |
| LONG length = (endTime - startTime) / 10000000; |
| |
| QMutexLocker locker(&m_mutex); |
| |
| if (thread() == QThread::currentThread()) { |
| qint64 bytesRead = 0; |
| |
| HRESULT hr = blockingRead(position, length, buffer, &bytesRead); |
| if (SUCCEEDED(hr)) |
| pSample->SetActualDataLength(bytesRead); |
| |
| return hr; |
| } |
| m_synchronousPosition = position; |
| m_synchronousLength = length; |
| m_synchronousBuffer = buffer; |
| |
| m_loop->postEvent(this, new QEvent(QEvent::User)); |
| |
| m_wait.wait(&m_mutex); |
| |
| m_synchronousBuffer = nullptr; |
| |
| if (SUCCEEDED(m_synchronousResult)) |
| pSample->SetActualDataLength(m_synchronousBytesRead); |
| |
| return m_synchronousResult; |
| } |
| |
| HRESULT DirectShowIOReader::SyncRead(LONGLONG llPosition, LONG lLength, BYTE *pBuffer) |
| { |
| if (!pBuffer) |
| return E_POINTER; |
| |
| if (thread() == QThread::currentThread()) { |
| qint64 bytesRead; |
| return blockingRead(llPosition, lLength, pBuffer, &bytesRead); |
| } |
| QMutexLocker locker(&m_mutex); |
| |
| m_synchronousPosition = llPosition; |
| m_synchronousLength = lLength; |
| m_synchronousBuffer = pBuffer; |
| |
| m_loop->postEvent(this, new QEvent(QEvent::User)); |
| |
| m_wait.wait(&m_mutex); |
| |
| m_synchronousBuffer = nullptr; |
| |
| return m_synchronousResult; |
| } |
| |
| HRESULT DirectShowIOReader::Length(LONGLONG *pTotal, LONGLONG *pAvailable) |
| { |
| if (!pTotal || !pAvailable) |
| return E_POINTER; |
| |
| QMutexLocker locker(&m_mutex); |
| *pTotal = m_totalLength; |
| *pAvailable = m_availableLength; |
| return S_OK; |
| } |
| |
| |
| HRESULT DirectShowIOReader::BeginFlush() |
| { |
| QMutexLocker locker(&m_mutex); |
| |
| if (m_flushing) |
| return S_FALSE; |
| |
| m_flushing = true; |
| |
| flushRequests(); |
| |
| m_wait.wakeAll(); |
| |
| return S_OK; |
| } |
| |
| HRESULT DirectShowIOReader::EndFlush() |
| { |
| QMutexLocker locker(&m_mutex); |
| |
| if (!m_flushing) |
| return S_FALSE; |
| |
| m_flushing = false; |
| |
| return S_OK; |
| } |
| |
| void DirectShowIOReader::customEvent(QEvent *event) |
| { |
| if (event->type() == QEvent::User) { |
| readyRead(); |
| } else { |
| QObject::customEvent(event); |
| } |
| } |
| |
| void DirectShowIOReader::readyRead() |
| { |
| QMutexLocker locker(&m_mutex); |
| |
| m_availableLength = m_device->bytesAvailable() + m_device->pos(); |
| m_totalLength = m_device->size(); |
| |
| if (m_synchronousBuffer) { |
| if (nonBlockingRead( |
| m_synchronousPosition, |
| m_synchronousLength, |
| m_synchronousBuffer, |
| &m_synchronousBytesRead, |
| &m_synchronousResult)) { |
| m_wait.wakeAll(); |
| } |
| } else { |
| qint64 bytesRead = 0; |
| |
| while (m_pendingHead && nonBlockingRead( |
| m_pendingHead->position, |
| m_pendingHead->length, |
| m_pendingHead->buffer, |
| &bytesRead, |
| &m_pendingHead->result)) { |
| m_pendingHead->sample->SetActualDataLength(bytesRead); |
| |
| if (m_readyTail) |
| m_readyTail->next = m_pendingHead; |
| m_readyTail = m_pendingHead; |
| |
| m_pendingHead = m_pendingHead->next; |
| |
| m_readyTail->next = nullptr; |
| |
| if (!m_pendingHead) |
| m_pendingTail = nullptr; |
| |
| if (!m_readyHead) |
| m_readyHead = m_readyTail; |
| |
| m_wait.wakeAll(); |
| } |
| } |
| } |
| |
| HRESULT DirectShowIOReader::blockingRead( |
| LONGLONG position, LONG length, BYTE *buffer, qint64 *bytesRead) |
| { |
| *bytesRead = 0; |
| |
| if (qint64(position) > m_device->size()) |
| return S_FALSE; |
| |
| const qint64 maxSize = qMin<qint64>(m_device->size(), position + length); |
| |
| while (m_device->bytesAvailable() + m_device->pos() < maxSize) { |
| if (!m_device->waitForReadyRead(-1)) |
| return S_FALSE; |
| } |
| |
| if (m_device->pos() != position && !m_device->seek(position)) |
| return S_FALSE; |
| |
| const qint64 maxBytes = qMin<qint64>(length, m_device->bytesAvailable()); |
| |
| *bytesRead = m_device->read(reinterpret_cast<char *>(buffer), maxBytes); |
| |
| if (*bytesRead != length) { |
| ::memset(buffer + *bytesRead, 0, length - *bytesRead); |
| |
| return S_FALSE; |
| } |
| return S_OK; |
| } |
| |
| bool DirectShowIOReader::nonBlockingRead( |
| LONGLONG position, LONG length, BYTE *buffer, qint64 *bytesRead, HRESULT *result) |
| { |
| const qint64 maxSize = qMin<qint64>(m_device->size(), position + length); |
| |
| if (position > m_device->size()) { |
| *bytesRead = 0; |
| *result = S_FALSE; |
| |
| return true; |
| } |
| if (m_device->bytesAvailable() + m_device->pos() >= maxSize) { |
| if (m_device->pos() != position && !m_device->seek(position)) { |
| *bytesRead = 0; |
| *result = S_FALSE; |
| |
| return true; |
| } |
| const qint64 maxBytes = qMin<qint64>(length, m_device->bytesAvailable()); |
| |
| *bytesRead = m_device->read(reinterpret_cast<char *>(buffer), maxBytes); |
| |
| if (*bytesRead != length) { |
| ::memset(buffer + *bytesRead, 0, length - *bytesRead); |
| |
| *result = S_FALSE; |
| } else { |
| *result = S_OK; |
| } |
| |
| return true; |
| } |
| return false; |
| } |
| |
| void DirectShowIOReader::flushRequests() |
| { |
| while (m_pendingHead) { |
| m_pendingHead->result = VFW_E_WRONG_STATE; |
| |
| if (m_readyTail) |
| m_readyTail->next = m_pendingHead; |
| |
| m_readyTail = m_pendingHead; |
| |
| m_pendingHead = m_pendingHead->next; |
| |
| m_readyTail->next = nullptr; |
| |
| if (!m_pendingHead) |
| m_pendingTail = nullptr; |
| |
| if (!m_readyHead) |
| m_readyHead = m_readyTail; |
| } |
| } |
| |
| QT_END_NAMESPACE |
