gstreamer/sys/mediafoundation/mediacapturewrapper.h

180 lines
5.7 KiB
C
Raw Normal View History

/* GStreamer
* Copyright (C) 2020 Seungha Yang <seungha@centricular.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* 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
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#ifndef __GST_MEDIA_CAPTURE_WRAPPER_H__
#define __GST_MEDIA_CAPTURE_WRAPPER_H__
#include <gst/gst.h>
#include <wrl.h>
#include <wrl/wrappers/corewrappers.h>
#include <windows.media.capture.h>
#include <vector>
#include <memory>
#include <string>
#include <functional>
#include <mutex>
#include <condition_variable>
using namespace Microsoft::WRL;
using namespace Microsoft::WRL::Wrappers;
using namespace ABI::Windows::Foundation;
using namespace ABI::Windows::UI::Core;
using namespace ABI::Windows::Media::Capture;
using namespace ABI::Windows::Media::Capture::Frames;
using namespace ABI::Windows::Graphics::Imaging;
/* Store Format info and its caps representation */
class GstWinRTMediaDescription
{
public:
GstWinRTMediaDescription();
GstWinRTMediaDescription(const GstWinRTMediaDescription& other);
~GstWinRTMediaDescription();
void Release();
bool IsValid() const;
HRESULT Fill(HString &source_id,
const ComPtr<IMediaCaptureVideoProfileMediaDescription>& desc,
unsigned int info_index,
unsigned int desc_index);
GstWinRTMediaDescription& operator=(const GstWinRTMediaDescription& rhs)
{
if (this == &rhs)
return *this;
Release();
if (rhs.source_id_.IsValid())
rhs.source_id_.CopyTo(source_id_.GetAddressOf());
if (rhs.subtype_.IsValid())
rhs.subtype_.CopyTo(subtype_.GetAddressOf());
gst_caps_replace (&caps_, rhs.caps_);
return *this;
}
public:
HString source_id_;
/* TODO: need to cover audio too */
HString subtype_;
/* Source ID which is mapped to MediaFormatSource */
GstCaps *caps_;
};
/* holds GstWinRTMediaFrameSourceInfo, corresponding to per device info */
class GstWinRTMediaFrameSourceGroup
{
public:
GstWinRTMediaFrameSourceGroup();
GstWinRTMediaFrameSourceGroup(const GstWinRTMediaFrameSourceGroup& other);
~GstWinRTMediaFrameSourceGroup();
void Release();
bool Contain(const GstWinRTMediaDescription &desc);
HRESULT Fill(const ComPtr<IMediaFrameSourceGroup> &source_group,
unsigned int index);
GstWinRTMediaFrameSourceGroup& operator=(const GstWinRTMediaFrameSourceGroup& rhs)
{
if (this == &rhs)
return *this;
Release();
id_ = rhs.id_;
display_name_ = rhs.display_name_;
source_group_ = rhs.source_group_;
source_list_ = rhs.source_list_;
return *this;
}
public:
std::string id_;
std::string display_name_;
ComPtr<IMediaFrameSourceGroup> source_group_;
std::vector<GstWinRTMediaDescription> source_list_;
};
typedef struct
{
HRESULT (*frame_arrived) (IMediaFrameReference * frame,
void * user_data);
HRESULT (*failed) (const std::string &error,
UINT32 error_code,
void * user_data);
} MediaCaptureWrapperCallbacks;
class MediaCaptureWrapper
{
public:
MediaCaptureWrapper(gpointer dispatcher);
~MediaCaptureWrapper();
void RegisterCb(const MediaCaptureWrapperCallbacks &cb,
void * user_data);
/* Enumerating available source devices */
/* Fill enumerated device infos into list */
HRESULT EnumrateFrameSourceGroup(std::vector<GstWinRTMediaFrameSourceGroup> &group_list);
/* Select target device which should be one of enumerated be fore */
HRESULT SetSourceGroup(const GstWinRTMediaFrameSourceGroup &group);
/* Select target format (resolution, video format) to use */
HRESULT SetMediaDescription(const GstWinRTMediaDescription &desc);
/* Start and Stop capturing operation */
HRESULT StartCapture();
HRESULT StopCapture();
HRESULT GetAvailableDescriptions(std::vector<GstWinRTMediaDescription> &desc_list);
private:
ComPtr<IMediaCapture> media_capture_;
ComPtr<IMediaFrameReader> frame_reader_;
ComPtr<ICoreDispatcher> dispatcher_;
bool init_done_;
std::mutex lock_;
std::condition_variable cond_;
EventRegistrationToken token_frame_arrived_;
EventRegistrationToken token_capture_failed_;
std::unique_ptr<GstWinRTMediaFrameSourceGroup> source_group_;
std::unique_ptr<GstWinRTMediaDescription> media_desc_;
MediaCaptureWrapperCallbacks user_cb_;
void *user_data_;
private:
HRESULT openMediaCapture();
HRESULT mediaCaptureInitPre();
HRESULT mediaCaptureInitPost(ComPtr<IAsyncAction> init_async,
ComPtr<IMediaCapture> media_capture);
HRESULT startCapture();
HRESULT stopCapture();
HRESULT onFrameArrived(IMediaFrameReader *reader,
IMediaFrameArrivedEventArgs *args);
HRESULT onCaptureFailed(IMediaCapture *capture,
IMediaCaptureFailedEventArgs *args);
static HRESULT enumrateFrameSourceGroup(std::vector<GstWinRTMediaFrameSourceGroup> &list);
};
HRESULT
FindCoreDispatcherForCurrentThread(ICoreDispatcher ** dispatcher);
bool
WinRTCapsCompareFunc(const GstWinRTMediaDescription & a,
const GstWinRTMediaDescription & b);
#endif /* __GST_MEDIA_CAPTURE_WRAPPER_H__ */