summaryrefslogtreecommitdiffstats
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/plugins/directshow/camera/directshowcameraglobal.h3
-rw-r--r--src/plugins/directshow/camera/dscamerasession.cpp105
-rw-r--r--src/plugins/directshow/camera/dscamerasession.h5
-rw-r--r--src/plugins/directshow/helpers/directshowglobal.h3
-rw-r--r--src/plugins/directshow/helpers/directshowmediatype.cpp198
-rw-r--r--src/plugins/directshow/helpers/directshowmediatype.h45
-rw-r--r--src/plugins/directshow/helpers/directshowmediatypeenum.cpp2
-rw-r--r--src/plugins/directshow/helpers/directshowpin.cpp35
-rw-r--r--src/plugins/directshow/helpers/directshowpin.h8
-rw-r--r--src/plugins/directshow/player/directshowiosource.cpp12
-rw-r--r--src/plugins/directshow/player/directshowplayerservice.cpp6
-rw-r--r--src/plugins/directshow/player/videosurfacefilter.cpp16
-rw-r--r--src/plugins/directshow/player/videosurfacefilter.h4
13 files changed, 227 insertions, 215 deletions
diff --git a/src/plugins/directshow/camera/directshowcameraglobal.h b/src/plugins/directshow/camera/directshowcameraglobal.h
index 75112a090..8df387b4a 100644
--- a/src/plugins/directshow/camera/directshowcameraglobal.h
+++ b/src/plugins/directshow/camera/directshowcameraglobal.h
@@ -44,9 +44,6 @@
#include <dshow.h>
-DEFINE_GUID(MEDIASUBTYPE_I420,
- 0x30323449,0x0000,0x0010,0x80,0x00,0x00,0xAA,0x00,0x38,0x9B,0x71);
-
extern const GUID MEDIASUBTYPE_RGB24;
extern const GUID MEDIASUBTYPE_RGB32;
extern const GUID MEDIASUBTYPE_YUY2;
diff --git a/src/plugins/directshow/camera/dscamerasession.cpp b/src/plugins/directshow/camera/dscamerasession.cpp
index 9955a4821..83abd983e 100644
--- a/src/plugins/directshow/camera/dscamerasession.cpp
+++ b/src/plugins/directshow/camera/dscamerasession.cpp
@@ -48,44 +48,12 @@
#include "dscamerasession.h"
#include "dsvideorenderer.h"
#include "directshowcameraglobal.h"
+#include "directshowmediatype.h"
QT_BEGIN_NAMESPACE
-
-namespace {
-// DirectShow helper implementation
-void _CopyMediaType(AM_MEDIA_TYPE *pmtTarget, const AM_MEDIA_TYPE *pmtSource)
-{
- *pmtTarget = *pmtSource;
- if (pmtTarget->cbFormat != 0) {
- pmtTarget->pbFormat = reinterpret_cast<BYTE *>(CoTaskMemAlloc(pmtTarget->cbFormat));
- if (pmtTarget->pbFormat)
- memcpy(pmtTarget->pbFormat, pmtSource->pbFormat, pmtTarget->cbFormat);
- }
- if (pmtTarget->pUnk != NULL) {
- // pUnk should not be used.
- pmtTarget->pUnk->AddRef();
- }
-}
-
-void _FreeMediaType(AM_MEDIA_TYPE& mt)
-{
- if (mt.cbFormat != 0) {
- CoTaskMemFree((PVOID)mt.pbFormat);
- mt.cbFormat = 0;
- mt.pbFormat = NULL;
- }
- if (mt.pUnk != NULL) {
- // pUnk should not be used.
- mt.pUnk->Release();
- mt.pUnk = NULL;
- }
-}
-} // end namespace
-
static HRESULT getPin(IBaseFilter *filter, PIN_DIRECTION pinDir, IPin **pin);
-
class SampleGrabberCallbackPrivate : public ISampleGrabberCB
{
public:
@@ -150,45 +118,6 @@ private:
DSCameraSession *m_session;
};
-QVideoFrame::PixelFormat pixelFormatFromMediaSubtype(GUID uid)
-{
- if (uid == MEDIASUBTYPE_ARGB32)
- return QVideoFrame::Format_ARGB32;
- else if (uid == MEDIASUBTYPE_RGB32)
- return QVideoFrame::Format_RGB32;
- else if (uid == MEDIASUBTYPE_RGB24)
- return QVideoFrame::Format_RGB24;
- else if (uid == MEDIASUBTYPE_RGB565)
- return QVideoFrame::Format_RGB565;
- else if (uid == MEDIASUBTYPE_RGB555)
- return QVideoFrame::Format_RGB555;
- else if (uid == MEDIASUBTYPE_AYUV)
- return QVideoFrame::Format_AYUV444;
- else if (uid == MEDIASUBTYPE_I420 || uid == MEDIASUBTYPE_IYUV)
- return QVideoFrame::Format_YUV420P;
- else if (uid == MEDIASUBTYPE_YV12)
- return QVideoFrame::Format_YV12;
- else if (uid == MEDIASUBTYPE_UYVY)
- return QVideoFrame::Format_UYVY;
- else if (uid == MEDIASUBTYPE_YUYV || uid == MEDIASUBTYPE_YUY2)
- return QVideoFrame::Format_YUYV;
- else if (uid == MEDIASUBTYPE_NV12)
- return QVideoFrame::Format_NV12;
- else if (uid == MEDIASUBTYPE_MJPG)
- return QVideoFrame::Format_Jpeg;
- else if (uid == MEDIASUBTYPE_IMC1)
- return QVideoFrame::Format_IMC1;
- else if (uid == MEDIASUBTYPE_IMC2)
- return QVideoFrame::Format_IMC2;
- else if (uid == MEDIASUBTYPE_IMC3)
- return QVideoFrame::Format_IMC3;
- else if (uid == MEDIASUBTYPE_IMC4)
- return QVideoFrame::Format_IMC4;
- else
- return QVideoFrame::Format_Invalid;
-}
-
-
DSCameraSession::DSCameraSession(QObject *parent)
: QObject(parent)
, m_graphBuilder(Q_NULLPTR)
@@ -207,8 +136,6 @@ DSCameraSession::DSCameraSession(QObject *parent)
, m_currentImageId(-1)
, m_status(QCamera::UnloadedStatus)
{
- ZeroMemory(&m_sourceFormat, sizeof(m_sourceFormat));
-
connect(this, SIGNAL(statusChanged(QCamera::Status)),
this, SLOT(updateReadyForCapture()));
}
@@ -499,8 +426,6 @@ bool DSCameraSession::unload()
m_needsHorizontalMirroring = false;
m_supportedViewfinderSettings.clear();
- for (AM_MEDIA_TYPE f : qAsConst(m_supportedFormats))
- _FreeMediaType(f);
m_supportedFormats.clear();
SAFE_RELEASE(m_sourceFilter);
SAFE_RELEASE(m_previewSampleGrabber);
@@ -587,8 +512,7 @@ bool DSCameraSession::stopPreview()
disconnectGraph();
- _FreeMediaType(m_sourceFormat);
- ZeroMemory(&m_sourceFormat, sizeof(m_sourceFormat));
+ m_sourceFormat.clear();
m_previewStarted = false;
setStatus(QCamera::LoadedStatus);
@@ -910,11 +834,11 @@ bool DSCameraSession::configurePreviewFormat()
m_actualViewfinderSettings = resolvedViewfinderSettings;
- _CopyMediaType(&m_sourceFormat, &m_supportedFormats[settingsIndex]);
+ m_sourceFormat = m_supportedFormats[settingsIndex];
// Set frame rate.
// We don't care about the minimumFrameRate, DirectShow only allows to set an
// average frame rate, so set that to the maximumFrameRate.
- VIDEOINFOHEADER *videoInfo = reinterpret_cast<VIDEOINFOHEADER*>(m_sourceFormat.pbFormat);
+ VIDEOINFOHEADER *videoInfo = reinterpret_cast<VIDEOINFOHEADER*>(m_sourceFormat->pbFormat);
videoInfo->AvgTimePerFrame = 10000000 / resolvedViewfinderSettings.maximumFrameRate();
// We only support RGB32, if the capture source doesn't support
@@ -955,16 +879,10 @@ bool DSCameraSession::configurePreviewFormat()
}
// Set sample grabber format (always RGB32)
- AM_MEDIA_TYPE grabberFormat;
- ZeroMemory(&grabberFormat, sizeof(grabberFormat));
- grabberFormat.majortype = MEDIATYPE_Video;
- grabberFormat.subtype = MEDIASUBTYPE_RGB32;
- grabberFormat.formattype = FORMAT_VideoInfo;
+ static const AM_MEDIA_TYPE grabberFormat { MEDIATYPE_Video, MEDIASUBTYPE_RGB32, 0, 0, 0, FORMAT_VideoInfo };
hr = m_previewSampleGrabber->SetMediaType(&grabberFormat);
- if (FAILED(hr)) {
- qWarning() << "Failed to set video format on grabber";
+ if (FAILED(hr))
return false;
- }
return true;
}
@@ -1107,8 +1025,6 @@ void DSCameraSession::updateSourceCapabilities()
m_supportedViewfinderSettings.clear();
m_needsHorizontalMirroring = false;
- for (AM_MEDIA_TYPE f : qAsConst(m_supportedFormats))
- _FreeMediaType(f);
m_supportedFormats.clear();
m_imageProcessingParametersInfos.clear();
@@ -1160,7 +1076,7 @@ void DSCameraSession::updateSourceCapabilities()
for (int iIndex = 0; iIndex < iCount; ++iIndex) {
hr = pConfig->GetStreamCaps(iIndex, &pmt, reinterpret_cast<BYTE*>(&scc));
if (hr == S_OK) {
- QVideoFrame::PixelFormat pixelFormat = pixelFormatFromMediaSubtype(pmt->subtype);
+ QVideoFrame::PixelFormat pixelFormat = DirectShowMediaType::pixelFormatFromType(pmt);
if (pmt->majortype == MEDIATYPE_Video
&& pmt->formattype == FORMAT_VideoInfo
@@ -1207,15 +1123,12 @@ void DSCameraSession::updateSourceCapabilities()
settings.setPixelFormat(pixelFormat);
settings.setPixelAspectRatio(1, 1);
m_supportedViewfinderSettings.append(settings);
-
- AM_MEDIA_TYPE format;
- _CopyMediaType(&format, pmt);
- m_supportedFormats.append(format);
+ m_supportedFormats.append(DirectShowMediaType(*pmt));
}
}
- _FreeMediaType(*pmt);
+ DirectShowMediaType::deleteType(pmt);
}
}
diff --git a/src/plugins/directshow/camera/dscamerasession.h b/src/plugins/directshow/camera/dscamerasession.h
index 61b156d8a..3e5dc5efd 100644
--- a/src/plugins/directshow/camera/dscamerasession.h
+++ b/src/plugins/directshow/camera/dscamerasession.h
@@ -56,6 +56,7 @@
#include <dshow.h>
#include <objbase.h>
#include <initguid.h>
+#include "directshowmediatype.h"
#ifdef Q_CC_MSVC
# pragma comment(lib, "strmiids.lib")
# pragma comment(lib, "ole32.lib")
@@ -182,9 +183,9 @@ private:
QString m_sourceDeviceName;
IBaseFilter* m_sourceFilter;
bool m_needsHorizontalMirroring;
- QList<AM_MEDIA_TYPE> m_supportedFormats;
+ QList<DirectShowMediaType> m_supportedFormats;
QList<QCameraViewfinderSettings> m_supportedViewfinderSettings;
- AM_MEDIA_TYPE m_sourceFormat;
+ DirectShowMediaType m_sourceFormat;
QMap<QCameraImageProcessingControl::ProcessingParameter, ImageProcessingParameterInfo> m_imageProcessingParametersInfos;
// Preview
diff --git a/src/plugins/directshow/helpers/directshowglobal.h b/src/plugins/directshow/helpers/directshowglobal.h
index 1447bff16..5f391710e 100644
--- a/src/plugins/directshow/helpers/directshowglobal.h
+++ b/src/plugins/directshow/helpers/directshowglobal.h
@@ -84,6 +84,9 @@ template <typename T> T *com_new(const IID &clsid, const IID &iid)
: 0;
}
+DEFINE_GUID(MEDIASUBTYPE_I420,
+ 0x30323449,0x0000,0x0010,0x80,0x00,0x00,0xAA,0x00,0x38,0x9B,0x71);
+
#ifndef __IFilterGraph2_INTERFACE_DEFINED__
#define __IFilterGraph2_INTERFACE_DEFINED__
#define INTERFACE IFilterGraph2
diff --git a/src/plugins/directshow/helpers/directshowmediatype.cpp b/src/plugins/directshow/helpers/directshowmediatype.cpp
index 60c0ee040..586b6bd80 100644
--- a/src/plugins/directshow/helpers/directshowmediatype.cpp
+++ b/src/plugins/directshow/helpers/directshowmediatype.cpp
@@ -38,6 +38,7 @@
****************************************************************************/
#include "directshowmediatype.h"
+#include "directshowglobal.h"
namespace
{
@@ -49,85 +50,168 @@ namespace
static const TypeLookup qt_typeLookup[] =
{
- { QVideoFrame::Format_RGB32, /*MEDIASUBTYPE_RGB32*/ {0xe436eb7e, 0x524f, 0x11ce, {0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70}} },
- { QVideoFrame::Format_BGR24, /*MEDIASUBTYPE_RGB24*/ {0xe436eb7d, 0x524f, 0x11ce, {0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70}} },
- { QVideoFrame::Format_RGB565, /*MEDIASUBTYPE_RGB565*/ {0xe436eb7b, 0x524f, 0x11ce, {0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70}} },
- { QVideoFrame::Format_RGB555, /*MEDIASUBTYPE_RGB555*/ {0xe436eb7c, 0x524f, 0x11ce, {0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70}} },
- { QVideoFrame::Format_AYUV444, /*MEDIASUBTYPE_AYUV*/ {0x56555941, 0x0000, 0x0010, {0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}} },
- { QVideoFrame::Format_YUYV, /*MEDIASUBTYPE_YUY2*/ {0x32595559, 0x0000, 0x0010, {0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}} },
- { QVideoFrame::Format_UYVY, /*MEDIASUBTYPE_UYVY*/ {0x59565955, 0x0000, 0x0010, {0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}} },
- { QVideoFrame::Format_IMC1, /*MEDIASUBTYPE_IMC1*/ {0x31434D49, 0x0000, 0x0010, {0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}} },
- { QVideoFrame::Format_IMC2, /*MEDIASUBTYPE_IMC2*/ {0x32434D49, 0x0000, 0x0010, {0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}} },
- { QVideoFrame::Format_IMC3, /*MEDIASUBTYPE_IMC3*/ {0x33434D49, 0x0000, 0x0010, {0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}} },
- { QVideoFrame::Format_IMC4, /*MEDIASUBTYPE_IMC4*/ {0x34434D49, 0x0000, 0x0010, {0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}} },
- { QVideoFrame::Format_YV12, /*MEDIASUBTYPE_YV12*/ {0x32315659, 0x0000, 0x0010, {0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}} },
- { QVideoFrame::Format_NV12, /*MEDIASUBTYPE_NV12*/ {0x3231564E, 0x0000, 0x0010, {0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}} },
- { QVideoFrame::Format_YUV420P, /*MEDIASUBTYPE_IYUV*/ {0x56555949, 0x0000, 0x0010, {0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}} },
- { QVideoFrame::Format_YUV420P, /*MEDIASUBTYPE_I420*/ {0x30323449, 0x0000, 0x0010, {0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}} }
+ { QVideoFrame::Format_ARGB32, MEDIASUBTYPE_ARGB32 },
+ { QVideoFrame::Format_RGB32, MEDIASUBTYPE_RGB32 },
+ { QVideoFrame::Format_RGB24, MEDIASUBTYPE_RGB24 },
+ { QVideoFrame::Format_RGB565, MEDIASUBTYPE_RGB565 },
+ { QVideoFrame::Format_RGB555, MEDIASUBTYPE_RGB555 },
+ { QVideoFrame::Format_AYUV444, MEDIASUBTYPE_AYUV },
+ { QVideoFrame::Format_YUYV, MEDIASUBTYPE_YUY2 },
+ { QVideoFrame::Format_UYVY, MEDIASUBTYPE_UYVY },
+ { QVideoFrame::Format_IMC1, MEDIASUBTYPE_IMC1 },
+ { QVideoFrame::Format_IMC2, MEDIASUBTYPE_IMC2 },
+ { QVideoFrame::Format_IMC3, MEDIASUBTYPE_IMC3 },
+ { QVideoFrame::Format_IMC4, MEDIASUBTYPE_IMC4 },
+ { QVideoFrame::Format_YV12, MEDIASUBTYPE_YV12 },
+ { QVideoFrame::Format_NV12, MEDIASUBTYPE_NV12 },
+ { QVideoFrame::Format_YUV420P, MEDIASUBTYPE_IYUV },
+ { QVideoFrame::Format_YUV420P, MEDIASUBTYPE_I420 },
+ { QVideoFrame::Format_Jpeg, MEDIASUBTYPE_MJPG }
};
}
-bool DirectShowMediaType::isPartiallySpecified() const
+bool DirectShowMediaType::isPartiallySpecified(const AM_MEDIA_TYPE *mediaType)
{
- return majortype == GUID_NULL || formattype == GUID_NULL;
+ return mediaType->majortype == GUID_NULL || mediaType->formattype == GUID_NULL;
}
-bool DirectShowMediaType::isCompatibleWith(const DirectShowMediaType *type) const
+DirectShowMediaType::DirectShowMediaType()
+ : mediaType({ GUID_NULL, GUID_NULL, TRUE, FALSE, 1 })
{
- if (type->majortype != GUID_NULL && majortype != type->majortype)
- return false;
+}
- if (type->subtype != GUID_NULL && subtype != type->subtype)
- return false;
+DirectShowMediaType::DirectShowMediaType(const AM_MEDIA_TYPE &type)
+ : DirectShowMediaType()
+{
+ copy(&mediaType, &type);
+}
- if (type->formattype != GUID_NULL) {
- if (formattype != type->formattype)
- return false;
- if (cbFormat != type->cbFormat)
- return false;
- if (cbFormat != 0 && memcmp(pbFormat, type->pbFormat, cbFormat) != 0)
- return false;
- }
+DirectShowMediaType::DirectShowMediaType(AM_MEDIA_TYPE &&type)
+ : DirectShowMediaType()
+{
+ move(&mediaType, type);
+}
- return true;
+DirectShowMediaType::DirectShowMediaType(const DirectShowMediaType &other)
+ : DirectShowMediaType()
+{
+ copy(&mediaType, &other.mediaType);
+}
+
+DirectShowMediaType::DirectShowMediaType(DirectShowMediaType &&other)
+ : DirectShowMediaType()
+{
+ move(&mediaType, other.mediaType);
+}
+
+DirectShowMediaType &DirectShowMediaType::operator=(const DirectShowMediaType &other)
+{
+ copy(&mediaType, &other.mediaType);
+ return *this;
+}
+
+DirectShowMediaType &DirectShowMediaType::operator=(DirectShowMediaType &&other)
+{
+ move(&mediaType, other.mediaType);
+ return *this;
}
void DirectShowMediaType::init(AM_MEDIA_TYPE *type)
{
- ZeroMemory((PVOID)type, sizeof(*type));
+ Q_ASSERT(type);
+ SecureZeroMemory(reinterpret_cast<void *>(type), sizeof(AM_MEDIA_TYPE));
type->lSampleSize = 1;
type->bFixedSizeSamples = TRUE;
}
-void DirectShowMediaType::copy(AM_MEDIA_TYPE *target, const AM_MEDIA_TYPE &source)
+void DirectShowMediaType::copy(AM_MEDIA_TYPE *target, const AM_MEDIA_TYPE *source)
{
- if (!target)
+ if (!(target && source))
+ return;
+
+ if (target == source)
return;
- *target = source;
+ clear(*target);
- if (source.cbFormat > 0) {
- target->pbFormat = reinterpret_cast<PBYTE>(CoTaskMemAlloc(source.cbFormat));
- memcpy(target->pbFormat, source.pbFormat, source.cbFormat);
+ *target = *source;
+
+ if (source->cbFormat > 0) {
+ target->pbFormat = reinterpret_cast<PBYTE>(CoTaskMemAlloc(source->cbFormat));
+ memcpy(target->pbFormat, source->pbFormat, source->cbFormat);
}
if (target->pUnk)
target->pUnk->AddRef();
}
+void DirectShowMediaType::move(AM_MEDIA_TYPE *target, AM_MEDIA_TYPE **source)
+{
+ if (!target || !source || !(*source))
+ return;
+
+ if (target == *source)
+ return;
+
+ clear(*target);
+ *target = *(*source);
+ SecureZeroMemory(reinterpret_cast<void *>(*source), sizeof(AM_MEDIA_TYPE));
+ *source = nullptr;
+}
+
+void DirectShowMediaType::move(AM_MEDIA_TYPE *target, AM_MEDIA_TYPE &source)
+{
+ AM_MEDIA_TYPE *srcPtr = &source;
+ move(target, &srcPtr);
+}
+
+/**
+ * @brief DirectShowMediaType::deleteType - Used for AM_MEDIA_TYPE structures that have
+ * been allocated by CoTaskMemAlloc or CreateMediaType.
+ * @param type
+ */
void DirectShowMediaType::deleteType(AM_MEDIA_TYPE *type)
{
- freeData(type);
+ if (!type)
+ return;
+ clear(*type);
CoTaskMemFree(type);
}
-void DirectShowMediaType::freeData(AM_MEDIA_TYPE *type)
+bool DirectShowMediaType::isCompatible(const AM_MEDIA_TYPE *a, const AM_MEDIA_TYPE *b)
+{
+ if (b->majortype != GUID_NULL && a->majortype != b->majortype)
+ return false;
+
+ if (b->subtype != GUID_NULL && a->subtype != b->subtype)
+ return false;
+
+ if (b->formattype != GUID_NULL) {
+ if (a->formattype != b->formattype)
+ return false;
+ if (a->cbFormat != b->cbFormat)
+ return false;
+ if (a->cbFormat != 0 && memcmp(a->pbFormat, b->pbFormat, a->cbFormat) != 0)
+ return false;
+ }
+
+ return true;
+}
+
+/**
+ * @brief DirectShowMediaType::clear - Clears all member data, and releases allocated buffers.
+ * Use this to release automatic AM_MEDIA_TYPE structures.
+ * @param type
+ */
+void DirectShowMediaType::clear(AM_MEDIA_TYPE &type)
{
- if (type->cbFormat > 0)
- CoTaskMemFree(type->pbFormat);
+ if (type.cbFormat > 0)
+ CoTaskMemFree(type.pbFormat);
+
+ if (type.pUnk)
+ type.pUnk->Release();
- if (type->pUnk)
- type->pUnk->Release();
+ SecureZeroMemory(&type, sizeof(type));
}
@@ -142,14 +226,17 @@ GUID DirectShowMediaType::convertPixelFormat(QVideoFrame::PixelFormat format)
return MEDIASUBTYPE_None;
}
-QVideoSurfaceFormat DirectShowMediaType::formatFromType(const AM_MEDIA_TYPE &type)
+QVideoSurfaceFormat DirectShowMediaType::videoFormatFromType(const AM_MEDIA_TYPE *type)
{
+ if (!type)
+ return QVideoSurfaceFormat();
+
const int count = sizeof(qt_typeLookup) / sizeof(TypeLookup);
for (int i = 0; i < count; ++i) {
- if (IsEqualGUID(qt_typeLookup[i].mediaType, type.subtype) && type.cbFormat > 0) {
- if (IsEqualGUID(type.formattype, FORMAT_VideoInfo)) {
- VIDEOINFOHEADER *header = reinterpret_cast<VIDEOINFOHEADER *>(type.pbFormat);
+ if (IsEqualGUID(qt_typeLookup[i].mediaType, type->subtype) && type->cbFormat > 0) {
+ if (IsEqualGUID(type->formattype, FORMAT_VideoInfo)) {
+ VIDEOINFOHEADER *header = reinterpret_cast<VIDEOINFOHEADER *>(type->pbFormat);
QVideoSurfaceFormat format(
QSize(header->bmiHeader.biWidth, qAbs(header->bmiHeader.biHeight)),
@@ -161,8 +248,8 @@ QVideoSurfaceFormat DirectShowMediaType::formatFromType(const AM_MEDIA_TYPE &typ
format.setScanLineDirection(scanLineDirection(format.pixelFormat(), header->bmiHeader));
return format;
- } else if (IsEqualGUID(type.formattype, FORMAT_VideoInfo2)) {
- VIDEOINFOHEADER2 *header = reinterpret_cast<VIDEOINFOHEADER2 *>(type.pbFormat);
+ } else if (IsEqualGUID(type->formattype, FORMAT_VideoInfo2)) {
+ VIDEOINFOHEADER2 *header = reinterpret_cast<VIDEOINFOHEADER2 *>(type->pbFormat);
QVideoSurfaceFormat format(
QSize(header->bmiHeader.biWidth, qAbs(header->bmiHeader.biHeight)),
@@ -180,12 +267,15 @@ QVideoSurfaceFormat DirectShowMediaType::formatFromType(const AM_MEDIA_TYPE &typ
return QVideoSurfaceFormat();
}
-QVideoFrame::PixelFormat DirectShowMediaType::pixelFormatFromType(const AM_MEDIA_TYPE &type)
+QVideoFrame::PixelFormat DirectShowMediaType::pixelFormatFromType(const AM_MEDIA_TYPE *type)
{
+ if (!type)
+ return QVideoFrame::Format_Invalid;
+
const int count = sizeof(qt_typeLookup) / sizeof(TypeLookup);
for (int i = 0; i < count; ++i) {
- if (IsEqualGUID(qt_typeLookup[i].mediaType, type.subtype)) {
+ if (IsEqualGUID(qt_typeLookup[i].mediaType, type->subtype)) {
return qt_typeLookup[i].pixelFormat;
}
}
@@ -198,6 +288,7 @@ int DirectShowMediaType::bytesPerLine(const QVideoSurfaceFormat &format)
{
switch (format.pixelFormat()) {
// 32 bpp packed formats.
+ case QVideoFrame::Format_ARGB32:
case QVideoFrame::Format_RGB32:
case QVideoFrame::Format_AYUV444:
return format.frameWidth() * 4;
@@ -240,8 +331,9 @@ QVideoSurfaceFormat::Direction DirectShowMediaType::scanLineDirection(QVideoFram
*/
switch (pixelFormat)
{
+ case QVideoFrame::Format_ARGB32:
case QVideoFrame::Format_RGB32:
- case QVideoFrame::Format_BGR24:
+ case QVideoFrame::Format_RGB24:
case QVideoFrame::Format_RGB565:
case QVideoFrame::Format_RGB555:
return bmiHeader.biHeight < 0
diff --git a/src/plugins/directshow/helpers/directshowmediatype.h b/src/plugins/directshow/helpers/directshowmediatype.h
index b2b074ccc..b9aa989f0 100644
--- a/src/plugins/directshow/helpers/directshowmediatype.h
+++ b/src/plugins/directshow/helpers/directshowmediatype.h
@@ -45,39 +45,48 @@
#include <qvideosurfaceformat.h>
#include <dvdmedia.h>
+#include <QtCore/qglobal.h>
QT_USE_NAMESPACE
-class DirectShowMediaType : public AM_MEDIA_TYPE
+class DirectShowMediaType
{
public:
- DirectShowMediaType() { init(this); }
- DirectShowMediaType(const AM_MEDIA_TYPE &type) { copy(this, type); }
- DirectShowMediaType(const DirectShowMediaType &other) { copy(this, other); }
- DirectShowMediaType &operator =(const AM_MEDIA_TYPE &type) {
- freeData(this); copy(this, type); return *this; }
- DirectShowMediaType &operator =(const DirectShowMediaType &other) {
- freeData(this); copy(this, other); return *this; }
- ~DirectShowMediaType() { freeData(this); }
+ DirectShowMediaType();
+ DirectShowMediaType(const DirectShowMediaType &other);
+ DirectShowMediaType(DirectShowMediaType &&other);
+ explicit DirectShowMediaType(const AM_MEDIA_TYPE &type);
+ explicit DirectShowMediaType(AM_MEDIA_TYPE &&type);
+ ~DirectShowMediaType() { clear(mediaType); }
- void clear() { freeData(this); init(this); }
+ DirectShowMediaType &operator =(const DirectShowMediaType &other);
+ DirectShowMediaType &operator =(DirectShowMediaType &&other);
- bool isPartiallySpecified() const;
- bool isCompatibleWith(const DirectShowMediaType *type) const;
+ void clear() { clear(mediaType); }
+
+ inline AM_MEDIA_TYPE *operator &() Q_DECL_NOTHROW { return &mediaType; }
+ inline AM_MEDIA_TYPE *operator ->() Q_DECL_NOTHROW { return &mediaType; }
+
+ inline const AM_MEDIA_TYPE *const operator &() const Q_DECL_NOTHROW { return &mediaType; }
+ inline const AM_MEDIA_TYPE *const operator ->() const Q_DECL_NOTHROW { return &mediaType; }
static void init(AM_MEDIA_TYPE *type);
- static void copy(AM_MEDIA_TYPE *target, const AM_MEDIA_TYPE &source);
- static void freeData(AM_MEDIA_TYPE *type);
+ static void copy(AM_MEDIA_TYPE *target, const AM_MEDIA_TYPE *source);
+ static void move(AM_MEDIA_TYPE *target, AM_MEDIA_TYPE **source);
+ static void move(AM_MEDIA_TYPE *target, AM_MEDIA_TYPE &source);
+ static void clear(AM_MEDIA_TYPE &type);
static void deleteType(AM_MEDIA_TYPE *type);
-
+ static bool isPartiallySpecified(const AM_MEDIA_TYPE *mediaType);
+ static bool isCompatible(const AM_MEDIA_TYPE *a, const AM_MEDIA_TYPE *b);
static GUID convertPixelFormat(QVideoFrame::PixelFormat format);
- static QVideoSurfaceFormat formatFromType(const AM_MEDIA_TYPE &type);
- static QVideoFrame::PixelFormat pixelFormatFromType(const AM_MEDIA_TYPE &type);
+ static QVideoSurfaceFormat videoFormatFromType(const AM_MEDIA_TYPE *type);
+ static QVideoFrame::PixelFormat pixelFormatFromType(const AM_MEDIA_TYPE *type);
static int bytesPerLine(const QVideoSurfaceFormat &format);
+ static QVideoSurfaceFormat::Direction scanLineDirection(QVideoFrame::PixelFormat pixelFormat, const BITMAPINFOHEADER &bmiHeader);
private:
- static QVideoSurfaceFormat::Direction scanLineDirection(QVideoFrame::PixelFormat pixelFormat, const BITMAPINFOHEADER &bmiHeader);
+ AM_MEDIA_TYPE mediaType;
};
Q_DECLARE_TYPEINFO(DirectShowMediaType, Q_MOVABLE_TYPE);
diff --git a/src/plugins/directshow/helpers/directshowmediatypeenum.cpp b/src/plugins/directshow/helpers/directshowmediatypeenum.cpp
index a1c8b2306..a58993f7f 100644
--- a/src/plugins/directshow/helpers/directshowmediatypeenum.cpp
+++ b/src/plugins/directshow/helpers/directshowmediatypeenum.cpp
@@ -72,7 +72,7 @@ HRESULT DirectShowMediaTypeEnum::Next(ULONG cMediaTypes, AM_MEDIA_TYPE **ppMedia
for (ULONG i = 0; i < count; ++i, ++m_index) {
ppMediaTypes[i] = reinterpret_cast<AM_MEDIA_TYPE *>(CoTaskMemAlloc(sizeof(AM_MEDIA_TYPE)));
- DirectShowMediaType::copy(ppMediaTypes[i], m_mediaTypes.at(m_index));
+ DirectShowMediaType::copy(ppMediaTypes[i], &m_mediaTypes.at(m_index));
}
if (pcFetched)
diff --git a/src/plugins/directshow/helpers/directshowpin.cpp b/src/plugins/directshow/helpers/directshowpin.cpp
index 6cf4da321..f501747f9 100644
--- a/src/plugins/directshow/helpers/directshowpin.cpp
+++ b/src/plugins/directshow/helpers/directshowpin.cpp
@@ -81,22 +81,20 @@ HRESULT DirectShowPin::Connect(IPin *pReceivePin, const AM_MEDIA_TYPE *pmt)
if (pd == m_direction)
return VFW_E_INVALID_DIRECTION;
- const DirectShowMediaType *type = reinterpret_cast<const DirectShowMediaType*>(pmt);
-
- if (type != NULL && !type->isPartiallySpecified()) {
+ if (pmt != NULL && DirectShowMediaType::isPartiallySpecified(pmt)) {
// If the type is fully specified, use it
- hr = tryConnect(pReceivePin, type);
+ hr = tryConnect(pReceivePin, pmt);
} else {
IEnumMediaTypes *enumMediaTypes = NULL;
// First, try the receiving pin's preferred types
if (SUCCEEDED(pReceivePin->EnumMediaTypes(&enumMediaTypes))) {
- hr = tryMediaTypes(pReceivePin, type, enumMediaTypes);
+ hr = tryMediaTypes(pReceivePin, pmt, enumMediaTypes);
enumMediaTypes->Release();
}
// Then, try this pin's preferred types
if (FAILED(hr) && SUCCEEDED(EnumMediaTypes(&enumMediaTypes))) {
- hr = tryMediaTypes(pReceivePin, type, enumMediaTypes);
+ hr = tryMediaTypes(pReceivePin, pmt, enumMediaTypes);
enumMediaTypes->Release();
}
}
@@ -109,19 +107,19 @@ HRESULT DirectShowPin::Connect(IPin *pReceivePin, const AM_MEDIA_TYPE *pmt)
return S_OK;
}
-HRESULT DirectShowPin::tryMediaTypes(IPin *pin, const DirectShowMediaType *partialType, IEnumMediaTypes *enumMediaTypes)
+HRESULT DirectShowPin::tryMediaTypes(IPin *pin, const AM_MEDIA_TYPE *partialType, IEnumMediaTypes *enumMediaTypes)
{
HRESULT hr = enumMediaTypes->Reset();
if (FAILED(hr))
return hr;
- DirectShowMediaType *mediaType = NULL;
+ AM_MEDIA_TYPE *mediaType = NULL;
ULONG mediaCount = 0;
HRESULT hrFailure = VFW_E_NO_ACCEPTABLE_TYPES;
- for (; enumMediaTypes->Next(1, reinterpret_cast<AM_MEDIA_TYPE**>(&mediaType), &mediaCount) == S_OK;) {
+ for (; enumMediaTypes->Next(1, &mediaType, &mediaCount) == S_OK;) {
- if (mediaType && (partialType == NULL || mediaType->isCompatibleWith(partialType))) {
+ if (mediaType && (partialType == NULL || DirectShowMediaType::isCompatible(mediaType, partialType))) {
hr = tryConnect(pin, mediaType);
if (FAILED(hr) && (hr != E_FAIL)
@@ -141,7 +139,7 @@ HRESULT DirectShowPin::tryMediaTypes(IPin *pin, const DirectShowMediaType *parti
return hrFailure;
}
-HRESULT DirectShowPin::tryConnect(IPin *pin, const DirectShowMediaType *type)
+HRESULT DirectShowPin::tryConnect(IPin *pin, const AM_MEDIA_TYPE *type)
{
if (!isMediaTypeSupported(type))
return VFW_E_TYPE_NOT_ACCEPTED;
@@ -189,15 +187,14 @@ HRESULT DirectShowPin::ReceiveConnection(IPin *pConnector, const AM_MEDIA_TYPE *
if (pd == m_direction)
return VFW_E_INVALID_DIRECTION;
- const DirectShowMediaType *type = reinterpret_cast<const DirectShowMediaType*>(pmt);
- if (!isMediaTypeSupported(type))
+ if (!isMediaTypeSupported(pmt))
return VFW_E_TYPE_NOT_ACCEPTED;
m_peerPin = pConnector;
m_peerPin->AddRef();
HRESULT hr;
- if (!setMediaType(type))
+ if (!setMediaType(pmt))
hr = VFW_E_TYPE_NOT_ACCEPTED;
else
hr = completeConnection(pConnector);
@@ -265,7 +262,7 @@ HRESULT DirectShowPin::ConnectionMediaType(AM_MEDIA_TYPE *pmt)
DirectShowMediaType::init(pmt);
return VFW_E_NOT_CONNECTED;
} else {
- DirectShowMediaType::copy(pmt, m_mediaType);
+ DirectShowMediaType::copy(pmt, &m_mediaType);
return S_OK;
}
}
@@ -309,7 +306,7 @@ HRESULT DirectShowPin::QueryAccept(const AM_MEDIA_TYPE *pmt)
if (!pmt)
return E_POINTER;
- if (!isMediaTypeSupported(reinterpret_cast<const DirectShowMediaType*>(pmt)))
+ if (!isMediaTypeSupported(pmt))
return S_FALSE;
return S_OK;
@@ -370,12 +367,12 @@ QList<DirectShowMediaType> DirectShowPin::supportedMediaTypes()
return QList<DirectShowMediaType>();
}
-bool DirectShowPin::setMediaType(const DirectShowMediaType *type)
+bool DirectShowPin::setMediaType(const AM_MEDIA_TYPE *type)
{
if (!type)
m_mediaType.clear();
else
- m_mediaType = *type;
+ DirectShowMediaType::copy(&m_mediaType, type);
return true;
}
@@ -673,7 +670,7 @@ HRESULT DirectShowInputPin::Receive(IMediaSample *pSample)
if (!(m_sampleProperties.dwSampleFlags & AM_SAMPLE_TYPECHANGED))
return S_OK;
- if (isMediaTypeSupported(reinterpret_cast<DirectShowMediaType*>(m_sampleProperties.pMediaType)))
+ if (isMediaTypeSupported(m_sampleProperties.pMediaType))
return S_OK;
m_inErrorState = true;
diff --git a/src/plugins/directshow/helpers/directshowpin.h b/src/plugins/directshow/helpers/directshowpin.h
index 823223956..b8207abae 100644
--- a/src/plugins/directshow/helpers/directshowpin.h
+++ b/src/plugins/directshow/helpers/directshowpin.h
@@ -55,9 +55,9 @@ public:
QString name() const { return m_name; }
bool isConnected() const { return m_peerPin != NULL; }
- virtual bool isMediaTypeSupported(const DirectShowMediaType *type) = 0;
+ virtual bool isMediaTypeSupported(const AM_MEDIA_TYPE *type) = 0;
virtual QList<DirectShowMediaType> supportedMediaTypes();
- virtual bool setMediaType(const DirectShowMediaType *type);
+ virtual bool setMediaType(const AM_MEDIA_TYPE *type);
virtual HRESULT completeConnection(IPin *pin);
virtual HRESULT connectionEnded();
@@ -107,8 +107,8 @@ protected:
private:
Q_DISABLE_COPY(DirectShowPin)
- HRESULT tryMediaTypes(IPin *pin, const DirectShowMediaType *type, IEnumMediaTypes *enumMediaTypes);
- HRESULT tryConnect(IPin *pin, const DirectShowMediaType *type);
+ HRESULT tryMediaTypes(IPin *pin, const AM_MEDIA_TYPE *type, IEnumMediaTypes *enumMediaTypes);
+ HRESULT tryConnect(IPin *pin, const AM_MEDIA_TYPE *type);
};
diff --git a/src/plugins/directshow/player/directshowiosource.cpp b/src/plugins/directshow/player/directshowiosource.cpp
index 3c44dd1ed..96b4b14bf 100644
--- a/src/plugins/directshow/player/directshowiosource.cpp
+++ b/src/plugins/directshow/player/directshowiosource.cpp
@@ -82,7 +82,7 @@ DirectShowIOSource::DirectShowIOSource(DirectShowEventLoop *loop)
// The filter works in pull mode, the downstream filter is responsible for requesting
// samples from this one.
//
- AM_MEDIA_TYPE type =
+ AM_MEDIA_TYPE type
{
MEDIATYPE_Stream, // majortype
MEDIASUBTYPE_NULL, // subtype
@@ -99,7 +99,7 @@ DirectShowIOSource::DirectShowIOSource(DirectShowEventLoop *loop)
for (int i = 0; i < count; ++i) {
type.subtype = directshow_subtypes[i];
- m_supportedMediaTypes.append(type);
+ m_supportedMediaTypes.append(DirectShowMediaType(type));
}
}
@@ -371,12 +371,12 @@ HRESULT DirectShowIOSource::Connect(IPin *pReceivePin, const AM_MEDIA_TYPE *pmt)
hr = pReceivePin->ReceiveConnection(this, pmt);
// Update the media type for the current connection.
if (SUCCEEDED(hr))
- m_connectionMediaType = *pmt;
+ DirectShowMediaType::copy(&m_connectionMediaType, pmt);
} else if (pmt && pmt->subtype == MEDIATYPE_NULL) { // - Partial type (Stream, but no subtype specified).
- m_connectionMediaType = *pmt;
+ DirectShowMediaType::copy(&m_connectionMediaType, pmt);
// Check if the receiving pin accepts any of the streaming subtypes.
for (const DirectShowMediaType &t : qAsConst(m_supportedMediaTypes)) {
- m_connectionMediaType.subtype = t.subtype;
+ m_connectionMediaType->subtype = t->subtype;
hr = pReceivePin->ReceiveConnection(this, &m_connectionMediaType);
if (SUCCEEDED(hr))
break;
@@ -477,7 +477,7 @@ HRESULT DirectShowIOSource::ConnectionMediaType(AM_MEDIA_TYPE *pmt)
return VFW_E_NOT_CONNECTED;
} else {
- DirectShowMediaType::copy(pmt, m_connectionMediaType);
+ DirectShowMediaType::copy(pmt, &m_connectionMediaType);
return S_OK;
}
diff --git a/src/plugins/directshow/player/directshowplayerservice.cpp b/src/plugins/directshow/player/directshowplayerservice.cpp
index 1502c6df3..0b88496af 100644
--- a/src/plugins/directshow/player/directshowplayerservice.cpp
+++ b/src/plugins/directshow/player/directshowplayerservice.cpp
@@ -627,13 +627,13 @@ int DirectShowPlayerService::findStreamTypes(IBaseFilter *source) const
for (IPin *pin = 0; pins->Next(1, &pin, 0) == S_OK; pin->Release()) {
PIN_DIRECTION direction;
if (pin->QueryDirection(&direction) == S_OK && direction == PINDIR_OUTPUT) {
- AM_MEDIA_TYPE connectionType;
+ DirectShowMediaType connectionType;
if (SUCCEEDED(pin->ConnectionMediaType(&connectionType))) {
IPin *peer = 0;
- if (connectionType.majortype == MEDIATYPE_Audio) {
+ if (connectionType->majortype == MEDIATYPE_Audio) {
streamTypes |= AudioStream;
- } else if (connectionType.majortype == MEDIATYPE_Video) {
+ } else if (connectionType->majortype == MEDIATYPE_Video) {
streamTypes |= VideoStream;
} else if (SUCCEEDED(pin->ConnectedTo(&peer))) {
PIN_INFO peerInfo;
diff --git a/src/plugins/directshow/player/videosurfacefilter.cpp b/src/plugins/directshow/player/videosurfacefilter.cpp
index 4cb97be39..13f767a85 100644
--- a/src/plugins/directshow/player/videosurfacefilter.cpp
+++ b/src/plugins/directshow/player/videosurfacefilter.cpp
@@ -63,8 +63,8 @@ public:
VideoSurfaceInputPin(VideoSurfaceFilter *filter);
// DirectShowPin
- bool isMediaTypeSupported(const DirectShowMediaType *type);
- bool setMediaType(const DirectShowMediaType *type);
+ bool isMediaTypeSupported(const AM_MEDIA_TYPE *type) override;
+ bool setMediaType(const AM_MEDIA_TYPE *type) override;
HRESULT completeConnection(IPin *pin);
HRESULT connectionEnded();
@@ -90,12 +90,12 @@ VideoSurfaceInputPin::VideoSurfaceInputPin(VideoSurfaceFilter *filter)
{
}
-bool VideoSurfaceInputPin::isMediaTypeSupported(const DirectShowMediaType *type)
+bool VideoSurfaceInputPin::isMediaTypeSupported(const AM_MEDIA_TYPE *type)
{
return m_videoSurfaceFilter->isMediaTypeSupported(type);
}
-bool VideoSurfaceInputPin::setMediaType(const DirectShowMediaType *type)
+bool VideoSurfaceInputPin::setMediaType(const AM_MEDIA_TYPE *type)
{
if (!DirectShowInputPin::setMediaType(type))
return false;
@@ -282,7 +282,7 @@ void VideoSurfaceFilter::supportedFormatsChanged()
}
}
-bool VideoSurfaceFilter::isMediaTypeSupported(const DirectShowMediaType *type)
+bool VideoSurfaceFilter::isMediaTypeSupported(const AM_MEDIA_TYPE *type)
{
if (type->majortype != MEDIATYPE_Video || type->bFixedSizeSamples == FALSE)
return false;
@@ -297,7 +297,7 @@ bool VideoSurfaceFilter::isMediaTypeSupported(const DirectShowMediaType *type)
return false;
}
-bool VideoSurfaceFilter::setMediaType(const DirectShowMediaType *type)
+bool VideoSurfaceFilter::setMediaType(const AM_MEDIA_TYPE *type)
{
if (!type) {
qCDebug(qLcRenderFilter, "clear media type");
@@ -305,7 +305,7 @@ bool VideoSurfaceFilter::setMediaType(const DirectShowMediaType *type)
m_bytesPerLine = 0;
return true;
} else {
- m_surfaceFormat = DirectShowMediaType::formatFromType(*type);
+ m_surfaceFormat = DirectShowMediaType::videoFormatFromType(type);
m_bytesPerLine = DirectShowMediaType::bytesPerLine(m_surfaceFormat);
qCDebug(qLcRenderFilter) << "setMediaType -->" << m_surfaceFormat;
return m_surfaceFormat.isValid();
@@ -478,7 +478,7 @@ HRESULT VideoSurfaceFilter::Receive(IMediaSample *pMediaSample)
// If the format dynamically changed, the sample contains information about the new format.
// We need to reset the format and restart the QAbstractVideoSurface.
if (m_pin->currentSampleProperties()->pMediaType
- && (!m_pin->setMediaType(reinterpret_cast<const DirectShowMediaType *>(m_pin->currentSampleProperties()->pMediaType))
+ && (!m_pin->setMediaType(m_pin->currentSampleProperties()->pMediaType)
|| !restartSurface())) {
qCWarning(qLcRenderFilter, " dynamic format change failed, aborting rendering");
NotifyEvent(EC_ERRORABORT, VFW_E_TYPE_NOT_ACCEPTED, 0);
diff --git a/src/plugins/directshow/player/videosurfacefilter.h b/src/plugins/directshow/player/videosurfacefilter.h
index 581e33c70..6d6cc7593 100644
--- a/src/plugins/directshow/player/videosurfacefilter.h
+++ b/src/plugins/directshow/player/videosurfacefilter.h
@@ -83,8 +83,8 @@ public:
STDMETHODIMP_(ULONG) GetMiscFlags();
// DirectShowPin (delegate)
- bool isMediaTypeSupported(const DirectShowMediaType *type);
- bool setMediaType(const DirectShowMediaType *type);
+ bool isMediaTypeSupported(const AM_MEDIA_TYPE *type);
+ bool setMediaType(const AM_MEDIA_TYPE *type);
HRESULT completeConnection(IPin *pin);
HRESULT connectionEnded();