Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1596>
} GstMFAacEncClassData;
/* *INDENT-ON* */
-static GstElementClass *parent_class = NULL;
+static GstElementClass *parent_class = nullptr;
static void gst_mf_aac_enc_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec);
{
GstMFAacEnc *self = (GstMFAacEnc *) mfenc;
GstMFTransform *transform = mfenc->transform;
- GList *output_list = NULL;
+ GList *output_list = nullptr;
GList *iter;
ComPtr < IMFMediaType > target_output;
std::vector < ComPtr < IMFMediaType >> filtered_types;
{
GstMFAacEnc *self = (GstMFAacEnc *) mfenc;
GstMFTransform *transform = mfenc->transform;
- GList *input_list = NULL;
+ GList *input_list = nullptr;
GList *iter;
ComPtr < IMFMediaType > target_input;
std::vector < ComPtr < IMFMediaType >> filtered_types;
HRESULT hr;
GstCaps *src_caps;
GstBuffer *codec_data;
- UINT8 *blob = NULL;
+ UINT8 *blob = nullptr;
UINT32 blob_size = 0;
gboolean ret;
ComPtr < IMFMediaType > output_type;
"channels", G_TYPE_INT, GST_AUDIO_INFO_CHANNELS (info),
"rate", G_TYPE_INT, GST_AUDIO_INFO_RATE (info),
"framed", G_TYPE_BOOLEAN, TRUE,
- "codec_data", GST_TYPE_BUFFER, codec_data, NULL);
+ "codec_data", GST_TYPE_BUFFER, codec_data, nullptr);
gst_buffer_unref (codec_data);
gst_codec_utils_aac_caps_set_level_and_profile (src_caps,
gboolean is_default = TRUE;
GTypeInfo type_info = {
sizeof (GstMFAacEncClass),
- NULL,
- NULL,
+ nullptr,
+ nullptr,
(GClassInitFunc) gst_mf_aac_enc_class_init,
- NULL,
- NULL,
+ nullptr,
+ nullptr,
sizeof (GstMFAacEnc),
0,
(GInstanceInitFunc) gst_mf_aac_enc_init,
{
HRESULT hr;
gint i;
- GstCaps *src_caps = NULL;
- GstCaps *sink_caps = NULL;
- gchar *device_name = NULL;
- GList *output_list = NULL;
+ GstCaps *src_caps = nullptr;
+ GstCaps *sink_caps = nullptr;
+ gchar *device_name = nullptr;
+ GList *output_list = nullptr;
GList *iter;
std::set < UINT32 > channels_list;
std::set < UINT32 > rate_list;
if (!gst_mf_transform_open (transform))
return;
- g_object_get (transform, "device-name", &device_name, NULL);
+ g_object_get (transform, "device-name", &device_name, nullptr);
if (!device_name) {
GST_WARNING_OBJECT (transform, "Unknown device name");
return;
return FALSE;
}
- g_assert (klass->get_output_type != NULL);
+ g_assert (klass->get_output_type != nullptr);
if (!klass->get_output_type (self, info, &out_type)) {
GST_ERROR_OBJECT (self, "subclass failed to set output type");
return FALSE;
return FALSE;
}
- g_assert (klass->get_input_type != NULL);
+ g_assert (klass->get_input_type != nullptr);
if (!klass->get_input_type (self, info, &in_type)) {
GST_ERROR_OBJECT (self, "subclass didn't provide input type");
return FALSE;
return FALSE;
}
- g_assert (klass->set_src_caps != NULL);
+ g_assert (klass->set_src_caps != nullptr);
if (!klass->set_src_caps (self, info))
return FALSE;
if (!gst_buffer_map (buffer, &info, GST_MAP_READ)) {
GST_ELEMENT_ERROR (self,
- RESOURCE, READ, ("Couldn't map input buffer"), (NULL));
+ RESOURCE, READ, ("Couldn't map input buffer"), (nullptr));
return FALSE;
}
if (!gst_mf_result (hr))
goto done;
- hr = media_buffer->Lock (&data, NULL, NULL);
+ hr = media_buffer->Lock (&data, nullptr, nullptr);
if (!gst_mf_result (hr))
goto done;
if (!gst_mf_result (hr))
return GST_FLOW_ERROR;
- hr = media_buffer->Lock (&data, NULL, &buffer_len);
+ hr = media_buffer->Lock (&data, nullptr, &buffer_len);
if (!gst_mf_result (hr))
return GST_FLOW_ERROR;
using namespace ABI::Windows::Media::MediaProperties;
using namespace ABI::Windows::Graphics::Imaging;
using namespace ABI::Windows::Foundation;
-
-G_BEGIN_DECLS
+/* *INDENT-ON* */
GST_DEBUG_CATEGORY_EXTERN (gst_mf_source_object_debug);
#define GST_CAT_DEFAULT gst_mf_source_object_debug
-G_END_DECLS
-/* *INDENT-ON* */
enum
{
idle_source = g_idle_source_new ();
g_source_set_callback (idle_source,
- (GSourceFunc) gst_mf_capture_winrt_main_loop_running_cb, self, NULL);
+ (GSourceFunc) gst_mf_capture_winrt_main_loop_running_cb, self, nullptr);
g_source_attach (idle_source, self->context);
g_source_unref (idle_source);
gst_mf_capture_winrt_stop (source);
delete self->capture;
- self->capture = NULL;
+ self->capture = nullptr;
- return NULL;
+ return nullptr;
}
static gboolean
if (self->supported_caps)
return gst_caps_ref (self->supported_caps);
- return NULL;
+ return nullptr;
}
/* *INDENT-OFF* */
GstMFCaptureWinRT *self = GST_MF_CAPTURE_WINRT (object);
std::vector<GstWinRTMediaDescription> desc_list;
HRESULT hr;
- GstCaps *target_caps = NULL;
+ GstCaps *target_caps = nullptr;
hr = self->capture->GetAvailableDescriptions(desc_list);
if (!gst_mf_result (hr) || desc_list.empty()) {
RoInitializeWrapper init_wrapper (RO_INIT_MULTITHREADED);
/* TODO: Add audio capture support */
- g_return_val_if_fail (type == GST_MF_SOURCE_TYPE_VIDEO, NULL);
+ g_return_val_if_fail (type == GST_MF_SOURCE_TYPE_VIDEO, nullptr);
/* If application didn't pass ICoreDispatcher object,
* try to get dispatcher object for the current thread */
self = (GstMFSourceObject *) g_object_new (GST_TYPE_MF_CAPTURE_WINRT,
"source-type", type, "device-index", device_index, "device-name",
- device_name, "device-path", device_path, "dispatcher", dispatcher, NULL);
+ device_name, "device-path", device_path, "dispatcher", dispatcher,
+ nullptr);
/* Reset explicitly to ensure that it happens before
* RoInitializeWrapper dtor is called */
if (!self->opened) {
GST_WARNING_OBJECT (self, "Couldn't open device");
gst_object_unref (self);
- return NULL;
+ return nullptr;
}
gst_object_ref_sink (self);
#if GST_MF_WINAPI_APP
#include <gst/winrt/gstwinrt.h>
+/* *INDENT-OFF* */
+using namespace ABI::Windows::Devices::Enumeration;
+/* *INDENT-ON* */
#endif
GST_DEBUG_CATEGORY_EXTERN (gst_mf_debug);
g_object_class_install_property (gobject_class, PROP_DEVICE_PATH,
g_param_spec_string ("device-path", "Device Path",
- "The device path", NULL,
- G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS));
+ "The device path", nullptr,
+ (GParamFlags) (G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY |
+ G_PARAM_STATIC_STRINGS)));
}
static void
elem = gst_element_factory_make ("mfvideosrc", name);
- g_object_set (elem, "device-path", self->device_path, NULL);
+ g_object_set (elem, "device-path", self->device_path, nullptr);
return elem;
}
static gboolean gst_mf_device_provider_start_winrt (GstDeviceProvider * self);
static void
gst_mf_device_provider_device_added (GstWinRTDeviceWatcher * watcher,
- __x_ABI_CWindows_CDevices_CEnumeration_CIDeviceInformation * info,
- gpointer user_data);
+ IDeviceInformation * info, gpointer user_data);
static void
gst_mf_device_provider_device_updated (GstWinRTDeviceWatcher * watcher,
- __x_ABI_CWindows_CDevices_CEnumeration_CIDeviceInformationUpdate *
- info_update, gpointer user_data);
+ IDeviceInformationUpdate * info_update, gpointer user_data);
static void gst_mf_device_provider_device_removed (GstWinRTDeviceWatcher *
- watcher,
- __x_ABI_CWindows_CDevices_CEnumeration_CIDeviceInformationUpdate *
- info_update, gpointer user_data);
+ watcher, IDeviceInformationUpdate * info_update, gpointer user_data);
static void
gst_mf_device_provider_device_enum_completed (GstWinRTDeviceWatcher *
watcher, gpointer user_data);
gst_mf_device_provider_probe (GstDeviceProvider * provider)
{
GstMFDeviceProvider *self = GST_MF_DEVICE_PROVIDER (provider);
- GList *list = NULL;
+ GList *list = nullptr;
gint i;
for (i = 0;; i++) {
- GstMFSourceObject *obj = NULL;
+ GstMFSourceObject *obj = nullptr;
GstDevice *device;
- GstStructure *props = NULL;
- GstCaps *caps = NULL;
- gchar *device_name = NULL;
- gchar *device_path = NULL;
+ GstStructure *props = nullptr;
+ GstCaps *caps = nullptr;
+ gchar *device_name = nullptr;
+ gchar *device_path = nullptr;
obj = gst_mf_source_object_new (GST_MF_SOURCE_TYPE_VIDEO,
- i, NULL, NULL, NULL);
+ i, nullptr, nullptr, nullptr);
if (!obj)
break;
}
g_object_get (obj,
- "device-path", &device_path, "device-name", &device_name, NULL);
+ "device-path", &device_path, "device-name", &device_name, nullptr);
if (!device_path) {
GST_WARNING_OBJECT (self, "Device path is unavailable");
props = gst_structure_new ("mf-proplist",
"device.api", G_TYPE_STRING, "mediafoundation",
"device.path", G_TYPE_STRING, device_path,
- "device.name", G_TYPE_STRING, device_name, NULL);
+ "device.name", G_TYPE_STRING, device_name, nullptr);
- device = g_object_new (GST_TYPE_MF_DEVICE, "device-path", device_path,
+ device = (GstDevice *) g_object_new (GST_TYPE_MF_DEVICE,
+ "device-path", device_path,
"display-name", device_name, "caps", caps,
- "device-class", "Source/Video", "properties", props, NULL);
+ "device-class", "Source/Video", "properties", props, nullptr);
list = g_list_append (list, device);
{
GstMFDeviceProvider *self = GST_MF_DEVICE_PROVIDER (provider);
GstWin32DeviceWatcher *watcher;
- GList *devices = NULL;
+ GList *devices = nullptr;
GList *iter;
if (!GST_IS_WIN32_DEVICE_WATCHER (self->watcher))
{
GstMFDeviceProvider *self = GST_MF_DEVICE_PROVIDER (provider);
GstWinRTDeviceWatcher *watcher;
- GList *devices = NULL;
+ GList *devices = nullptr;
GList *iter;
if (!GST_IS_WINRT_DEVICE_WATCHER (self->watcher))
gst_mf_device_provider_update_devices (GstMFDeviceProvider * self)
{
GstDeviceProvider *provider = GST_DEVICE_PROVIDER_CAST (self);
- GList *prev_devices = NULL;
- GList *new_devices = NULL;
- GList *to_add = NULL;
- GList *to_remove = NULL;
+ GList *prev_devices = nullptr;
+ GList *new_devices = nullptr;
+ GList *to_add = nullptr;
+ GList *to_remove = nullptr;
GList *iter;
GST_OBJECT_LOCK (self);
prev_devices = g_list_copy_deep (provider->devices,
- (GCopyFunc) gst_object_ref, NULL);
+ (GCopyFunc) gst_object_ref, nullptr);
GST_OBJECT_UNLOCK (self);
new_devices = gst_mf_device_provider_probe (provider);
#if GST_MF_WINAPI_APP
static void
gst_mf_device_provider_device_added (GstWinRTDeviceWatcher * watcher,
- __x_ABI_CWindows_CDevices_CEnumeration_CIDeviceInformation * info,
- gpointer user_data)
+ IDeviceInformation * info, gpointer user_data)
{
GstMFDeviceProvider *self = GST_MF_DEVICE_PROVIDER (user_data);
static void
gst_mf_device_provider_device_removed (GstWinRTDeviceWatcher * watcher,
- __x_ABI_CWindows_CDevices_CEnumeration_CIDeviceInformationUpdate *
- info_update, gpointer user_data)
+ IDeviceInformationUpdate * info_update, gpointer user_data)
{
GstMFDeviceProvider *self = GST_MF_DEVICE_PROVIDER (user_data);
static void
gst_mf_device_provider_device_updated (GstWinRTDeviceWatcher * watcher,
- __x_ABI_CWindows_CDevices_CEnumeration_CIDeviceInformationUpdate *
- info_update, gpointer user_data)
+ IDeviceInformationUpdate * info_update, gpointer user_data)
{
GstMFDeviceProvider *self = GST_MF_DEVICE_PROVIDER (user_data);
{GST_MF_H264_ENC_RC_MODE_UNCONSTRAINED_VBR,
"Unconstrained variable bitrate", "uvbr"},
{GST_MF_H264_ENC_RC_MODE_QUALITY, "Quality-based variable bitrate", "qvbr"},
- {0, NULL, NULL}
+ {0, nullptr, nullptr}
};
if (!rc_mode_type) {
{GST_MF_H264_ENC_ADAPTIVE_MODE_NONE, "None", "none"},
{GST_MF_H264_ENC_ADAPTIVE_MODE_FRAMERATE,
"Adaptively change the frame rate", "framerate"},
- {0, NULL, NULL}
+ {0, nullptr, nullptr}
};
if (!adaptive_mode_type) {
{GST_MF_H264_ENC_CONTENT_TYPE_UNKNOWN, "Unknown", "unknown"},
{GST_MF_H264_ENC_CONTENT_TYPE_FIXED_CAMERA_ANGLE,
"Fixed Camera Angle, such as a webcam", "fixed"},
- {0, NULL, NULL}
+ {0, nullptr, nullptr}
};
if (!content_type) {
GstMFVideoEncClass parent_class;
} GstMFH264EncClass;
-static GstElementClass *parent_class = NULL;
+static GstElementClass *parent_class = nullptr;
static void gst_mf_h264_enc_finalize (GObject * object);
static void gst_mf_h264_enc_get_property (GObject * object, guint prop_id,
gst_structure_set (s, "stream-format", G_TYPE_STRING, "byte-stream",
"alignment", G_TYPE_STRING, "au", "profile",
- G_TYPE_STRING, self->profile_str, NULL);
+ G_TYPE_STRING, self->profile_str, nullptr);
out_state = gst_video_encoder_set_output_state (GST_VIDEO_ENCODER (self),
out_caps, state);
tags = gst_tag_list_new_empty ();
gst_tag_list_add (tags, GST_TAG_MERGE_REPLACE, GST_TAG_ENCODER,
gst_element_get_metadata (GST_ELEMENT_CAST (self),
- GST_ELEMENT_METADATA_LONGNAME), NULL);
+ GST_ELEMENT_METADATA_LONGNAME), nullptr);
gst_video_encoder_merge_tags (GST_VIDEO_ENCODER (self), tags,
GST_TAG_MERGE_REPLACE);
gst_tag_list_unref (tags);
{
GTypeInfo type_info = {
sizeof (GstMFH264EncClass),
- NULL,
- NULL,
+ nullptr,
+ nullptr,
(GClassInitFunc) gst_mf_h264_enc_class_init,
- NULL,
- NULL,
+ nullptr,
+ nullptr,
sizeof (GstMFH264Enc),
0,
(GInstanceInitFunc) gst_mf_h264_enc_init,
static const GEnumValue rc_mode_types[] = {
{GST_MF_H265_ENC_RC_MODE_CBR, "Constant bitrate", "cbr"},
{GST_MF_H265_ENC_RC_MODE_QUALITY, "Quality-based variable bitrate", "qvbr"},
- {0, NULL, NULL}
+ {0, nullptr, nullptr}
};
if (!rc_mode_type) {
{GST_MF_H265_ENC_CONTENT_TYPE_UNKNOWN, "Unknown", "unknown"},
{GST_MF_H265_ENC_CONTENT_TYPE_FIXED_CAMERA_ANGLE,
"Fixed Camera Angle, such as a webcam", "fixed"},
- {0, NULL, NULL}
+ {0, nullptr, nullptr}
};
if (!content_type) {
GstMFVideoEncClass parent_class;
} GstMFH265EncClass;
-static GstElementClass *parent_class = NULL;
+static GstElementClass *parent_class = nullptr;
static void gst_mf_h265_enc_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec);
s = gst_caps_get_structure (out_caps, 0);
gst_structure_set (s, "stream-format", G_TYPE_STRING, "byte-stream",
- "alignment", G_TYPE_STRING, "au", NULL);
+ "alignment", G_TYPE_STRING, "au", nullptr);
if (GST_VIDEO_INFO_FORMAT (&mfenc->input_state->info) ==
GST_VIDEO_FORMAT_P010_10LE) {
- gst_structure_set (s, "profile", G_TYPE_STRING, "main-10", NULL);
+ gst_structure_set (s, "profile", G_TYPE_STRING, "main-10", nullptr);
} else {
- gst_structure_set (s, "profile", G_TYPE_STRING, "main", NULL);
+ gst_structure_set (s, "profile", G_TYPE_STRING, "main", nullptr);
}
out_state = gst_video_encoder_set_output_state (GST_VIDEO_ENCODER (self),
tags = gst_tag_list_new_empty ();
gst_tag_list_add (tags, GST_TAG_MERGE_REPLACE, GST_TAG_ENCODER,
gst_element_get_metadata (GST_ELEMENT_CAST (self),
- GST_ELEMENT_METADATA_LONGNAME), NULL);
+ GST_ELEMENT_METADATA_LONGNAME), nullptr);
gst_video_encoder_merge_tags (GST_VIDEO_ENCODER (self), tags,
GST_TAG_MERGE_REPLACE);
gst_tag_list_unref (tags);
{
GTypeInfo type_info = {
sizeof (GstMFH265EncClass),
- NULL,
- NULL,
+ nullptr,
+ nullptr,
(GClassInitFunc) gst_mf_h265_enc_class_init,
- NULL,
- NULL,
+ nullptr,
+ nullptr,
sizeof (GstMFH265Enc),
0,
(GInstanceInitFunc) gst_mf_h265_enc_init,
} GstMFMp3EncClassData;
/* *INDENT-ON* */
-static GstElementClass *parent_class = NULL;
+static GstElementClass *parent_class = nullptr;
static void gst_mf_mp3_enc_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec);
{
GstMFMp3Enc *self = (GstMFMp3Enc *) mfenc;
GstMFTransform *transform = mfenc->transform;
- GList *output_list = NULL;
+ GList *output_list = nullptr;
GList *iter;
ComPtr < IMFMediaType > target_output;
std::vector < ComPtr < IMFMediaType >> filtered_types;
{
GstMFMp3Enc *self = (GstMFMp3Enc *) mfenc;
GstMFTransform *transform = mfenc->transform;
- GList *input_list = NULL;
+ GList *input_list = nullptr;
GList *iter;
ComPtr < IMFMediaType > target_input;
std::vector < ComPtr < IMFMediaType >> filtered_types;
"mpegaudioversion", G_TYPE_INT, version,
"layer", G_TYPE_INT, 3,
"channels", G_TYPE_INT, GST_AUDIO_INFO_CHANNELS (info),
- "rate", G_TYPE_INT, GST_AUDIO_INFO_RATE (info), NULL);
+ "rate", G_TYPE_INT, GST_AUDIO_INFO_RATE (info), nullptr);
ret =
gst_audio_encoder_set_output_format (GST_AUDIO_ENCODER (self), src_caps);
gboolean is_default = TRUE;
GTypeInfo type_info = {
sizeof (GstMFMp3EncClass),
- NULL,
- NULL,
+ nullptr,
+ nullptr,
(GClassInitFunc) gst_mf_mp3_enc_class_init,
- NULL,
- NULL,
+ nullptr,
+ nullptr,
sizeof (GstMFMp3Enc),
0,
(GInstanceInitFunc) gst_mf_mp3_enc_init,
gst_mf_mp3_enc_create_template_caps (const std::set < UINT32 > &rate_list,
gint channels, GstCaps ** sink_caps, GstCaps ** src_caps)
{
- GstCaps *sink = NULL;
- GstCaps *src = NULL;
+ GstCaps *sink = nullptr;
+ GstCaps *src = nullptr;
GValue rate_value = G_VALUE_INIT;
if (rate_list.empty ()) {
gst_caps_from_string ("audio/mpeg, mpegversion = (int) 1,"
"layer = (int) 3");
- gst_caps_set_simple (sink, "channels", G_TYPE_INT, channels, NULL);
- gst_caps_set_simple (src, "channels", G_TYPE_INT, channels, NULL);
+ gst_caps_set_simple (sink, "channels", G_TYPE_INT, channels, nullptr);
+ gst_caps_set_simple (src, "channels", G_TYPE_INT, channels, nullptr);
} else {
sink =
gst_caps_from_string ("audio/x-raw, "
g_value_unset (&rate_value);
- if (*sink_caps == NULL)
+ if (*sink_caps == nullptr)
*sink_caps = sink;
else
*sink_caps = gst_caps_merge (*sink_caps, sink);
- if (*src_caps == NULL)
+ if (*src_caps == nullptr)
*src_caps = src;
else
*src_caps = gst_caps_merge (*src_caps, src);
{
HRESULT hr;
gint i;
- GstCaps *src_caps = NULL;
- GstCaps *sink_caps = NULL;
- gchar *device_name = NULL;
- GList *output_list = NULL;
+ GstCaps *src_caps = nullptr;
+ GstCaps *sink_caps = nullptr;
+ gchar *device_name = nullptr;
+ GList *output_list = nullptr;
GList *iter;
std::set < UINT32 > mono_rate_list;
std::set < UINT32 > stereo_rate_list;
if (!gst_mf_transform_open (transform))
return;
- g_object_get (transform, "device-name", &device_name, NULL);
+ g_object_get (transform, "device-name", &device_name, nullptr);
if (!device_name) {
GST_WARNING_OBJECT (transform, "Unknown device name");
return;
#include "gstmfconfig.h"
#include <gmodule.h>
-/* *INDENT-OFF* */
-G_BEGIN_DECLS
-
GST_DEBUG_CATEGORY_EXTERN (gst_mf_debug);
#define GST_CAT_DEFAULT gst_mf_debug
-G_END_DECLS
-
+/* *INDENT-OFF* */
#define LOAD_SYMBOL(name,func) G_STMT_START { \
if (!g_module_symbol (module, G_STRINGIFY (name), (gpointer *) &vtable->func)) { \
GST_WARNING ("Failed to load '%s', %s", G_STRINGIFY (name), g_module_error()); \
IMFAttributes * pAttributes, IMFActivate *** pppMFTActivate,
UINT32 * pnumMFTActivate)
{
- g_assert (gst_mf_plat_vtable.GstMFTEnum2 != NULL);
+ g_assert (gst_mf_plat_vtable.GstMFTEnum2 != nullptr);
return gst_mf_plat_vtable.GstMFTEnum2 (guidCategory, Flags, pInputType,
pOutputType, pAttributes, pppMFTActivate, pnumMFTActivate);
GstMFCreateDXGIDeviceManager (UINT * resetToken,
IMFDXGIDeviceManager ** ppDeviceManager)
{
- g_assert (gst_mf_plat_vtable.GstMFCreateDXGIDeviceManager != NULL);
+ g_assert (gst_mf_plat_vtable.GstMFCreateDXGIDeviceManager != nullptr);
return gst_mf_plat_vtable.GstMFCreateDXGIDeviceManager (resetToken,
ppDeviceManager);
HRESULT __stdcall
GstMFCreateVideoSampleAllocatorEx (REFIID riid, void **ppSampleAllocator)
{
- g_assert (gst_mf_plat_vtable.GstMFCreateVideoSampleAllocatorEx != NULL);
+ g_assert (gst_mf_plat_vtable.GstMFCreateVideoSampleAllocatorEx != nullptr);
return gst_mf_plat_vtable.GstMFCreateVideoSampleAllocatorEx (riid,
ppSampleAllocator);
PROP_SOURCE_TYPE,
};
-#define DEFAULT_DEVICE_PATH NULL
-#define DEFAULT_DEVICE_NAME NULL
+#define DEFAULT_DEVICE_PATH nullptr
+#define DEFAULT_DEVICE_NAME nullptr
#define DEFAULT_DEVICE_INDEX -1
#define DEFAULT_SOURCE_TYPE GST_MF_SOURCE_TYPE_VIDEO
static const GEnumValue source_types[] = {
{GST_MF_SOURCE_TYPE_VIDEO, "Video", "video"},
- {0, NULL, NULL}
+ {0, nullptr, nullptr}
};
if (!source_type) {
gst_mf_source_object_class_init (GstMFSourceObjectClass * klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+ GParamFlags flags =
+ (GParamFlags) (G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY |
+ G_PARAM_STATIC_STRINGS);
gobject_class->finalize = gst_mf_source_object_finalize;
gobject_class->get_property = gst_mf_source_object_get_property;
g_object_class_install_property (gobject_class, PROP_DEVICE_PATH,
g_param_spec_string ("device-path", "Device Path",
- "The device path", DEFAULT_DEVICE_PATH,
- G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS));
+ "The device path", DEFAULT_DEVICE_PATH, flags));
g_object_class_install_property (gobject_class, PROP_DEVICE_NAME,
g_param_spec_string ("device-name", "Device Name",
- "The human-readable device name", DEFAULT_DEVICE_NAME,
- G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS));
+ "The human-readable device name", DEFAULT_DEVICE_NAME, flags));
g_object_class_install_property (gobject_class, PROP_DEVICE_INDEX,
g_param_spec_int ("device-index", "Device Index",
"The zero-based device index", -1, G_MAXINT, DEFAULT_DEVICE_INDEX,
- G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS));
+ flags));
g_object_class_install_property (gobject_class, PROP_SOURCE_TYPE,
g_param_spec_enum ("source-type", "Source Type",
- "Source Type", GST_TYPE_MF_SOURCE_TYPE,
- DEFAULT_SOURCE_TYPE,
- G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS));
+ "Source Type", GST_TYPE_MF_SOURCE_TYPE, DEFAULT_SOURCE_TYPE, flags));
}
static void
self->device_index = DEFAULT_DEVICE_INDEX;
self->source_type = DEFAULT_SOURCE_TYPE;
- g_weak_ref_init (&self->client, NULL);
+ g_weak_ref_init (&self->client, nullptr);
}
static void
self->device_index = g_value_get_int (value);
break;
case PROP_SOURCE_TYPE:
- self->source_type = g_value_get_enum (value);
+ self->source_type = (GstMFSourceType) g_value_get_enum (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
g_return_val_if_fail (GST_IS_MF_SOURCE_OBJECT (object), FALSE);
klass = GST_MF_SOURCE_OBJECT_GET_CLASS (object);
- g_assert (klass->start != NULL);
+ g_assert (klass->start != nullptr);
return klass->start (object);
}
g_return_val_if_fail (GST_IS_MF_SOURCE_OBJECT (object), FALSE);
klass = GST_MF_SOURCE_OBJECT_GET_CLASS (object);
- g_assert (klass->stop != NULL);
+ g_assert (klass->stop != nullptr);
return klass->stop (object);
}
g_return_val_if_fail (GST_IS_BUFFER (buffer), GST_FLOW_ERROR);
klass = GST_MF_SOURCE_OBJECT_GET_CLASS (object);
- g_assert (klass->fill != NULL);
+ g_assert (klass->fill != nullptr);
return klass->fill (object, buffer);
}
GstMFSourceObjectClass *klass;
g_return_val_if_fail (GST_IS_MF_SOURCE_OBJECT (object), GST_FLOW_ERROR);
- g_return_val_if_fail (buffer != NULL, GST_FLOW_ERROR);
+ g_return_val_if_fail (buffer != nullptr, GST_FLOW_ERROR);
klass = GST_MF_SOURCE_OBJECT_GET_CLASS (object);
- g_assert (klass->create != NULL);
+ g_assert (klass->create != nullptr);
return klass->create (object, buffer);
}
g_return_val_if_fail (GST_IS_MF_SOURCE_OBJECT (object), FALSE);
klass = GST_MF_SOURCE_OBJECT_GET_CLASS (object);
- g_assert (klass->set_caps != NULL);
+ g_assert (klass->set_caps != nullptr);
return klass->set_caps (object, caps);
}
{
GstMFSourceObjectClass *klass;
- g_return_val_if_fail (GST_IS_MF_SOURCE_OBJECT (object), NULL);
+ g_return_val_if_fail (GST_IS_MF_SOURCE_OBJECT (object), nullptr);
klass = GST_MF_SOURCE_OBJECT_GET_CLASS (object);
- g_assert (klass->get_caps != NULL);
+ g_assert (klass->get_caps != nullptr);
return klass->get_caps (object);
}
GstClockTime
gst_mf_source_object_get_running_time (GstMFSourceObject * object)
{
- GstElement *client = NULL;
+ GstElement *client = nullptr;
GstClockTime timestamp = GST_CLOCK_TIME_NONE;
g_return_val_if_fail (GST_IS_MF_SOURCE_OBJECT (object), GST_CLOCK_TIME_NONE);
#endif
g_assert_not_reached ();
- return NULL;
+ return nullptr;
}
gint
/* *INDENT-OFF* */
using namespace Microsoft::WRL;
-
-G_BEGIN_DECLS
+/* *INDENT-ON* */
GST_DEBUG_CATEGORY_EXTERN (gst_mf_source_object_debug);
#define GST_CAT_DEFAULT gst_mf_source_object_debug
-G_END_DECLS
-/* *INDENT-ON* */
-
typedef struct _GstMFStreamMediaType
{
IMFMediaType *media_type;
{
gint i, j;
HRESULT hr;
- GList *list = NULL;
+ GList *list = nullptr;
std::vector < std::string > unhandled_caps;
- g_return_val_if_fail (source_reader != NULL, FALSE);
- g_return_val_if_fail (media_types != NULL, FALSE);
+ g_return_val_if_fail (source_reader != nullptr, FALSE);
+ g_return_val_if_fail (media_types != nullptr, FALSE);
{
/* Retrive only the first video stream. non-first video stream might be
if (SUCCEEDED (hr)) {
GstMFStreamMediaType *mtype;
- GstCaps *caps = NULL;
+ GstCaps *caps = nullptr;
GstStructure *s;
std::string name;
static void
gst_mf_stream_media_type_free (GstMFStreamMediaType * media_type)
{
- g_return_if_fail (media_type != NULL);
+ g_return_if_fail (media_type != nullptr);
if (media_type->media_type)
media_type->media_type->Release ();
if (self->activate) {
self->activate->ShutdownObject ();
self->activate->Release ();
- self->activate = NULL;
+ self->activate = nullptr;
}
if (self->media_types) {
g_list_free_full (self->media_types,
(GDestroyNotify) gst_mf_stream_media_type_free);
- self->media_types = NULL;
+ self->media_types = nullptr;
}
if (self->reader) {
self->reader->Release ();
- self->reader = NULL;
+ self->reader = nullptr;
}
if (self->source) {
self->source->Shutdown ();
self->source->Release ();
- self->source = NULL;
+ self->source = nullptr;
}
return TRUE;
return FALSE;
hr = self->reader->SetCurrentMediaType (type->stream_index,
- NULL, type->media_type);
+ nullptr, type->media_type);
if (!gst_mf_result (hr))
return FALSE;
IMFSample *sample = nullptr;
GstMFSourceReaderSample reader_sample;
- hr = self->reader->ReadSample (type->stream_index, 0, NULL, &stream_flags,
- NULL, &sample);
+ hr = self->reader->ReadSample (type->stream_index, 0, nullptr, &stream_flags,
+ nullptr, &sample);
if (!gst_mf_result (hr)) {
GST_ERROR_OBJECT (self, "Failed to read sample");
if (ret != GST_FLOW_OK)
return ret;
- hr = media_buffer->Lock (&data, NULL, NULL);
+ hr = media_buffer->Lock (&data, nullptr, nullptr);
if (!gst_mf_result (hr)) {
GST_ERROR_OBJECT (self, "Failed to lock media buffer");
return GST_FLOW_ERROR;
if (ret != GST_FLOW_OK)
return ret;
- hr = media_buffer->Lock (&data, NULL, &len);
+ hr = media_buffer->Lock (&data, nullptr, &len);
if (!gst_mf_result (hr) || len == 0) {
GST_ERROR_OBJECT (self, "Failed to lock media buffer");
return GST_FLOW_ERROR;
if (self->supported_caps)
return gst_caps_ref (self->supported_caps);
- return NULL;
+ return nullptr;
}
static gboolean
{
GstMFSourceReader *self = GST_MF_SOURCE_READER (object);
GList *iter;
- GstMFStreamMediaType *best_type = NULL;
+ GstMFStreamMediaType *best_type = nullptr;
for (iter = self->media_types; iter; iter = g_list_next (iter)) {
GstMFStreamMediaType *minfo = (GstMFStreamMediaType *) iter->data;
{
GstMFSourceObject *object = GST_MF_SOURCE_OBJECT (self);
GSource *source;
- GList *activate_list = NULL;
- GstMFDeviceActivate *target = NULL;
+ GList *activate_list = nullptr;
+ GstMFDeviceActivate *target = nullptr;
GList *iter;
- CoInitializeEx (NULL, COINIT_MULTITHREADED);
+ CoInitializeEx (nullptr, COINIT_MULTITHREADED);
g_main_context_push_thread_default (self->context);
source = g_idle_source_new ();
g_source_set_callback (source,
- (GSourceFunc) gst_mf_source_reader_main_loop_running_cb, self, NULL);
+ (GSourceFunc) gst_mf_source_reader_main_loop_running_cb, self, nullptr);
g_source_attach (source, self->context);
g_source_unref (source);
CoUninitialize ();
- return NULL;
+ return nullptr;
}
static gboolean
GstMFSourceType source_type, GList ** device_sources)
{
HRESULT hr;
- GList *ret = NULL;
+ GList *ret = nullptr;
ComPtr < IMFAttributes > attr;
- IMFActivate **devices = NULL;
+ IMFActivate **devices = nullptr;
UINT32 i, count = 0;
hr = MFCreateAttributes (&attr, 1);
if (gst_mf_result (hr)) {
entry->path = g_utf16_to_utf8 ((const gunichar2 *) name,
- -1, NULL, NULL, NULL);
+ -1, nullptr, nullptr, nullptr);
CoTaskMemFree (name);
}
&name, &name_len);
if (gst_mf_result (hr)) {
entry->name = g_utf16_to_utf8 ((const gunichar2 *) name,
- -1, NULL, NULL, NULL);
+ -1, nullptr, nullptr, nullptr);
CoTaskMemFree (name);
}
static void
gst_mf_device_activate_free (GstMFDeviceActivate * activate)
{
- g_return_if_fail (activate != NULL);
+ g_return_if_fail (activate != nullptr);
if (activate->handle)
activate->handle->Release ();
GstMFSourceObject *self;
/* TODO: add more type */
- g_return_val_if_fail (type == GST_MF_SOURCE_TYPE_VIDEO, NULL);
+ g_return_val_if_fail (type == GST_MF_SOURCE_TYPE_VIDEO, nullptr);
self = (GstMFSourceObject *) g_object_new (GST_TYPE_MF_SOURCE_READER,
"source-type", type, "device-index", device_index, "device-name",
- device_name, "device-path", device_path, NULL);
+ device_name, "device-path", device_path, nullptr);
gst_object_ref_sink (self);
if (!self->opened) {
GST_WARNING_OBJECT (self, "Couldn't open device");
gst_object_unref (self);
- return NULL;
+ return nullptr;
}
return self;
/* *INDENT-OFF* */
using namespace Microsoft::WRL;
-G_BEGIN_DECLS
-
GST_DEBUG_CATEGORY_EXTERN (gst_mf_transform_debug);
#define GST_CAT_DEFAULT gst_mf_transform_debug
-G_END_DECLS
-
typedef HRESULT (*GstMFTransformAsyncCallbackOnEvent) (MediaEventType event,
GstObject * client);
: ref_count_ (1)
, running_ (false)
{
- g_weak_ref_init (&client_, NULL);
+ g_weak_ref_init (&client_, nullptr);
}
~GstMFTransformAsyncCallback ()
g_object_class_install_property (gobject_class, PROP_DEVICE_NAME,
g_param_spec_string ("device-name", "device-name",
- "Device name", NULL,
+ "Device name", nullptr,
(GParamFlags) (G_PARAM_READABLE | G_PARAM_STATIC_STRINGS)));
g_object_class_install_property (gobject_class, PROP_HARDWARE,
g_param_spec_boolean ("hardware", "Hardware",
gst_mf_transform_clear_enum_params (GstMFTransformEnumParams * params)
{
g_free (params->input_typeinfo);
- params->input_typeinfo = NULL;
+ params->input_typeinfo = nullptr;
g_free (params->output_typeinfo);
- params->output_typeinfo = NULL;
+ params->output_typeinfo = nullptr;
}
static void
gst_mf_transform_thread_func (GstMFTransform * self)
{
HRESULT hr = S_OK;
- IMFActivate **devices = NULL;
+ IMFActivate **devices = nullptr;
UINT32 num_devices, i;
- LPWSTR name = NULL;
+ LPWSTR name = nullptr;
GSource *source;
- CoInitializeEx (NULL, COINIT_MULTITHREADED);
+ CoInitializeEx (nullptr, COINIT_MULTITHREADED);
g_main_context_push_thread_default (self->context);
source = g_idle_source_new ();
g_source_set_callback (source,
- (GSourceFunc) gst_mf_transform_main_loop_running_cb, self, NULL);
+ (GSourceFunc) gst_mf_transform_main_loop_running_cb, self, nullptr);
g_source_attach (source, self->context);
g_source_unref (source);
devices[i]->Release ();
hr = self->activate->GetAllocatedString (MFT_FRIENDLY_NAME_Attribute,
- &name, NULL);
+ &name, nullptr);
if (gst_mf_result (hr)) {
self->device_name = g_utf16_to_utf8 ((const gunichar2 *) name,
- -1, NULL, NULL, NULL);
+ -1, nullptr, nullptr, nullptr);
GST_INFO_OBJECT (self, "Open device %s", self->device_name);
CoTaskMemFree (name);
if (self->activate) {
self->activate->Release ();
- self->activate = NULL;
+ self->activate = nullptr;
}
CoUninitialize ();
- return NULL;
+ return nullptr;
}
static GstFlowReturn
gboolean ret = FALSE;
g_return_val_if_fail (GST_IS_MF_TRANSFORM (object), FALSE);
- g_return_val_if_fail (sample != NULL, FALSE);
+ g_return_val_if_fail (sample != nullptr, FALSE);
GST_TRACE_OBJECT (object, "Process input");
GstFlowReturn ret;
g_return_val_if_fail (GST_IS_MF_TRANSFORM (object), GST_FLOW_ERROR);
- g_return_val_if_fail (sample != NULL, GST_FLOW_ERROR);
+ g_return_val_if_fail (sample != nullptr, GST_FLOW_ERROR);
/* Hardware MFT must not call this method, instead client must install
* new sample callback so that outputting data from Media Foundation's
* worker thread */
GstMFTransformOpenData data;
g_return_val_if_fail (GST_IS_MF_TRANSFORM (object), FALSE);
- g_return_val_if_fail (object->activate != NULL, FALSE);
+ g_return_val_if_fail (object->activate != nullptr, FALSE);
data.object = object;
data.invoked = FALSE;
if (object->codec_api) {
object->codec_api->Release ();
- object->codec_api = NULL;
+ object->codec_api = nullptr;
}
if (object->transform) {
object->transform->Release ();
- object->transform = NULL;
+ object->transform = nullptr;
}
return TRUE;
IMFActivate *
gst_mf_transform_get_activate_handle (GstMFTransform * object)
{
- g_return_val_if_fail (GST_IS_MF_TRANSFORM (object), NULL);
+ g_return_val_if_fail (GST_IS_MF_TRANSFORM (object), nullptr);
return object->activate;
}
IMFTransform *
gst_mf_transform_get_transform_handle (GstMFTransform * object)
{
- g_return_val_if_fail (GST_IS_MF_TRANSFORM (object), NULL);
+ g_return_val_if_fail (GST_IS_MF_TRANSFORM (object), nullptr);
if (!object->transform) {
GST_WARNING_OBJECT (object,
"IMFTransform is not configured, open MFT first");
- return NULL;
+ return nullptr;
}
return object->transform;
ICodecAPI *
gst_mf_transform_get_codec_api_handle (GstMFTransform * object)
{
- g_return_val_if_fail (GST_IS_MF_TRANSFORM (object), NULL);
+ g_return_val_if_fail (GST_IS_MF_TRANSFORM (object), nullptr);
if (!object->codec_api) {
GST_WARNING_OBJECT (object, "ICodecAPI is not configured, open MFT first");
- return NULL;
+ return nullptr;
}
return object->codec_api;
IMFTransform *transform;
HRESULT hr;
DWORD index = 0;
- GList *list = NULL;
+ GList *list = nullptr;
g_return_val_if_fail (GST_IS_MF_TRANSFORM (object), FALSE);
- g_return_val_if_fail (input_types != NULL, FALSE);
+ g_return_val_if_fail (input_types != nullptr, FALSE);
transform = object->transform;
}
do {
- IMFMediaType *type = NULL;
+ IMFMediaType *type = nullptr;
hr = transform->GetInputAvailableType (object->input_id, index, &type);
if (SUCCEEDED (hr))
IMFTransform *transform;
HRESULT hr;
DWORD index = 0;
- GList *list = NULL;
+ GList *list = nullptr;
g_return_val_if_fail (GST_IS_MF_TRANSFORM (object), FALSE);
- g_return_val_if_fail (output_types != NULL, FALSE);
+ g_return_val_if_fail (output_types != nullptr, FALSE);
transform = object->transform;
HRESULT hr;
g_return_val_if_fail (GST_IS_MF_TRANSFORM (object), FALSE);
- g_return_val_if_fail (input_type != NULL, FALSE);
+ g_return_val_if_fail (input_type != nullptr, FALSE);
transform = object->transform;
HRESULT hr;
g_return_val_if_fail (GST_IS_MF_TRANSFORM (object), FALSE);
- g_return_val_if_fail (output_type != NULL, FALSE);
+ g_return_val_if_fail (output_type != nullptr, FALSE);
transform = object->transform;
{
GstMFTransform *self;
- g_return_val_if_fail (params != NULL, NULL);
+ g_return_val_if_fail (params != nullptr, nullptr);
self = (GstMFTransform *) g_object_new (GST_TYPE_MF_TRANSFORM_OBJECT,
- "enum-params", params, NULL);
+ "enum-params", params, nullptr);
if (!self->initialized) {
gst_object_unref (self);
- return NULL;
+ return nullptr;
}
gst_object_ref_sink (self);
VARIANT var;
g_return_val_if_fail (GST_IS_MF_TRANSFORM (object), FALSE);
- g_return_val_if_fail (api != NULL, FALSE);
+ g_return_val_if_fail (api != nullptr, FALSE);
if (!object->codec_api) {
GST_WARNING_OBJECT (object, "codec api unavailable");
VARIANT var;
g_return_val_if_fail (GST_IS_MF_TRANSFORM (object), FALSE);
- g_return_val_if_fail (api != NULL, FALSE);
+ g_return_val_if_fail (api != nullptr, FALSE);
if (!object->codec_api) {
GST_WARNING_OBJECT (object, "codec api unavailable");
VARIANT var;
g_return_val_if_fail (GST_IS_MF_TRANSFORM (object), FALSE);
- g_return_val_if_fail (api != NULL, FALSE);
+ g_return_val_if_fail (api != nullptr, FALSE);
if (!object->codec_api) {
GST_WARNING_OBJECT (object, "codec api unavailable");
/* *INDENT-OFF* */
using namespace Microsoft::WRL;
-G_BEGIN_DECLS
-
GST_DEBUG_CATEGORY_EXTERN (gst_mf_utils_debug);
#define GST_CAT_DEFAULT gst_mf_utils_debug
-G_END_DECLS
-
#define MAKE_RAW_FORMAT_CAPS(format) \
"video/x-raw, format = (string) " format
return &raw_video_format_map[i].mf_format;
}
- return NULL;
+ return nullptr;
}
static GstCaps *
gst_mf_media_type_to_video_caps (IMFMediaType * media_type)
{
HRESULT hr;
- GstCaps *caps = NULL;
+ GstCaps *caps = nullptr;
gint i;
guint32 width = 0;
guint32 height = 0;
hr = media_type->GetGUID (MF_MT_SUBTYPE, &subtype);
if (FAILED (hr)) {
GST_WARNING ("Failed to get subtype, hr: 0x%x", (guint) hr);
- return NULL;
+ return nullptr;
}
for (i = 0; i < G_N_ELEMENTS (raw_video_format_map); i++) {
if (!caps) {
GST_WARNING ("Unknown format %" GST_FOURCC_FORMAT,
GST_FOURCC_ARGS (subtype.Data1));
- return NULL;
+ return nullptr;
}
hr = MFGetAttributeSize (media_type, MF_MT_FRAME_SIZE, &width, &height);
if (raw_format) {
gst_caps_unref (caps);
- return NULL;
+ return nullptr;
}
}
if (width > 0 && height > 0) {
gst_caps_set_simple (caps, "width", G_TYPE_INT, width,
- "height", G_TYPE_INT, height, NULL);
+ "height", G_TYPE_INT, height, nullptr);
}
hr = MFGetAttributeRatio (media_type, MF_MT_FRAME_RATE, &num, &den);
if (SUCCEEDED (hr) && num > 0 && den > 0)
- gst_caps_set_simple (caps, "framerate", GST_TYPE_FRACTION, num, den, NULL);
+ gst_caps_set_simple (caps, "framerate", GST_TYPE_FRACTION, num, den,
+ nullptr);
hr = MFGetAttributeRatio (media_type, MF_MT_PIXEL_ASPECT_RATIO, &num, &den);
if (SUCCEEDED (hr) && num > 0 && den > 0)
gst_caps_set_simple (caps,
- "pixel-aspect-ratio", GST_TYPE_FRACTION, num, den, NULL);
+ "pixel-aspect-ratio", GST_TYPE_FRACTION, num, den, nullptr);
colorimetry.range = GST_VIDEO_COLOR_RANGE_UNKNOWN;
colorimetry.matrix = GST_VIDEO_COLOR_MATRIX_UNKNOWN;
str = gst_video_colorimetry_to_string (&colorimetry);
if (str) {
- gst_caps_set_simple (caps, "colorimetry", G_TYPE_STRING, str, NULL);
+ gst_caps_set_simple (caps, "colorimetry", G_TYPE_STRING, str, nullptr);
g_free (str);
- str = NULL;
+ str = nullptr;
}
chroma_site = GST_VIDEO_CHROMA_SITE_UNKNOWN;
if (chroma_site != GST_VIDEO_CHROMA_SITE_UNKNOWN)
gst_caps_set_simple (caps, "chroma-site", G_TYPE_STRING,
- gst_video_chroma_to_string (chroma_site), NULL);
+ gst_video_chroma_to_string (chroma_site), nullptr);
return caps;
}
GUID major_type;
HRESULT hr;
- g_return_val_if_fail (media_type != NULL, NULL);
+ g_return_val_if_fail (media_type != nullptr, nullptr);
hr = media_type->GetMajorType (&major_type);
if (FAILED (hr)) {
GST_WARNING ("failed to get major type, hr: 0x%x", (guint) hr);
- return NULL;
+ return nullptr;
}
if (IsEqualGUID (major_type, MFMediaType_Video))
return gst_mf_media_type_to_video_caps (media_type);
- return NULL;
+ return nullptr;
}
void
gboolean ret = TRUE;
if (FAILED (hr)) {
- gchar *error_text = NULL;
+ gchar *error_text = nullptr;
error_text = g_win32_error_message ((gint) hr);
/* g_win32_error_message() doesn't cover all HERESULT return code,
* so it could be empty string, or null if there was an error
* in g_utf16_to_utf8() */
gst_debug_log (cat, GST_LEVEL_WARNING, file, function, line,
- NULL, "MediaFoundation call failed: 0x%x, %s", (guint) hr,
+ nullptr, "MediaFoundation call failed: 0x%x, %s", (guint) hr,
GST_STR_NULL (error_text));
g_free (error_text);
GST_MF_IF_EQUAL_RETURN (guid, MF_MT_ORIGINAL_WAVE_FORMAT_TAG);
#endif
- return NULL;
+ return nullptr;
}
static gchar *
gst_mf_guid_to_string (const GUID & guid)
{
- const gchar *str = NULL;
+ const gchar *str = nullptr;
HRESULT hr;
- WCHAR *name = NULL;
- gchar *ret = NULL;
+ WCHAR *name = nullptr;
+ gchar *ret = nullptr;
str = gst_mf_guid_to_static_string (guid);
if (str)
hr = StringFromCLSID (guid, &name);
if (gst_mf_result (hr) && name) {
- ret = g_utf16_to_utf8 ((const gunichar2 *) name, -1, NULL, NULL, NULL);
+ ret =
+ g_utf16_to_utf8 ((const gunichar2 *) name, -1, nullptr, nullptr,
+ nullptr);
CoTaskMemFree (name);
if (ret)
return gst_mf_guid_to_string (*var.puuid);
case VT_LPWSTR:
return g_utf16_to_utf8 ((const gunichar2 *) var.pwszVal,
- -1, NULL, NULL, NULL);
+ -1, nullptr, nullptr, nullptr);
case VT_UNKNOWN:
return g_strdup ("IUnknown");
default:
return g_strdup_printf ("Unhandled type (vt = %d)", var.vt);
}
- return NULL;
+ return nullptr;
}
static void
guint index, GstDebugLevel level, GstDebugCategory * cat,
const gchar * file, const gchar * function, gint line)
{
- gchar *guid_name = NULL;
- gchar *value = NULL;
+ gchar *guid_name = nullptr;
+ gchar *value = nullptr;
GUID guid = GUID_NULL;
HRESULT hr;
goto done;
gst_debug_log (cat, level, file, function, line,
- NULL, "%s attribute %d, %s: %s", msg ? msg : "", index, guid_name, value);
+ nullptr, "%s attribute %d, %s: %s", msg ? msg : "", index, guid_name,
+ value);
done:
PropVariantClear (&var);
#include "gstmfvideobuffer.h"
#include <string.h>
-/* *INDENT-OFF* */
-G_BEGIN_DECLS
-
GST_DEBUG_CATEGORY_EXTERN (gst_mf_video_buffer_debug);
#define GST_CAT_DEFAULT gst_mf_video_buffer_debug
-G_END_DECLS
-
+/* *INDENT-OFF* */
IGstMFVideoBuffer::IGstMFVideoBuffer ()
: ref_count_ (1)
, current_len_ (0)
GST_TRACE ("query IGstMFVideoBuffer interface %p", this);
*object = this;
} else {
- *object = NULL;
+ *object = nullptr;
return E_NOINTERFACE;
}
/* *INDENT-OFF* */
using namespace Microsoft::WRL;
-
-G_BEGIN_DECLS
+/* *INDENT-ON* */
GST_DEBUG_CATEGORY_EXTERN (gst_mf_video_enc_debug);
#define GST_CAT_DEFAULT gst_mf_video_enc_debug
-G_END_DECLS
-/* *INDENT-ON* */
-
#define gst_mf_video_enc_parent_class parent_class
G_DEFINE_ABSTRACT_TYPE (GstMFVideoEnc, gst_mf_video_enc,
GST_TYPE_VIDEO_ENCODER);
device = self->d3d11_device;
- hr = GstMFCreateDXGIDeviceManager (&self->reset_token, &self->device_manager);
+ hr = GstMFCreateDXGIDeviceManager (&self->reset_token,
+ &self->device_manager);
if (!gst_mf_result (hr)) {
GST_ERROR_OBJECT (self, "Couldn't create DXGI device manager");
gst_clear_object (&self->other_d3d11_device);
if (self->input_state) {
gst_video_codec_state_unref (self->input_state);
- self->input_state = NULL;
+ self->input_state = nullptr;
}
#if GST_MF_HAVE_D3D11
if (self->device_manager) {
if (self->mf_allocator) {
self->mf_allocator->UninitializeSampleAllocator ();
self->mf_allocator->Release ();
- self->mf_allocator = NULL;
+ self->mf_allocator = nullptr;
}
gst_clear_object (&self->other_d3d11_device);
GstVideoInfo *info = &state->info;
ComPtr < IMFMediaType > in_type;
ComPtr < IMFMediaType > out_type;
- GList *input_types = NULL;
+ GList *input_types = nullptr;
GList *iter;
HRESULT hr;
gint fps_n, fps_d;
return FALSE;
}
- g_assert (klass->set_src_caps != NULL);
+ g_assert (klass->set_src_caps != nullptr);
if (!klass->set_src_caps (self, self->input_state, out_type.Get ())) {
GST_ERROR_OBJECT (self, "subclass couldn't set src caps");
return FALSE;
if (self->mf_allocator) {
self->mf_allocator->UninitializeSampleAllocator ();
self->mf_allocator->Release ();
- self->mf_allocator = NULL;
+ self->mf_allocator = nullptr;
}
/* Check whether upstream is d3d11 element */
GstMFVideoEncClass *klass = GST_MF_VIDEO_ENC_GET_CLASS (self);
HRESULT hr;
gboolean unset_force_keyframe = FALSE;
- GstMFVideoEncFrameData *frame_data = NULL;
+ GstMFVideoEncFrameData *frame_data = nullptr;
gboolean res;
frame_data = g_new0 (GstMFVideoEncFrameData, 1);
gst_mf_video_enc_find_output_frame (GstMFVideoEnc * self, LONGLONG mf_pts)
{
GList *l, *walk = gst_video_encoder_get_frames (GST_VIDEO_ENCODER (self));
- GstVideoCodecFrame *ret = NULL;
- GstVideoCodecFrame *closest = NULL;
+ GstVideoCodecFrame *ret = nullptr;
+ GstVideoCodecFrame *closest = nullptr;
LONGLONG min_pts_abs_diff = 0;
for (l = walk; l; l = l->next) {
if (!gst_mf_result (hr))
goto done;
- hr = media_buffer->Lock (&data, NULL, &buffer_len);
+ hr = media_buffer->Lock (&data, nullptr, &buffer_len);
if (!gst_mf_result (hr))
goto done;
- buffer = gst_buffer_new_allocate (NULL, buffer_len, NULL);
+ buffer = gst_buffer_new_allocate (nullptr, buffer_len, nullptr);
gst_buffer_fill (buffer, 0, data, buffer_len);
media_buffer->Unlock ();
ComPtr < IGstMFVideoBuffer > video_buffer;
GstVideoInfo *info = &self->input_state->info;
gint i, j;
- GstVideoFrame *vframe = NULL;
- BYTE *data = NULL;
+ GstVideoFrame *vframe = nullptr;
+ BYTE *data = nullptr;
gboolean need_copy;
vframe = g_new0 (GstVideoFrame, 1);
if (!gst_mf_result (hr))
goto error;
} else {
- hr = media_buffer->Lock (&data, NULL, NULL);
+ hr = media_buffer->Lock (&data, nullptr, nullptr);
if (!gst_mf_result (hr))
goto error;
} else {
gst_video_frame_unmap (vframe);
g_free (vframe);
- vframe = NULL;
+ vframe = nullptr;
}
*sample = new_sample.Detach ();
#if GST_MF_HAVE_D3D11
GstMFVideoEnc *self = GST_MF_VIDEO_ENC (enc);
GstVideoInfo info;
- GstBufferPool *pool = NULL;
+ GstBufferPool *pool = nullptr;
GstCaps *caps;
guint size;
GstD3D11Device *device = self->other_d3d11_device;
- gst_query_parse_allocation (query, &caps, NULL);
+ gst_query_parse_allocation (query, &caps, nullptr);
- if (caps == NULL)
+ if (caps == nullptr)
return FALSE;
if (!gst_video_info_from_caps (&info, caps))
gboolean is_hardware = FALSE;
gint i;
- g_object_get (device, "hardware", &is_hardware, NULL);
+ g_object_get (device, "hardware", &is_hardware, nullptr);
/* In case of hardware, set D3D11_RESOURCE_MISC_SHARED_KEYEDMUTEX flag
* so that it can be shared with other d3d11 devices */
gst_object_unref (pool);
}
- gst_query_add_allocation_meta (query, GST_VIDEO_META_API_TYPE, NULL);
+ gst_query_add_allocation_meta (query, GST_VIDEO_META_API_TYPE, nullptr);
return TRUE;
MFT_REGISTER_TYPE_INFO *infos;
UINT32 info_size;
gint i;
- GstCaps *src_caps = NULL;
- GstCaps *sink_caps = NULL;
- GstCaps *d3d11_caps = NULL;
- GValue *supported_formats = NULL;
- GValue *profiles = NULL;
+ GstCaps *src_caps = nullptr;
+ GstCaps *sink_caps = nullptr;
+ GstCaps *d3d11_caps = nullptr;
+ GValue *supported_formats = nullptr;
+ GValue *profiles = nullptr;
gboolean have_I420 = FALSE;
gboolean have_NV12 = FALSE;
gboolean have_P010 = FALSE;
gboolean d3d11_aware = FALSE;
- gchar *device_name = NULL;
+ gchar *device_name = nullptr;
IMFActivate *activate;
IMFTransform *encoder;
ICodecAPI *codec_api;
{eAVEncH264VProfile_High, "high"},
{eAVEncH264VProfile_Main, "main"},
{eAVEncH264VProfile_Base, "baseline"},
- {0, NULL},
+ {0, nullptr},
};
GstMFVideoEncProfileMap hevc_profile_map[] = {
{eAVEncH265VProfile_Main_420_8, "main"},
{eAVEncH265VProfile_Main_420_10, "main-10"},
- {0, NULL},
+ {0, nullptr},
};
- GstMFVideoEncProfileMap *profile_to_check = NULL;
+ GstMFVideoEncProfileMap *profile_to_check = nullptr;
static const gchar *h264_caps_str =
"video/x-h264, stream-format=(string) byte-stream, alignment=(string) au";
static const gchar *hevc_caps_str =
"video/x-h265, stream-format=(string) byte-stream, alignment=(string) au";
static const gchar *vp9_caps_str = "video/x-vp9";
- const gchar *codec_caps_str = NULL;
+ const gchar *codec_caps_str = nullptr;
/* NOTE: depending on environment,
* some enumerated h/w MFT might not be usable (e.g., multiple GPU case) */
return;
}
- g_object_get (transform, "device-name", &device_name, NULL);
+ g_object_get (transform, "device-name", &device_name, nullptr);
if (!device_name) {
GST_WARNING_OBJECT (transform, "Unknown device name");
return;
if (mf_profile == 0)
break;
- g_assert (profile_str != NULL);
+ g_assert (profile_str != nullptr);
hr = out_type->SetUINT32 (MF_MT_MPEG2_PROFILE, mf_profile);
if (!gst_mf_result (hr))
* API for querying supported max resolution... */
gst_caps_set_simple (sink_caps,
"width", GST_TYPE_INT_RANGE, 64, 8192,
- "height", GST_TYPE_INT_RANGE, 64, 8192, NULL);
+ "height", GST_TYPE_INT_RANGE, 64, 8192, nullptr);
gst_caps_set_simple (src_caps,
"width", GST_TYPE_INT_RANGE, 64, 8192,
- "height", GST_TYPE_INT_RANGE, 64, 8192, NULL);
+ "height", GST_TYPE_INT_RANGE, 64, 8192, nullptr);
#if GST_MF_HAVE_D3D11
/* Check whether this MFT can support D3D11 */
if (d3d11_device && (have_NV12 || have_P010)) {
- g_object_get (transform, "d3d11-aware", &d3d11_aware, NULL);
+ g_object_get (transform, "d3d11-aware", &d3d11_aware, nullptr);
GST_DEBUG_OBJECT (transform, "d3d11 aware %d", d3d11_aware);
}
gint64 adapter_luid = 0;
GValue d3d11_formats = G_VALUE_INIT;
- g_object_get (d3d11_device, "adapter-luid", &adapter_luid, NULL);
+ g_object_get (d3d11_device, "adapter-luid", &adapter_luid, nullptr);
d3d11_caps = gst_caps_copy (sink_caps);
GstMFTransform *transform;
gint64 adapter_luid = 0;
- *sink_template = NULL;
- *src_template = NULL;
+ *sink_template = nullptr;
+ *src_template = nullptr;
memset (device_caps, 0, sizeof (GstMFVideoEncDeviceCaps));
if (!IsEqualGUID (MFVideoFormat_H264, *subtype) &&
!IsEqualGUID (MFVideoFormat_VP90, *subtype)) {
GST_ERROR ("Unknown subtype GUID");
- return NULL;
+ return nullptr;
}
if (d3d11_device) {
- g_object_get (d3d11_device, "adapter-luid", &adapter_luid, NULL);
+ g_object_get (d3d11_device, "adapter-luid", &adapter_luid, nullptr);
if (!adapter_luid) {
GST_ERROR ("Couldn't get adapter LUID");
- return NULL;
+ return nullptr;
}
}
transform = gst_mf_transform_new (&enum_params);
if (!transform)
- return NULL;
+ return nullptr;
gst_mf_video_enc_enum_internal (transform, output_type.guidSubtype,
d3d11_device, device_caps, sink_template, src_template);
gint i;
GstMFVideoEncClassData *cdata;
gboolean is_default = TRUE;
- gchar *device_name = NULL;
- const gchar *type_name_prefix = NULL;
- const gchar *feature_name_prefix = NULL;
+ gchar *device_name = nullptr;
+ const gchar *type_name_prefix = nullptr;
+ const gchar *feature_name_prefix = nullptr;
if (IsEqualGUID (MFVideoFormat_H264, *subtype)) {
type_name_prefix = "H264";
}
/* Must be checked already */
- g_object_get (transform, "device-name", &device_name, NULL);
- g_assert (device_name != NULL);
+ g_object_get (transform, "device-name", &device_name, nullptr);
+ g_assert (device_name != nullptr);
cdata = g_new0 (GstMFVideoEncClassData, 1);
cdata->sink_caps = gst_caps_copy (sink_caps);
gst_mf_video_enc_register (GstPlugin * plugin, guint rank, GUID * subtype,
GTypeInfo * type_info, GList * d3d11_device)
{
- GstMFTransform *transform = NULL;
- GstCaps *sink_template = NULL;
- GstCaps *src_template = NULL;
+ GstMFTransform *transform = nullptr;
+ GstCaps *sink_template = nullptr;
+ GstCaps *src_template = nullptr;
guint enum_flags;
GstMFVideoEncDeviceCaps device_caps;
guint i;
/* AMD seems to be able to support up to 12 GPUs */
for (i = 0; i < 12; i++) {
transform = gst_mf_video_enc_enum (enum_flags, subtype, i, &device_caps,
- NULL, &sink_template, &src_template);
+ nullptr, &sink_template, &src_template);
/* No more MFT to enumerate */
if (!transform)
MFT_ENUM_FLAG_SORTANDFILTER | MFT_ENUM_FLAG_SORTANDFILTER_APPROVED_ONLY);
transform = gst_mf_video_enc_enum (enum_flags, subtype, 0, &device_caps,
- NULL, &sink_template, &src_template);
+ nullptr, &sink_template, &src_template);
if (!transform)
goto done;
PROP_DISPATCHER,
};
-#define DEFAULT_DEVICE_PATH NULL
-#define DEFAULT_DEVICE_NAME NULL
+#define DEFAULT_DEVICE_PATH nullptr
+#define DEFAULT_DEVICE_NAME nullptr
#define DEFAULT_DEVICE_INDEX -1
static void gst_mf_video_src_finalize (GObject * object);
GstElementClass *element_class = GST_ELEMENT_CLASS (klass);
GstBaseSrcClass *basesrc_class = GST_BASE_SRC_CLASS (klass);
GstPushSrcClass *pushsrc_class = GST_PUSH_SRC_CLASS (klass);
+ GParamFlags flags = (GParamFlags) (G_PARAM_READWRITE |
+ GST_PARAM_MUTABLE_READY | G_PARAM_STATIC_STRINGS);
gobject_class->finalize = gst_mf_video_src_finalize;
gobject_class->get_property = gst_mf_video_src_get_property;
g_object_class_install_property (gobject_class, PROP_DEVICE_PATH,
g_param_spec_string ("device-path", "Device Path",
- "The device path", DEFAULT_DEVICE_PATH,
- G_PARAM_READWRITE | GST_PARAM_MUTABLE_READY |
- G_PARAM_STATIC_STRINGS));
+ "The device path", DEFAULT_DEVICE_PATH, flags));
g_object_class_install_property (gobject_class, PROP_DEVICE_NAME,
g_param_spec_string ("device-name", "Device Name",
- "The human-readable device name", DEFAULT_DEVICE_NAME,
- G_PARAM_READWRITE | GST_PARAM_MUTABLE_READY |
- G_PARAM_STATIC_STRINGS));
+ "The human-readable device name", DEFAULT_DEVICE_NAME, flags));
g_object_class_install_property (gobject_class, PROP_DEVICE_INDEX,
g_param_spec_int ("device-index", "Device Index",
"The zero-based device index", -1, G_MAXINT, DEFAULT_DEVICE_INDEX,
- G_PARAM_READWRITE | GST_PARAM_MUTABLE_READY |
- G_PARAM_STATIC_STRINGS));
+ flags));
#if GST_MF_WINAPI_APP
/**
* GstMFVideoSrc:dispatcher:
"the reference count of given ICoreDispatcher and release it after "
"use. Therefore, caller does not need to consider additional "
"reference count management",
- GST_PARAM_CONDITIONALLY_AVAILABLE | GST_PARAM_MUTABLE_READY |
- G_PARAM_WRITABLE | G_PARAM_STATIC_STRINGS));
+ (GParamFlags) (GST_PARAM_CONDITIONALLY_AVAILABLE |
+ GST_PARAM_MUTABLE_READY | G_PARAM_WRITABLE |
+ G_PARAM_STATIC_STRINGS)));
#endif
gst_element_class_set_static_metadata (element_class,
GST_DEBUG_OBJECT (self, "Start");
self->source = gst_mf_source_object_new (GST_MF_SOURCE_TYPE_VIDEO,
- self->device_index, self->device_name, self->device_path, NULL);
+ self->device_index, self->device_name, self->device_path, nullptr);
self->n_frames = 0;
self->latency = 0;
if (self->source) {
gst_mf_source_object_stop (self->source);
gst_object_unref (self->source);
- self->source = NULL;
+ self->source = nullptr;
}
self->started = FALSE;
gst_mf_video_src_get_caps (GstBaseSrc * src, GstCaps * filter)
{
GstMFVideoSrc *self = GST_MF_VIDEO_SRC (src);
- GstCaps *caps = NULL;
+ GstCaps *caps = nullptr;
if (self->source)
caps = gst_mf_source_object_get_caps (self->source);
{
GstMFVideoSrc *self = GST_MF_VIDEO_SRC (pushsrc);
GstFlowReturn ret = GST_FLOW_OK;
- GstBuffer *buf = NULL;
+ GstBuffer *buf = nullptr;
GstClock *clock;
GstClockTime running_time = GST_CLOCK_TIME_NONE;
GstClockTimeDiff diff;
static const GEnumValue rc_mode_types[] = {
{GST_MF_VP9_ENC_RC_MODE_CBR, "Constant bitrate", "cbr"},
{GST_MF_VP9_ENC_RC_MODE_QUALITY, "Quality-based variable bitrate", "qvbr"},
- {0, NULL, NULL}
+ {0, nullptr, nullptr}
};
if (!rc_mode_type) {
{GST_MF_VP9_ENC_CONTENT_TYPE_UNKNOWN, "Unknown", "unknown"},
{GST_MF_VP9_ENC_CONTENT_TYPE_FIXED_CAMERA_ANGLE,
"Fixed Camera Angle, such as a webcam", "fixed"},
- {0, NULL, NULL}
+ {0, nullptr, nullptr}
};
if (!content_type) {
GstMFVideoEncClass parent_class;
} GstMFVP9EncClass;
-static GstElementClass *parent_class = NULL;
+static GstElementClass *parent_class = nullptr;
static void gst_mf_vp9_enc_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec);
tags = gst_tag_list_new_empty ();
gst_tag_list_add (tags, GST_TAG_MERGE_REPLACE, GST_TAG_ENCODER,
gst_element_get_metadata (GST_ELEMENT_CAST (self),
- GST_ELEMENT_METADATA_LONGNAME), NULL);
+ GST_ELEMENT_METADATA_LONGNAME), nullptr);
gst_video_encoder_merge_tags (GST_VIDEO_ENCODER (self), tags,
GST_TAG_MERGE_REPLACE);
gst_tag_list_unref (tags);
{
GTypeInfo type_info = {
sizeof (GstMFVP9EncClass),
- NULL,
- NULL,
+ nullptr,
+ nullptr,
(GClassInitFunc) gst_mf_vp9_enc_class_init,
- NULL,
- NULL,
+ nullptr,
+ nullptr,
sizeof (GstMFVP9Enc),
0,
(GInstanceInitFunc) gst_mf_vp9_enc_init,
static LRESULT CALLBACK
window_proc (HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
{
- GstWin32DeviceWatcher * self;
+ GstWin32DeviceWatcher *self;
switch (msg) {
case WM_CREATE:
{
WNDCLASSEXA wc;
ATOM atom = 0;
- HINSTANCE hinstance = GetModuleHandle (NULL);
+ HINSTANCE hinstance = GetModuleHandle (nullptr);
static const gchar *klass_name = "GstWin32DeviceWatcher";
HWND hwnd;
G_UNLOCK (create_lock);
GST_ERROR_OBJECT (self, "Failed to register window class, lastError 0x%x",
(guint) GetLastError ());
- return NULL;
+ return nullptr;
}
} else {
GST_LOG_OBJECT (self, "window class was already registered");
G_UNLOCK (create_lock);
hwnd = CreateWindowExA (0, klass_name, "", 0, 0, 0, 0, 0,
- HWND_MESSAGE, NULL, hinstance, self);
+ HWND_MESSAGE, nullptr, hinstance, self);
if (!hwnd) {
GST_ERROR_OBJECT (self, "Failed to create window handle, lastError 0x%x",
(guint) GetLastError ());
{
MSG msg;
- if (!PeekMessage (&msg, NULL, 0, 0, PM_REMOVE))
+ if (!PeekMessage (&msg, nullptr, 0, 0, PM_REMOVE))
return G_SOURCE_CONTINUE;
TranslateMessage (&msg);
typedef struct
{
- GstWin32DeviceWatcher * self;
+ GstWin32DeviceWatcher *self;
gboolean handled;
gboolean ret;
static gboolean
register_device_notification (DeviceNotificationData * data)
{
- GstWin32DeviceWatcher * self = data->self;
+ GstWin32DeviceWatcher *self = data->self;
DEV_BROADCAST_DEVICEINTERFACE di = { 0, };
if (self->device_notify)
static gboolean
unregister_device_notification (DeviceNotificationData * data)
{
- GstWin32DeviceWatcher * self = data->self;
+ GstWin32DeviceWatcher *self = data->self;
if (!self->device_notify)
goto out;
using namespace ABI::Windows::Media::Devices;
using namespace ABI::Windows::Media::MediaProperties;
-G_BEGIN_DECLS
-
GST_DEBUG_CATEGORY_EXTERN (gst_mf_source_object_debug);
#define GST_CAT_DEFAULT gst_mf_source_object_debug
-G_END_DECLS
-
static std::string
convert_hstring_to_string (HString * hstr)
{
caps = gst_caps_new_simple ("video/x-raw",
"format", G_TYPE_STRING, format.c_str(), "width", G_TYPE_INT, width,
- "height", G_TYPE_INT, height, NULL);
+ "height", G_TYPE_INT, height, nullptr);
if (fps_n > 0 && fps_d > 0)
gst_caps_set_simple (caps,
- "framerate", GST_TYPE_FRACTION, fps_n, fps_d, NULL);
+ "framerate", GST_TYPE_FRACTION, fps_n, fps_d, nullptr);
source_id.CopyTo (source_id_.GetAddressOf());
hstr_subtype.CopyTo (subtype_.GetAddressOf());
mf_sources = [
- 'plugin.c',
'gstmfutils.cpp',
'gstmftransform.cpp',
'gstmfvideoenc.cpp',
'gstmfh264enc.cpp',
'gstmfh265enc.cpp',
'gstmfvp9enc.cpp',
- 'gstmfvideosrc.c',
- 'gstmfsourceobject.c',
- 'gstmfdevice.c',
+ 'gstmfvideosrc.cpp',
+ 'gstmfsourceobject.cpp',
+ 'gstmfdevice.cpp',
'gstmfaudioenc.cpp',
'gstmfaacenc.cpp',
'gstmfmp3enc.cpp',
'gstmfvideobuffer.cpp',
- 'gstmfplatloader.c',
+ 'gstmfplatloader.cpp',
+ 'plugin.cpp',
]
mf_desktop_sources = [
#include "gstmfconfig.h"
#include <winapifamily.h>
+#include <wrl.h>
#include <gst/gst.h>
#include <gst/video/video.h>
#define GST_CAT_DEFAULT gst_mf_debug
+/* *INDENT-OFF* */
+using namespace Microsoft::WRL;
+/* *INDENT-ON* */
+
static void
plugin_deinit (gpointer data)
{
static GList *
get_d3d11_devices (void)
{
- GList *ret = NULL;
+ GList *ret = nullptr;
guint i;
HRESULT hr;
- IMFVideoSampleAllocatorEx *allocator = NULL;
+ ComPtr < IMFVideoSampleAllocatorEx > allocator;
/* Check whether we can use IMFVideoSampleAllocatorEx interface */
- hr = GstMFCreateVideoSampleAllocatorEx (&IID_IMFVideoSampleAllocatorEx,
+ hr = GstMFCreateVideoSampleAllocatorEx (IID_IMFVideoSampleAllocatorEx,
&allocator);
if (!gst_mf_result (hr)) {
GST_DEBUG ("IMFVideoSampleAllocatorEx interface is unavailable");
- return NULL;
- } else {
- IMFVideoSampleAllocatorEx_Release (allocator);
+ return nullptr;
}
/* AMD seems supporting up to 12 cards, and 8 for NVIDIA */
if (!device)
break;
- g_object_get (device, "hardware", &is_hardware, NULL);
+ g_object_get (device, "hardware", &is_hardware, nullptr);
if (!is_hardware) {
GST_DEBUG_OBJECT (device, "Given d3d11 device is not for hardware");
* MF specific texture pool without download texture */
device_handle = gst_d3d11_device_get_device_handle (device);
- hr = ID3D11Device_CheckFeatureSupport (device_handle,
- D3D11_FEATURE_D3D11_OPTIONS4, &options, sizeof (options));
+ hr = device_handle->CheckFeatureSupport (D3D11_FEATURE_D3D11_OPTIONS4,
+ &options, sizeof (options));
if (!gst_d3d11_result (hr, device) ||
!options.ExtendedNV12SharedTextureSupported) {
GST_DEBUG_OBJECT (device,
}
/* can we bind NV12 texture for encoder? */
- hr = ID3D11Device_CheckFormatSupport (device_handle,
- DXGI_FORMAT_NV12, &supported);
+ hr = device_handle->CheckFormatSupport (DXGI_FORMAT_NV12, &supported);
if (!gst_d3d11_result (hr, device)) {
GST_DEBUG_OBJECT (device, "Couldn't query format support");
plugin_init (GstPlugin * plugin)
{
HRESULT hr;
- GstRank rank = GST_RANK_SECONDARY;
- GList *device_list = NULL;
+ guint rank = GST_RANK_SECONDARY;
+ GList *device_list = nullptr;
GST_DEBUG_CATEGORY_INIT (gst_mf_debug, "mf", 0, "media foundation");
GST_DEBUG_CATEGORY_INIT (gst_mf_utils_debug,
* of each MFStartup and MFShutdown call should be identical. This rule is
* simliar to that of CoInitialize/CoUninitialize pair */
g_object_set_data_full (G_OBJECT (plugin),
- "plugin-mediafoundation-shutdown", "shutdown-data",
+ "plugin-mediafoundation-shutdown", (gpointer) "shutdown-data",
(GDestroyNotify) plugin_deinit);
return TRUE;
projects / platform / upstream / gstreamer.git / commitdiff