Revision control
Copy as Markdown
// Copyright (C) 2021 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
#include "qwindowsmediadevicereader_p.h"
#include <QtMultimedia/qaudiodevice.h>
#include <QtMultimedia/qmediadevices.h>
#include <QtMultimedia/qvideosink.h>
#include <QtMultimedia/private/qmemoryvideobuffer_p.h>
#include <QtMultimedia/private/qvideoframe_p.h>
#include <QtMultimedia/private/qwindowsmultimediautils_p.h>
#include <QtCore/qdebug.h>
#include <QtCore/private/qcomptr_p.h>
#include <cguid.h>
#include <mfidl.h>
#include <mmdeviceapi.h>
QT_BEGIN_NAMESPACE
enum { MEDIA_TYPE_INDEX_DEFAULT = 0xffffffff };
QWindowsMediaDeviceReader::QWindowsMediaDeviceReader(QObject *parent)
: QObject(parent)
{
m_durationTimer.setInterval(100);
connect(&m_durationTimer, &QTimer::timeout, this, &QWindowsMediaDeviceReader::updateDuration);
}
QWindowsMediaDeviceReader::~QWindowsMediaDeviceReader()
{
stopRecording();
deactivate();
}
// Creates a video or audio media source specified by deviceId (symbolic link)
HRESULT QWindowsMediaDeviceReader::createSource(const QString &deviceId, bool video, ComPtr<IMFMediaSource> &source)
{
source = nullptr;
ComPtr<IMFAttributes> sourceAttributes;
HRESULT hr = MFCreateAttributes(sourceAttributes.GetAddressOf(), 2);
if (SUCCEEDED(hr)) {
hr = sourceAttributes->SetGUID(MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE,
video ? MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_GUID
: MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_AUDCAP_GUID);
if (SUCCEEDED(hr)) {
hr = sourceAttributes->SetString(video ? MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_SYMBOLIC_LINK
: MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_AUDCAP_ENDPOINT_ID,
reinterpret_cast<LPCWSTR>(deviceId.utf16()));
if (SUCCEEDED(hr)) {
hr = MFCreateDeviceSource(sourceAttributes.Get(), &source);
}
}
}
return hr;
}
// Creates a source/reader aggregating two other sources (video/audio).
// If one of the sources is null the result will be video-only or audio-only.
HRESULT QWindowsMediaDeviceReader::createAggregateReader(const ComPtr<IMFMediaSource> &firstSource,
const ComPtr<IMFMediaSource> &secondSource,
ComPtr<IMFMediaSource> &aggregateSource,
ComPtr<IMFSourceReader> &sourceReader)
{
if (!firstSource && !secondSource)
return E_INVALIDARG;
aggregateSource = nullptr;
sourceReader = nullptr;
ComPtr<IMFCollection> sourceCollection;
HRESULT hr = MFCreateCollection(sourceCollection.GetAddressOf());
if (SUCCEEDED(hr)) {
if (firstSource)
sourceCollection->AddElement(firstSource.Get());
if (secondSource)
sourceCollection->AddElement(secondSource.Get());
hr = MFCreateAggregateSource(sourceCollection.Get(), &aggregateSource);
if (SUCCEEDED(hr)) {
ComPtr<IMFAttributes> readerAttributes;
hr = MFCreateAttributes(readerAttributes.GetAddressOf(), 1);
if (SUCCEEDED(hr)) {
// Set callback so OnReadSample() is called for each new video frame or audio sample.
hr = readerAttributes->SetUnknown(MF_SOURCE_READER_ASYNC_CALLBACK,
static_cast<IMFSourceReaderCallback*>(this));
if (SUCCEEDED(hr)) {
hr = MFCreateSourceReaderFromMediaSource(aggregateSource.Get(), readerAttributes.Get(), &sourceReader);
}
}
}
}
return hr;
}
// Selects the requested resolution/frame rate (if specified),
// or chooses a high quality configuration otherwise.
DWORD QWindowsMediaDeviceReader::findMediaTypeIndex(const QCameraFormat &reqFormat)
{
DWORD mediaIndex = MEDIA_TYPE_INDEX_DEFAULT;
if (m_sourceReader && m_videoSource) {
DWORD index = 0;
ComPtr<IMFMediaType> mediaType;
UINT32 currArea = 0;
float currFrameRate = 0.0f;
while (SUCCEEDED(m_sourceReader->GetNativeMediaType(DWORD(MF_SOURCE_READER_FIRST_VIDEO_STREAM),
index, mediaType.ReleaseAndGetAddressOf()))) {
GUID subtype = GUID_NULL;
if (SUCCEEDED(mediaType->GetGUID(MF_MT_SUBTYPE, &subtype))) {
auto pixelFormat = QWMF::pixelFormatFromMediaSubtype(subtype);
if (pixelFormat != QVideoFrameFormat::Format_Invalid) {
UINT32 width, height;
if (SUCCEEDED(MFGetAttributeSize(mediaType.Get(), MF_MT_FRAME_SIZE, &width, &height))) {
UINT32 num, den;
if (SUCCEEDED(MFGetAttributeRatio(mediaType.Get(), MF_MT_FRAME_RATE, &num, &den))) {
UINT32 area = width * height;
float frameRate = float(num) / den;
if (!reqFormat.isNull()
&& UINT32(reqFormat.resolution().width()) == width
&& UINT32(reqFormat.resolution().height()) == height
&& QtPrivate::fuzzyCompare(reqFormat.maxFrameRate(), frameRate)
&& reqFormat.pixelFormat() == pixelFormat) {
return index;
}
if ((currFrameRate < 29.9 && currFrameRate < frameRate) ||
(currFrameRate == frameRate && currArea < area)) {
currArea = area;
currFrameRate = frameRate;
mediaIndex = index;
}
}
}
}
}
++index;
}
}
return mediaIndex;
}
// Prepares the source video stream and gets some metadata.
HRESULT QWindowsMediaDeviceReader::prepareVideoStream(DWORD mediaTypeIndex)
{
if (!m_sourceReader)
return E_FAIL;
if (!m_videoSource)
return S_OK; // It may be audio-only
HRESULT hr;
if (mediaTypeIndex == MEDIA_TYPE_INDEX_DEFAULT) {
hr = m_sourceReader->GetCurrentMediaType(DWORD(MF_SOURCE_READER_FIRST_VIDEO_STREAM),
&m_videoMediaType);
} else {
hr = m_sourceReader->GetNativeMediaType(DWORD(MF_SOURCE_READER_FIRST_VIDEO_STREAM),
mediaTypeIndex, &m_videoMediaType);
if (SUCCEEDED(hr))
hr = m_sourceReader->SetCurrentMediaType(DWORD(MF_SOURCE_READER_FIRST_VIDEO_STREAM),
nullptr, m_videoMediaType.Get());
}
if (SUCCEEDED(hr)) {
GUID subtype = GUID_NULL;
hr = m_videoMediaType->GetGUID(MF_MT_SUBTYPE, &subtype);
if (SUCCEEDED(hr)) {
m_pixelFormat = QWMF::pixelFormatFromMediaSubtype(subtype);
if (m_pixelFormat == QVideoFrameFormat::Format_Invalid) {
hr = E_FAIL;
} else {
// get the frame dimensions
hr = MFGetAttributeSize(m_videoMediaType.Get(), MF_MT_FRAME_SIZE, &m_frameWidth, &m_frameHeight);
if (SUCCEEDED(hr)) {
// and the stride, which we need to convert the frame later
hr = MFGetStrideForBitmapInfoHeader(subtype.Data1, m_frameWidth, &m_stride);
if (SUCCEEDED(hr)) {
m_stride = qAbs(m_stride);
UINT32 frameRateNum, frameRateDen;
hr = MFGetAttributeRatio(m_videoMediaType.Get(), MF_MT_FRAME_RATE, &frameRateNum, &frameRateDen);
if (SUCCEEDED(hr)) {
m_frameRate = qreal(frameRateNum) / frameRateDen;
hr = m_sourceReader->SetStreamSelection(DWORD(MF_SOURCE_READER_FIRST_VIDEO_STREAM), TRUE);
UINT32 nominalRange = 0;
if (SUCCEEDED(m_videoMediaType->GetUINT32(MF_MT_VIDEO_NOMINAL_RANGE, &nominalRange)))
m_colorRange = QWMF::colorRangeFromNominalRange(nominalRange);
UINT32 yuvMatrix = 0;
if (SUCCEEDED(m_videoMediaType->GetUINT32(MF_MT_YUV_MATRIX, &yuvMatrix))) {
m_colorSpace = QWMF::colorSpaceFromMatrix(yuvMatrix);
}
}
}
}
}
}
}
return hr;
}
HRESULT QWindowsMediaDeviceReader::initAudioType(const ComPtr<IMFMediaType> &mediaType, UINT32 channels, UINT32 samplesPerSec, bool flt)
{
if (!mediaType)
return E_INVALIDARG;
HRESULT hr = mediaType->SetGUID(MF_MT_MAJOR_TYPE, MFMediaType_Audio);
if (SUCCEEDED(hr)) {
hr = mediaType->SetGUID(MF_MT_SUBTYPE, flt ? MFAudioFormat_Float : MFAudioFormat_PCM);
if (SUCCEEDED(hr)) {
hr = mediaType->SetUINT32(MF_MT_AUDIO_NUM_CHANNELS, channels);
if (SUCCEEDED(hr)) {
hr = mediaType->SetUINT32(MF_MT_AUDIO_CHANNEL_MASK,
(channels == 1) ? SPEAKER_FRONT_CENTER : (SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT ));
if (SUCCEEDED(hr)) {
hr = mediaType->SetUINT32(MF_MT_AUDIO_SAMPLES_PER_SECOND, samplesPerSec);
if (SUCCEEDED(hr)) {
UINT32 bitsPerSample = flt ? 32 : 16;
UINT32 bytesPerFrame = channels * bitsPerSample/8;
hr = mediaType->SetUINT32(MF_MT_AUDIO_BITS_PER_SAMPLE, bitsPerSample);
if (SUCCEEDED(hr)) {
hr = mediaType->SetUINT32(MF_MT_AUDIO_BLOCK_ALIGNMENT, bytesPerFrame);
if (SUCCEEDED(hr)) {
hr = mediaType->SetUINT32(MF_MT_AUDIO_AVG_BYTES_PER_SECOND, bytesPerFrame * samplesPerSec);
}
}
}
}
}
}
}
return hr;
}
// Prepares the source audio stream.
HRESULT QWindowsMediaDeviceReader::prepareAudioStream()
{
if (!m_sourceReader)
return E_FAIL;
if (!m_audioSource)
return S_OK; // It may be video-only
HRESULT hr = m_sourceReader->GetCurrentMediaType(DWORD(MF_SOURCE_READER_FIRST_AUDIO_STREAM),
&m_audioMediaType);
if (SUCCEEDED(hr)) {
hr = initAudioType(m_audioMediaType, 2, 48000, true);
if (SUCCEEDED(hr)) {
hr = m_sourceReader->SetCurrentMediaType(DWORD(MF_SOURCE_READER_FIRST_AUDIO_STREAM),
nullptr, m_audioMediaType.Get());
if (SUCCEEDED(hr)) {
hr = m_sourceReader->SetStreamSelection(DWORD(MF_SOURCE_READER_FIRST_AUDIO_STREAM), TRUE);
}
}
}
return hr;
}
// Retrieves the indexes for selected video/audio streams.
HRESULT QWindowsMediaDeviceReader::initSourceIndexes()
{
if (!m_sourceReader)
return E_FAIL;
m_sourceVideoStreamIndex = MF_SOURCE_READER_INVALID_STREAM_INDEX;
m_sourceAudioStreamIndex = MF_SOURCE_READER_INVALID_STREAM_INDEX;
DWORD index = 0;
BOOL selected = FALSE;
ComPtr<IMFMediaType> mediaType;
while (m_sourceReader->GetStreamSelection(index, &selected) == S_OK) {
if (selected) {
if (SUCCEEDED(m_sourceReader->GetCurrentMediaType(index, mediaType.ReleaseAndGetAddressOf()))) {
GUID majorType = GUID_NULL;
if (SUCCEEDED(mediaType->GetGUID(MF_MT_MAJOR_TYPE, &majorType))) {
if (majorType == MFMediaType_Video)
m_sourceVideoStreamIndex = index;
else if (majorType == MFMediaType_Audio)
m_sourceAudioStreamIndex = index;
}
}
}
++index;
}
if ((m_videoSource && m_sourceVideoStreamIndex == MF_SOURCE_READER_INVALID_STREAM_INDEX) ||
(m_audioSource && m_sourceAudioStreamIndex == MF_SOURCE_READER_INVALID_STREAM_INDEX))
return E_FAIL;
return S_OK;
}
bool QWindowsMediaDeviceReader::setAudioOutput(const QString &audioOutputId)
{
QMutexLocker locker(&m_mutex);
stopMonitoring();
m_audioOutputId = audioOutputId;
if (!m_active || m_audioOutputId.isEmpty())
return true;
HRESULT hr = startMonitoring();
return SUCCEEDED(hr);
}
HRESULT QWindowsMediaDeviceReader::startMonitoring()
{
if (m_audioOutputId.isEmpty())
return E_FAIL;
ComPtr<IMFAttributes> sinkAttributes;
HRESULT hr = MFCreateAttributes(sinkAttributes.GetAddressOf(), 1);
if (SUCCEEDED(hr)) {
hr = sinkAttributes->SetString(MF_AUDIO_RENDERER_ATTRIBUTE_ENDPOINT_ID,
reinterpret_cast<LPCWSTR>(m_audioOutputId.utf16()));
if (SUCCEEDED(hr)) {
ComPtr<IMFMediaSink> mediaSink;
hr = MFCreateAudioRenderer(sinkAttributes.Get(), mediaSink.GetAddressOf());
if (SUCCEEDED(hr)) {
ComPtr<IMFStreamSink> streamSink;
hr = mediaSink->GetStreamSinkByIndex(0, streamSink.GetAddressOf());
if (SUCCEEDED(hr)) {
ComPtr<IMFMediaTypeHandler> typeHandler;
hr = streamSink->GetMediaTypeHandler(typeHandler.GetAddressOf());
if (SUCCEEDED(hr)) {
hr = typeHandler->IsMediaTypeSupported(m_audioMediaType.Get(), nullptr);
if (SUCCEEDED(hr)) {
hr = typeHandler->SetCurrentMediaType(m_audioMediaType.Get());
if (SUCCEEDED(hr)) {
ComPtr<IMFAttributes> writerAttributes;
HRESULT hr = MFCreateAttributes(writerAttributes.GetAddressOf(), 1);
if (SUCCEEDED(hr)) {
hr = writerAttributes->SetUINT32(MF_SINK_WRITER_DISABLE_THROTTLING, TRUE);
if (SUCCEEDED(hr)) {
ComPtr<IMFSinkWriter> sinkWriter;
hr = MFCreateSinkWriterFromMediaSink(mediaSink.Get(), writerAttributes.Get(), sinkWriter.GetAddressOf());
if (SUCCEEDED(hr)) {
hr = sinkWriter->SetInputMediaType(0, m_audioMediaType.Get(), nullptr);
if (SUCCEEDED(hr)) {
ComPtr<IMFSimpleAudioVolume> audioVolume;
if (SUCCEEDED(MFGetService(
mediaSink.Get(), MR_POLICY_VOLUME_SERVICE,
IID_PPV_ARGS(&audioVolume)))) {
audioVolume->SetMasterVolume(float(m_outputVolume));
audioVolume->SetMute(m_outputMuted);
}
hr = sinkWriter->BeginWriting();
if (SUCCEEDED(hr)) {
m_monitorSink = mediaSink;
m_monitorWriter = sinkWriter;
}
}
}
}
}
}
}
}
}
}
}
}
return hr;
}
void QWindowsMediaDeviceReader::stopMonitoring()
{
m_monitorWriter = nullptr;
if (m_monitorSink) {
m_monitorSink->Shutdown();
m_monitorSink = nullptr;
}
}
// Activates the requested camera/microphone for streaming.
// One of the IDs may be empty for video-only/audio-only.
bool QWindowsMediaDeviceReader::activate(const QString &cameraId,
const QCameraFormat &cameraFormat,
const QString µphoneId)
{
QMutexLocker locker(&m_mutex);
if (cameraId.isEmpty() && microphoneId.isEmpty())
return false;
stopMonitoring();
releaseResources();
m_active = false;
m_streaming = false;
if (!cameraId.isEmpty()) {
if (!SUCCEEDED(createSource(cameraId, true, m_videoSource))) {
releaseResources();
return false;
}
}
if (!microphoneId.isEmpty()) {
if (!SUCCEEDED(createSource(microphoneId, false, m_audioSource))) {
releaseResources();
return false;
}
}
if (!SUCCEEDED(createAggregateReader(m_videoSource, m_audioSource, m_aggregateSource, m_sourceReader))) {
releaseResources();
return false;
}
DWORD mediaTypeIndex = findMediaTypeIndex(cameraFormat);
if (!SUCCEEDED(prepareVideoStream(mediaTypeIndex))) {
releaseResources();
return false;
}
if (!SUCCEEDED(prepareAudioStream())) {
releaseResources();
return false;
}
if (!SUCCEEDED(initSourceIndexes())) {
releaseResources();
return false;
}
updateSinkInputMediaTypes();
startMonitoring();
// Request the first frame or audio sample.
if (!SUCCEEDED(m_sourceReader->ReadSample(MF_SOURCE_READER_ANY_STREAM, 0, nullptr, nullptr, nullptr, nullptr))) {
releaseResources();
return false;
}
m_active = true;
return true;
}
void QWindowsMediaDeviceReader::deactivate()
{
stopMonitoring();
stopStreaming();
m_active = false;
m_streaming = false;
}
void QWindowsMediaDeviceReader::stopStreaming()
{
QMutexLocker locker(&m_mutex);
releaseResources();
}
// Releases allocated streaming stuff.
void QWindowsMediaDeviceReader::releaseResources()
{
m_videoMediaType = nullptr;
m_audioMediaType = nullptr;
m_sourceReader = nullptr;
m_aggregateSource = nullptr;
m_videoSource = nullptr;
m_audioSource = nullptr;
}
HRESULT QWindowsMediaDeviceReader::createVideoMediaType(const GUID &format, UINT32 bitRate, UINT32 width,
UINT32 height, qreal frameRate, ComPtr<IMFMediaType> &mediaType)
{
mediaType = nullptr;
ComPtr<IMFMediaType> targetMediaType;
if (SUCCEEDED(MFCreateMediaType(targetMediaType.GetAddressOf()))) {
if (SUCCEEDED(targetMediaType->SetGUID(MF_MT_MAJOR_TYPE, MFMediaType_Video))) {
if (SUCCEEDED(targetMediaType->SetGUID(MF_MT_SUBTYPE, format))) {
if (SUCCEEDED(targetMediaType->SetUINT32(MF_MT_AVG_BITRATE, bitRate))) {
if (SUCCEEDED(MFSetAttributeSize(targetMediaType.Get(), MF_MT_FRAME_SIZE, width, height))) {
if (SUCCEEDED(MFSetAttributeRatio(targetMediaType.Get(), MF_MT_FRAME_RATE,
UINT32(frameRate * 1000), 1000))) {
UINT32 t1, t2;
if (SUCCEEDED(MFGetAttributeRatio(m_videoMediaType.Get(), MF_MT_PIXEL_ASPECT_RATIO, &t1, &t2))) {
if (SUCCEEDED(MFSetAttributeRatio(targetMediaType.Get(), MF_MT_PIXEL_ASPECT_RATIO, t1, t2))) {
if (SUCCEEDED(m_videoMediaType->GetUINT32(MF_MT_INTERLACE_MODE, &t1))) {
if (SUCCEEDED(targetMediaType->SetUINT32(MF_MT_INTERLACE_MODE, t1))) {
mediaType = targetMediaType;
return S_OK;
}
}
}
}
}
}
}
}
}
}
return E_FAIL;
}
HRESULT QWindowsMediaDeviceReader::createAudioMediaType(const GUID &format, UINT32 bitRate, ComPtr<IMFMediaType> &mediaType)
{
mediaType = nullptr;
ComPtr<IMFMediaType> targetMediaType;
if (SUCCEEDED(MFCreateMediaType(targetMediaType.GetAddressOf()))) {
if (SUCCEEDED(targetMediaType->SetGUID(MF_MT_MAJOR_TYPE, MFMediaType_Audio))) {
if (SUCCEEDED(targetMediaType->SetGUID(MF_MT_SUBTYPE, format))) {
if (bitRate == 0 || SUCCEEDED(targetMediaType->SetUINT32(MF_MT_AUDIO_AVG_BYTES_PER_SECOND, bitRate / 8))) {
mediaType = targetMediaType;
return S_OK;
}
}
}
}
return E_FAIL;
}
HRESULT QWindowsMediaDeviceReader::updateSinkInputMediaTypes()
{
HRESULT hr = S_OK;
if (m_sinkWriter) {
if (m_videoSource && m_videoMediaType && m_sinkVideoStreamIndex != MF_SINK_WRITER_INVALID_STREAM_INDEX) {
hr = m_sinkWriter->SetInputMediaType(m_sinkVideoStreamIndex, m_videoMediaType.Get(), nullptr);
}
if (SUCCEEDED(hr)) {
if (m_audioSource && m_audioMediaType && m_sinkAudioStreamIndex != MF_SINK_WRITER_INVALID_STREAM_INDEX) {
hr = m_sinkWriter->SetInputMediaType(m_sinkAudioStreamIndex, m_audioMediaType.Get(), nullptr);
}
}
}
return hr;
}
QMediaRecorder::Error QWindowsMediaDeviceReader::startRecording(
const QString &fileName, const GUID &container, const GUID &videoFormat, UINT32 videoBitRate,
UINT32 width, UINT32 height, qreal frameRate, const GUID &audioFormat, UINT32 audioBitRate)
{
QMutexLocker locker(&m_mutex);
if (!m_active || m_recording || (videoFormat == GUID_NULL && audioFormat == GUID_NULL))
return QMediaRecorder::ResourceError;
ComPtr<IMFAttributes> writerAttributes;
HRESULT hr = MFCreateAttributes(writerAttributes.GetAddressOf(), 2);
if (FAILED(hr))
return QMediaRecorder::ResourceError;
// Set callback so OnFinalize() is called after video is saved.
hr = writerAttributes->SetUnknown(MF_SINK_WRITER_ASYNC_CALLBACK,
static_cast<IMFSinkWriterCallback*>(this));
if (FAILED(hr))
return QMediaRecorder::ResourceError;
hr = writerAttributes->SetGUID(MF_TRANSCODE_CONTAINERTYPE, container);
if (FAILED(hr))
return QMediaRecorder::ResourceError;
ComPtr<IMFSinkWriter> sinkWriter;
hr = MFCreateSinkWriterFromURL(reinterpret_cast<LPCWSTR>(fileName.utf16()),
nullptr, writerAttributes.Get(), sinkWriter.GetAddressOf());
if (FAILED(hr))
return QMediaRecorder::LocationNotWritable;
m_sinkVideoStreamIndex = MF_SINK_WRITER_INVALID_STREAM_INDEX;
m_sinkAudioStreamIndex = MF_SINK_WRITER_INVALID_STREAM_INDEX;
if (m_videoSource && videoFormat != GUID_NULL) {
ComPtr<IMFMediaType> targetMediaType;
hr = createVideoMediaType(videoFormat, videoBitRate, width, height, frameRate, targetMediaType);
if (SUCCEEDED(hr)) {
hr = sinkWriter->AddStream(targetMediaType.Get(), &m_sinkVideoStreamIndex);
if (SUCCEEDED(hr)) {
hr = sinkWriter->SetInputMediaType(m_sinkVideoStreamIndex, m_videoMediaType.Get(), nullptr);
}
}
}
if (SUCCEEDED(hr)) {
if (m_audioSource && audioFormat != GUID_NULL) {
ComPtr<IMFMediaType> targetMediaType;
hr = createAudioMediaType(audioFormat, audioBitRate, targetMediaType);
if (SUCCEEDED(hr)) {
hr = sinkWriter->AddStream(targetMediaType.Get(), &m_sinkAudioStreamIndex);
if (SUCCEEDED(hr)) {
hr = sinkWriter->SetInputMediaType(m_sinkAudioStreamIndex, m_audioMediaType.Get(), nullptr);
}
}
}
}
if (FAILED(hr))
return QMediaRecorder::FormatError;
hr = sinkWriter->BeginWriting();
if (FAILED(hr))
return QMediaRecorder::ResourceError;
m_sinkWriter = std::move(sinkWriter);
m_lastDuration = -1;
m_currentDuration = 0;
updateDuration();
m_durationTimer.start();
m_recording = true;
m_firstFrame = true;
m_paused = false;
m_pauseChanging = false;
return QMediaRecorder::NoError;
}
void QWindowsMediaDeviceReader::stopRecording()
{
QMutexLocker locker(&m_mutex);
if (m_sinkWriter && m_recording) {
HRESULT hr = m_sinkWriter->Finalize();
if (SUCCEEDED(hr)) {
m_hasFinalized.wait(&m_mutex);
} else {
m_sinkWriter = nullptr;
QMetaObject::invokeMethod(this, [this, hr] {
Q_EMIT recordingError(hr);
}, Qt::QueuedConnection);
}
}
m_recording = false;
m_paused = false;
m_pauseChanging = false;
m_durationTimer.stop();
m_lastDuration = -1;
m_currentDuration = -1;
}
bool QWindowsMediaDeviceReader::pauseRecording()
{
if (!m_recording || m_paused)
return false;
m_pauseTime = m_lastTimestamp;
m_paused = true;
m_pauseChanging = true;
return true;
}
bool QWindowsMediaDeviceReader::resumeRecording()
{
if (!m_recording || !m_paused)
return false;
m_paused = false;
m_pauseChanging = true;
return true;
}
UINT32 QWindowsMediaDeviceReader::frameWidth() const
{
return m_frameWidth;
}
UINT32 QWindowsMediaDeviceReader::frameHeight() const
{
return m_frameHeight;
}
qreal QWindowsMediaDeviceReader::frameRate() const
{
return m_frameRate;
}
void QWindowsMediaDeviceReader::setInputMuted(bool muted)
{
m_inputMuted = muted;
}
void QWindowsMediaDeviceReader::setInputVolume(qreal volume)
{
m_inputVolume = qBound(0.0, volume, 1.0);
}
void QWindowsMediaDeviceReader::setOutputMuted(bool muted)
{
QMutexLocker locker(&m_mutex);
m_outputMuted = muted;
if (m_active && m_monitorSink) {
ComPtr<IMFSimpleAudioVolume> audioVolume;
if (SUCCEEDED(MFGetService(m_monitorSink.Get(), MR_POLICY_VOLUME_SERVICE,
IID_PPV_ARGS(&audioVolume)))) {
audioVolume->SetMute(m_outputMuted);
}
}
}
void QWindowsMediaDeviceReader::setOutputVolume(qreal volume)
{
QMutexLocker locker(&m_mutex);
m_outputVolume = qBound(0.0, volume, 1.0);
if (m_active && m_monitorSink) {
ComPtr<IMFSimpleAudioVolume> audioVolume;
if (SUCCEEDED(MFGetService(m_monitorSink.Get(), MR_POLICY_VOLUME_SERVICE,
IID_PPV_ARGS(&audioVolume)))) {
audioVolume->SetMasterVolume(float(m_outputVolume));
}
}
}
void QWindowsMediaDeviceReader::updateDuration()
{
if (m_currentDuration >= 0 && m_lastDuration != m_currentDuration) {
m_lastDuration = m_currentDuration;
Q_EMIT durationChanged(m_currentDuration);
}
}
//from IMFSourceReaderCallback
STDMETHODIMP QWindowsMediaDeviceReader::OnReadSample(HRESULT hrStatus, DWORD dwStreamIndex,
DWORD dwStreamFlags, LONGLONG llTimestamp,
IMFSample *pSample)
{
QMutexLocker locker(&m_mutex);
if (FAILED(hrStatus)) {
Q_EMIT streamingError(hrStatus);
return hrStatus;
}
m_lastTimestamp = llTimestamp;
if ((dwStreamFlags & MF_SOURCE_READERF_ENDOFSTREAM) == MF_SOURCE_READERF_ENDOFSTREAM) {
m_streaming = false;
Q_EMIT streamingStopped();
} else {
if (!m_streaming) {
m_streaming = true;
Q_EMIT streamingStarted();
}
if (pSample) {
if (m_monitorWriter && dwStreamIndex == m_sourceAudioStreamIndex)
m_monitorWriter->WriteSample(0, pSample);
if (m_recording) {
if (m_firstFrame) {
m_timeOffset = llTimestamp;
m_firstFrame = false;
Q_EMIT recordingStarted();
}
if (m_pauseChanging) {
// Recording time should not pass while paused.
if (m_paused)
m_pauseTime = llTimestamp;
else
m_timeOffset += llTimestamp - m_pauseTime;
m_pauseChanging = false;
}
// Send the video frame or audio sample to be encoded.
if (m_sinkWriter && !m_paused) {
pSample->SetSampleTime(llTimestamp - m_timeOffset);
if (dwStreamIndex == m_sourceVideoStreamIndex) {
m_sinkWriter->WriteSample(m_sinkVideoStreamIndex, pSample);
} else if (dwStreamIndex == m_sourceAudioStreamIndex) {
float volume = m_inputMuted ? 0.0f : float(m_inputVolume);
// Change the volume of the audio sample, if needed.
if (volume != 1.0f) {
ComPtr<IMFMediaBuffer> mediaBuffer;
if (SUCCEEDED(pSample->ConvertToContiguousBuffer(mediaBuffer.GetAddressOf()))) {
DWORD bufLen = 0;
BYTE *buffer = nullptr;
if (SUCCEEDED(mediaBuffer->Lock(&buffer, nullptr, &bufLen))) {
float *floatBuffer = reinterpret_cast<float*>(buffer);
for (DWORD i = 0; i < bufLen/4; ++i)
floatBuffer[i] *= volume;
mediaBuffer->Unlock();
}
}
}
m_sinkWriter->WriteSample(m_sinkAudioStreamIndex, pSample);
}
m_currentDuration = (llTimestamp - m_timeOffset) / 10000;
}
}
// Generate a new QVideoFrame from IMFSample.
if (dwStreamIndex == m_sourceVideoStreamIndex) {
ComPtr<IMFMediaBuffer> mediaBuffer;
if (SUCCEEDED(pSample->ConvertToContiguousBuffer(mediaBuffer.GetAddressOf()))) {
DWORD bufLen = 0;
BYTE *buffer = nullptr;
if (SUCCEEDED(mediaBuffer->Lock(&buffer, nullptr, &bufLen))) {
auto bytes = QByteArray(reinterpret_cast<char*>(buffer), bufLen);
QVideoFrameFormat format(QSize(m_frameWidth, m_frameHeight), m_pixelFormat);
format.setColorRange(m_colorRange);
format.setColorSpace(m_colorSpace);
QVideoFrame frame = QVideoFramePrivate::createFrame(
std::make_unique<QMemoryVideoBuffer>(std::move(bytes), m_stride),
std::move(format));
// WMF uses 100-nanosecond units, Qt uses microseconds
frame.setStartTime(llTimestamp * 0.1);
LONGLONG duration = -1;
if (SUCCEEDED(pSample->GetSampleDuration(&duration)))
frame.setEndTime((llTimestamp + duration) * 0.1);
Q_EMIT videoFrameChanged(frame);
mediaBuffer->Unlock();
}
}
}
}
// request the next video frame or sound sample
if (m_sourceReader)
m_sourceReader->ReadSample(MF_SOURCE_READER_ANY_STREAM,
0, nullptr, nullptr, nullptr, nullptr);
}
return S_OK;
}
STDMETHODIMP QWindowsMediaDeviceReader::OnFlush(DWORD)
{
return S_OK;
}
STDMETHODIMP QWindowsMediaDeviceReader::OnEvent(DWORD, IMFMediaEvent*)
{
return S_OK;
}
//from IMFSinkWriterCallback
STDMETHODIMP QWindowsMediaDeviceReader::OnFinalize(HRESULT)
{
QMutexLocker locker(&m_mutex);
m_sinkWriter = nullptr;
Q_EMIT recordingStopped();
m_hasFinalized.notify_one();
return S_OK;
}
STDMETHODIMP QWindowsMediaDeviceReader::OnMarker(DWORD, LPVOID)
{
return S_OK;
}
QT_END_NAMESPACE
#include "moc_qwindowsmediadevicereader_p.cpp"