mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-11-14 05:12:09 +00:00
Code Issues 1 Projects Releases Wiki Activity

mediafoundation: Cosmetic changes

Browse source 
Rename baseclass to be consistent with other Windows plugins

Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1596>
This commit is contained in:
Seungha Yang 2022-01-28 01:45:30 +09:00
parent ce4875ccde
commit 0b26254a6a
13 changed files with 367 additions and 342 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

50
subprojects/gst-plugins-bad/sys/mediafoundation/gstmfaacenc.cpp
View file

@ -36,7 +36,7 @@
#include <gst/gst.h> #include <gst/gst.h>
#include <gst/pbutils/pbutils.h> #include <gst/pbutils/pbutils.h>
#include "gstmfaudioenc.h" #include "gstmfaudioencoder.h"
#include "gstmfaacenc.h" #include "gstmfaacenc.h"
#include <wrl.h> #include <wrl.h>
#include <set> #include <set>
@ -60,7 +60,7 @@ enum
typedef struct _GstMFAacEnc typedef struct _GstMFAacEnc
{ {
GstMFAudioEnc parent; GstMFAudioEncoder parent;
/* properties */ /* properties */
guint bitrate; guint bitrate;
@ -68,7 +68,7 @@ typedef struct _GstMFAacEnc
typedef struct _GstMFAacEncClass typedef struct _GstMFAacEncClass
{ {
GstMFAudioEncClass parent_class; GstMFAudioEncoderClass parent_class;
} GstMFAacEncClass; } GstMFAacEncClass;
@ -90,11 +90,11 @@ static void gst_mf_aac_enc_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec); GValue * value, GParamSpec * pspec);
static void gst_mf_aac_enc_set_property (GObject * object, guint prop_id, static void gst_mf_aac_enc_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec); const GValue * value, GParamSpec * pspec);
static gboolean gst_mf_aac_enc_get_output_type (GstMFAudioEnc * mfenc, static gboolean gst_mf_aac_enc_get_output_type (GstMFAudioEncoder * encoder,
GstAudioInfo * info, IMFMediaType ** output_type); GstAudioInfo * info, IMFMediaType ** output_type);
static gboolean gst_mf_aac_enc_get_input_type (GstMFAudioEnc * mfenc, static gboolean gst_mf_aac_enc_get_input_type (GstMFAudioEncoder * encoder,
GstAudioInfo * info, IMFMediaType ** input_type); GstAudioInfo * info, IMFMediaType ** input_type);
static gboolean gst_mf_aac_enc_set_src_caps (GstMFAudioEnc * mfenc, static gboolean gst_mf_aac_enc_set_src_caps (GstMFAudioEncoder * encoder,
GstAudioInfo * info); GstAudioInfo * info);
static void static void
@ -102,7 +102,7 @@ gst_mf_aac_enc_class_init (GstMFAacEncClass * klass, gpointer data)
{ {
GObjectClass *gobject_class = G_OBJECT_CLASS (klass); GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
GstElementClass *element_class = GST_ELEMENT_CLASS (klass); GstElementClass *element_class = GST_ELEMENT_CLASS (klass);
GstMFAudioEncClass *mfenc_class = GST_MF_AUDIO_ENC_CLASS (klass); GstMFAudioEncoderClass *encoder_class = GST_MF_AUDIO_ENCODER_CLASS (klass);
GstMFAacEncClassData *cdata = (GstMFAacEncClassData *) data; GstMFAacEncClassData *cdata = (GstMFAacEncClassData *) data;
gchar *long_name; gchar *long_name;
gchar *classification; gchar *classification;
@ -149,16 +149,16 @@ gst_mf_aac_enc_class_init (GstMFAacEncClass * klass, gpointer data)
gst_pad_template_new ("src", GST_PAD_SRC, GST_PAD_ALWAYS, gst_pad_template_new ("src", GST_PAD_SRC, GST_PAD_ALWAYS,
cdata->src_caps)); cdata->src_caps));
mfenc_class->get_output_type = encoder_class->get_output_type =
GST_DEBUG_FUNCPTR (gst_mf_aac_enc_get_output_type); GST_DEBUG_FUNCPTR (gst_mf_aac_enc_get_output_type);
mfenc_class->get_input_type = encoder_class->get_input_type =
GST_DEBUG_FUNCPTR (gst_mf_aac_enc_get_input_type); GST_DEBUG_FUNCPTR (gst_mf_aac_enc_get_input_type);
mfenc_class->set_src_caps = GST_DEBUG_FUNCPTR (gst_mf_aac_enc_set_src_caps); encoder_class->set_src_caps = GST_DEBUG_FUNCPTR (gst_mf_aac_enc_set_src_caps);
mfenc_class->codec_id = MFAudioFormat_AAC; encoder_class->codec_id = MFAudioFormat_AAC;
mfenc_class->enum_flags = cdata->enum_flags; encoder_class->enum_flags = cdata->enum_flags;
mfenc_class->device_index = cdata->device_index; encoder_class->device_index = cdata->device_index;
mfenc_class->frame_samples = 1024; encoder_class->frame_samples = 1024;
g_free (cdata->device_name); g_free (cdata->device_name);
gst_caps_unref (cdata->sink_caps); gst_caps_unref (cdata->sink_caps);
@ -205,11 +205,11 @@ gst_mf_aac_enc_set_property (GObject * object, guint prop_id,
} }
static gboolean static gboolean
gst_mf_aac_enc_get_output_type (GstMFAudioEnc * mfenc, GstAudioInfo * info, gst_mf_aac_enc_get_output_type (GstMFAudioEncoder * encoder,
IMFMediaType ** output_type) GstAudioInfo * info, IMFMediaType ** output_type)
{ {
GstMFAacEnc *self = (GstMFAacEnc *) mfenc; GstMFAacEnc *self = (GstMFAacEnc *) encoder;
GstMFTransform *transform = mfenc->transform; GstMFTransform *transform = encoder->transform;
GList *output_list = nullptr; GList *output_list = nullptr;
GList *iter; GList *iter;
ComPtr < IMFMediaType > target_output; ComPtr < IMFMediaType > target_output;
@ -355,11 +355,11 @@ gst_mf_aac_enc_get_output_type (GstMFAudioEnc * mfenc, GstAudioInfo * info,
} }
static gboolean static gboolean
gst_mf_aac_enc_get_input_type (GstMFAudioEnc * mfenc, GstAudioInfo * info, gst_mf_aac_enc_get_input_type (GstMFAudioEncoder * encoder, GstAudioInfo * info,
IMFMediaType ** input_type) IMFMediaType ** input_type)
{ {
GstMFAacEnc *self = (GstMFAacEnc *) mfenc; GstMFAacEnc *self = (GstMFAacEnc *) encoder;
GstMFTransform *transform = mfenc->transform; GstMFTransform *transform = encoder->transform;
GList *input_list = nullptr; GList *input_list = nullptr;
GList *iter; GList *iter;
ComPtr < IMFMediaType > target_input; ComPtr < IMFMediaType > target_input;
@ -432,9 +432,9 @@ gst_mf_aac_enc_get_input_type (GstMFAudioEnc * mfenc, GstAudioInfo * info,
} }
static gboolean static gboolean
gst_mf_aac_enc_set_src_caps (GstMFAudioEnc * mfenc, GstAudioInfo * info) gst_mf_aac_enc_set_src_caps (GstMFAudioEncoder * encoder, GstAudioInfo * info)
{ {
GstMFAacEnc *self = (GstMFAacEnc *) mfenc; GstMFAacEnc *self = (GstMFAacEnc *) encoder;
HRESULT hr; HRESULT hr;
GstCaps *src_caps; GstCaps *src_caps;
GstBuffer *codec_data; GstBuffer *codec_data;
@ -444,7 +444,7 @@ gst_mf_aac_enc_set_src_caps (GstMFAudioEnc * mfenc, GstAudioInfo * info)
ComPtr < IMFMediaType > output_type; ComPtr < IMFMediaType > output_type;
static const guint config_data_offset = 12; static const guint config_data_offset = 12;
if (!gst_mf_transform_get_output_current_type (mfenc->transform, if (!gst_mf_transform_get_output_current_type (encoder->transform,
&output_type)) { &output_type)) {
GST_ERROR_OBJECT (self, "Couldn't get current output type"); GST_ERROR_OBJECT (self, "Couldn't get current output type");
return FALSE; return FALSE;
@ -546,7 +546,7 @@ gst_mf_aac_enc_register (GstPlugin * plugin, guint rank,
} }
type = type =
g_type_register_static (GST_TYPE_MF_AUDIO_ENC, type_name, &type_info, g_type_register_static (GST_TYPE_MF_AUDIO_ENCODER, type_name, &type_info,
(GTypeFlags) 0); (GTypeFlags) 0);
/* make lower rank than default device */ /* make lower rank than default device */

98
subprojects/gst-plugins-bad/sys/mediafoundation/gstmfaudioenc.cpp → subprojects/gst-plugins-bad/sys/mediafoundation/gstmfaudioencoder.cpp
View file

@ -22,7 +22,7 @@
#endif #endif
#include <gst/gst.h> #include <gst/gst.h>
#include "gstmfaudioenc.h" #include "gstmfaudioencoder.h"
#include <wrl.h> #include <wrl.h>
#include <string.h> #include <string.h>
@ -30,53 +30,54 @@
using namespace Microsoft::WRL; using namespace Microsoft::WRL;
/* *INDENT-ON* */ /* *INDENT-ON* */
GST_DEBUG_CATEGORY (gst_mf_audio_enc_debug); GST_DEBUG_CATEGORY (gst_mf_audio_encoder_debug);
#define GST_CAT_DEFAULT gst_mf_audio_enc_debug #define GST_CAT_DEFAULT gst_mf_audio_encoder_debug
#define gst_mf_audio_enc_parent_class parent_class #define gst_mf_audio_encoder_parent_class parent_class
G_DEFINE_ABSTRACT_TYPE_WITH_CODE (GstMFAudioEnc, gst_mf_audio_enc, G_DEFINE_ABSTRACT_TYPE_WITH_CODE (GstMFAudioEncoder, gst_mf_audio_encoder,
GST_TYPE_AUDIO_ENCODER, GST_TYPE_AUDIO_ENCODER,
GST_DEBUG_CATEGORY_INIT (gst_mf_audio_enc_debug, "mfaudioenc", 0, GST_DEBUG_CATEGORY_INIT (gst_mf_audio_encoder_debug, "mfaudioencoder", 0,
"mfaudioenc")); "mfaudioencoder"));
static gboolean gst_mf_audio_enc_open (GstAudioEncoder * enc); static gboolean gst_mf_audio_encoder_open (GstAudioEncoder * enc);
static gboolean gst_mf_audio_enc_close (GstAudioEncoder * enc); static gboolean gst_mf_audio_encoder_close (GstAudioEncoder * enc);
static gboolean gst_mf_audio_enc_set_format (GstAudioEncoder * enc, static gboolean gst_mf_audio_encoder_set_format (GstAudioEncoder * enc,
GstAudioInfo * info); GstAudioInfo * info);
static GstFlowReturn gst_mf_audio_enc_handle_frame (GstAudioEncoder * enc, static GstFlowReturn gst_mf_audio_encoder_handle_frame (GstAudioEncoder * enc,
GstBuffer * buffer); GstBuffer * buffer);
static GstFlowReturn gst_mf_audio_enc_drain (GstAudioEncoder * enc); static GstFlowReturn gst_mf_audio_encoder_drain (GstAudioEncoder * enc);
static void gst_mf_audio_enc_flush (GstAudioEncoder * enc); static void gst_mf_audio_encoder_flush (GstAudioEncoder * enc);
static void static void
gst_mf_audio_enc_class_init (GstMFAudioEncClass * klass) gst_mf_audio_encoder_class_init (GstMFAudioEncoderClass * klass)
{ {
GstAudioEncoderClass *audioenc_class = GST_AUDIO_ENCODER_CLASS (klass); GstAudioEncoderClass *audioenc_class = GST_AUDIO_ENCODER_CLASS (klass);
audioenc_class->open = GST_DEBUG_FUNCPTR (gst_mf_audio_enc_open); audioenc_class->open = GST_DEBUG_FUNCPTR (gst_mf_audio_encoder_open);
audioenc_class->close = GST_DEBUG_FUNCPTR (gst_mf_audio_enc_close); audioenc_class->close = GST_DEBUG_FUNCPTR (gst_mf_audio_encoder_close);
audioenc_class->set_format = GST_DEBUG_FUNCPTR (gst_mf_audio_enc_set_format); audioenc_class->set_format =
GST_DEBUG_FUNCPTR (gst_mf_audio_encoder_set_format);
audioenc_class->handle_frame = audioenc_class->handle_frame =
GST_DEBUG_FUNCPTR (gst_mf_audio_enc_handle_frame); GST_DEBUG_FUNCPTR (gst_mf_audio_encoder_handle_frame);
audioenc_class->flush = GST_DEBUG_FUNCPTR (gst_mf_audio_enc_flush); audioenc_class->flush = GST_DEBUG_FUNCPTR (gst_mf_audio_encoder_flush);
gst_type_mark_as_plugin_api (GST_TYPE_MF_AUDIO_ENC, (GstPluginAPIFlags) 0); gst_type_mark_as_plugin_api (GST_TYPE_MF_AUDIO_ENCODER,
(GstPluginAPIFlags) 0);
} }
static void static void
gst_mf_audio_enc_init (GstMFAudioEnc * self) gst_mf_audio_encoder_init (GstMFAudioEncoder * self)
{ {
gst_audio_encoder_set_drainable (GST_AUDIO_ENCODER (self), TRUE); gst_audio_encoder_set_drainable (GST_AUDIO_ENCODER (self), TRUE);
} }
static gboolean static gboolean
gst_mf_audio_enc_open (GstAudioEncoder * enc) gst_mf_audio_encoder_open (GstAudioEncoder * enc)
{ {
GstMFAudioEnc *self = GST_MF_AUDIO_ENC (enc); GstMFAudioEncoder *self = GST_MF_AUDIO_ENCODER (enc);
GstMFAudioEncClass *klass = GST_MF_AUDIO_ENC_GET_CLASS (enc); GstMFAudioEncoderClass *klass = GST_MF_AUDIO_ENCODER_GET_CLASS (enc);
GstMFTransformEnumParams enum_params = { 0, }; GstMFTransformEnumParams enum_params = { 0, };
MFT_REGISTER_TYPE_INFO output_type; MFT_REGISTER_TYPE_INFO output_type;
gboolean ret;
output_type.guidMajorType = MFMediaType_Audio; output_type.guidMajorType = MFMediaType_Audio;
output_type.guidSubtype = klass->codec_id; output_type.guidSubtype = klass->codec_id;
@ -90,18 +91,18 @@ gst_mf_audio_enc_open (GstAudioEncoder * enc)
klass->enum_flags, klass->device_index); klass->enum_flags, klass->device_index);
self->transform = gst_mf_transform_new (&enum_params); self->transform = gst_mf_transform_new (&enum_params);
ret = !!self->transform; if (!self->transform) {
if (!ret)
GST_ERROR_OBJECT (self, "Cannot create MFT object"); GST_ERROR_OBJECT (self, "Cannot create MFT object");
return FALSE;
}
return ret; return TRUE;
} }
static gboolean static gboolean
gst_mf_audio_enc_close (GstAudioEncoder * enc) gst_mf_audio_encoder_close (GstAudioEncoder * enc)
{ {
GstMFAudioEnc *self = GST_MF_AUDIO_ENC (enc); GstMFAudioEncoder *self = GST_MF_AUDIO_ENCODER (enc);
gst_clear_object (&self->transform); gst_clear_object (&self->transform);
@ -109,16 +110,16 @@ gst_mf_audio_enc_close (GstAudioEncoder * enc)
} }
static gboolean static gboolean
gst_mf_audio_enc_set_format (GstAudioEncoder * enc, GstAudioInfo * info) gst_mf_audio_encoder_set_format (GstAudioEncoder * enc, GstAudioInfo * info)
{ {
GstMFAudioEnc *self = GST_MF_AUDIO_ENC (enc); GstMFAudioEncoder *self = GST_MF_AUDIO_ENCODER (enc);
GstMFAudioEncClass *klass = GST_MF_AUDIO_ENC_GET_CLASS (enc); GstMFAudioEncoderClass *klass = GST_MF_AUDIO_ENCODER_GET_CLASS (enc);
ComPtr < IMFMediaType > in_type; ComPtr < IMFMediaType > in_type;
ComPtr < IMFMediaType > out_type; ComPtr < IMFMediaType > out_type;
GST_DEBUG_OBJECT (self, "Set format"); GST_DEBUG_OBJECT (self, "Set format");
gst_mf_audio_enc_drain (enc); gst_mf_audio_encoder_drain (enc);
if (!gst_mf_transform_open (self->transform)) { if (!gst_mf_transform_open (self->transform)) {
GST_ERROR_OBJECT (self, "Failed to open MFT"); GST_ERROR_OBJECT (self, "Failed to open MFT");
@ -173,7 +174,8 @@ gst_mf_audio_enc_set_format (GstAudioEncoder * enc, GstAudioInfo * info)
} }
static gboolean static gboolean
gst_mf_audio_enc_process_input (GstMFAudioEnc * self, GstBuffer * buffer) gst_mf_audio_encoder_process_input (GstMFAudioEncoder * self,
GstBuffer * buffer)
{ {
HRESULT hr; HRESULT hr;
ComPtr < IMFSample > sample; ComPtr < IMFSample > sample;
@ -240,9 +242,9 @@ done:
} }
static GstFlowReturn static GstFlowReturn
gst_mf_audio_enc_process_output (GstMFAudioEnc * self) gst_mf_audio_encoder_process_output (GstMFAudioEncoder * self)
{ {
GstMFAudioEncClass *klass = GST_MF_AUDIO_ENC_GET_CLASS (self); GstMFAudioEncoderClass *klass = GST_MF_AUDIO_ENCODER_GET_CLASS (self);
HRESULT hr; HRESULT hr;
BYTE *data = nullptr; BYTE *data = nullptr;
ComPtr < IMFMediaBuffer > media_buffer; ComPtr < IMFMediaBuffer > media_buffer;
@ -281,21 +283,21 @@ gst_mf_audio_enc_process_output (GstMFAudioEnc * self)
} }
static GstFlowReturn static GstFlowReturn
gst_mf_audio_enc_handle_frame (GstAudioEncoder * enc, GstBuffer * buffer) gst_mf_audio_encoder_handle_frame (GstAudioEncoder * enc, GstBuffer * buffer)
{ {
GstMFAudioEnc *self = GST_MF_AUDIO_ENC (enc); GstMFAudioEncoder *self = GST_MF_AUDIO_ENCODER (enc);
GstFlowReturn ret; GstFlowReturn ret;
if (!buffer) if (!buffer)
return gst_mf_audio_enc_drain (enc); return gst_mf_audio_encoder_drain (enc);
if (!gst_mf_audio_enc_process_input (self, buffer)) { if (!gst_mf_audio_encoder_process_input (self, buffer)) {
GST_ERROR_OBJECT (self, "Failed to process input"); GST_ERROR_OBJECT (self, "Failed to process input");
return GST_FLOW_ERROR; return GST_FLOW_ERROR;
} }
do { do {
ret = gst_mf_audio_enc_process_output (self); ret = gst_mf_audio_encoder_process_output (self);
} while (ret == GST_FLOW_OK); } while (ret == GST_FLOW_OK);
if (ret == GST_MF_TRANSFORM_FLOW_NEED_DATA) if (ret == GST_MF_TRANSFORM_FLOW_NEED_DATA)
@ -305,9 +307,9 @@ gst_mf_audio_enc_handle_frame (GstAudioEncoder * enc, GstBuffer * buffer)
} }
static GstFlowReturn static GstFlowReturn
gst_mf_audio_enc_drain (GstAudioEncoder * enc) gst_mf_audio_encoder_drain (GstAudioEncoder * enc)
{ {
GstMFAudioEnc *self = GST_MF_AUDIO_ENC (enc); GstMFAudioEncoder *self = GST_MF_AUDIO_ENCODER (enc);
GstFlowReturn ret = GST_FLOW_OK; GstFlowReturn ret = GST_FLOW_OK;
if (!self->transform) if (!self->transform)
@ -316,7 +318,7 @@ gst_mf_audio_enc_drain (GstAudioEncoder * enc)
gst_mf_transform_drain (self->transform); gst_mf_transform_drain (self->transform);
do { do {
ret = gst_mf_audio_enc_process_output (self); ret = gst_mf_audio_encoder_process_output (self);
} while (ret == GST_FLOW_OK); } while (ret == GST_FLOW_OK);
if (ret == GST_MF_TRANSFORM_FLOW_NEED_DATA) if (ret == GST_MF_TRANSFORM_FLOW_NEED_DATA)
@ -326,9 +328,9 @@ gst_mf_audio_enc_drain (GstAudioEncoder * enc)
} }
static void static void
gst_mf_audio_enc_flush (GstAudioEncoder * enc) gst_mf_audio_encoder_flush (GstAudioEncoder * enc)
{ {
GstMFAudioEnc *self = GST_MF_AUDIO_ENC (enc); GstMFAudioEncoder *self = GST_MF_AUDIO_ENCODER (enc);
if (!self->transform) if (!self->transform)
return; return;

32
subprojects/gst-plugins-bad/sys/mediafoundation/gstmfaudioenc.h → subprojects/gst-plugins-bad/sys/mediafoundation/gstmfaudioencoder.h
View file

@ -17,8 +17,7 @@
* Boston, MA 02110-1301, USA. * Boston, MA 02110-1301, USA.
*/ */
#ifndef __GST_MF_AUDIO_ENC_H__ #pragma once
#define __GST_MF_AUDIO_ENC_H__
#include <gst/gst.h> #include <gst/gst.h>
#include <gst/audio/audio.h> #include <gst/audio/audio.h>
@ -27,17 +26,17 @@
G_BEGIN_DECLS G_BEGIN_DECLS
#define GST_TYPE_MF_AUDIO_ENC (gst_mf_audio_enc_get_type()) #define GST_TYPE_MF_AUDIO_ENCODER (gst_mf_audio_encoder_get_type())
#define GST_MF_AUDIO_ENC(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_MF_AUDIO_ENC,GstMFAudioEnc)) #define GST_MF_AUDIO_ENCODER(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_MF_AUDIO_ENCODER,GstMFAudioEncoder))
#define GST_MF_AUDIO_ENC_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), GST_TYPE_MF_AUDIO_ENC,GstMFAudioEncClass)) #define GST_MF_AUDIO_ENCODER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), GST_TYPE_MF_AUDIO_ENCODER,GstMFAudioEncoderClass))
#define GST_MF_AUDIO_ENC_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), GST_TYPE_MF_AUDIO_ENC,GstMFAudioEncClass)) #define GST_MF_AUDIO_ENCODER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), GST_TYPE_MF_AUDIO_ENCODER,GstMFAudioEncoderClass))
#define GST_IS_MF_AUDIO_ENC(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_MF_AUDIO_ENC)) #define GST_IS_MF_AUDIO_ENCODER(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_MF_AUDIO_ENCODER))
#define GST_IS_MF_AUDIO_ENC_CLASS(obj) (G_TYPE_CHECK_CLASS_TYPE((klass), GST_TYPE_MF_AUDIO_ENC)) #define GST_IS_MF_AUDIO_ENCODER_CLASS(obj) (G_TYPE_CHECK_CLASS_TYPE((klass), GST_TYPE_MF_AUDIO_ENCODER))
typedef struct _GstMFAudioEnc GstMFAudioEnc; typedef struct _GstMFAudioEncoder GstMFAudioEncoder;
typedef struct _GstMFAudioEncClass GstMFAudioEncClass; typedef struct _GstMFAudioEncoderClass GstMFAudioEncoderClass;
struct _GstMFAudioEnc struct _GstMFAudioEncoder
{ {
GstAudioEncoder parent; GstAudioEncoder parent;
@ -46,7 +45,7 @@ struct _GstMFAudioEnc
guint64 sample_count; guint64 sample_count;
}; };
struct _GstMFAudioEncClass struct _GstMFAudioEncoderClass
{ {
GstAudioEncoderClass parent_class; GstAudioEncoderClass parent_class;
@ -55,20 +54,19 @@ struct _GstMFAudioEncClass
guint device_index; guint device_index;
gint frame_samples; gint frame_samples;
gboolean (*get_output_type) (GstMFAudioEnc * mfenc, gboolean (*get_output_type) (GstMFAudioEncoder * encoder,
GstAudioInfo * info, GstAudioInfo * info,
IMFMediaType ** output_type); IMFMediaType ** output_type);
gboolean (*get_input_type) (GstMFAudioEnc * mfenc, gboolean (*get_input_type) (GstMFAudioEncoder * encoder,
GstAudioInfo * info, GstAudioInfo * info,
IMFMediaType ** input_type); IMFMediaType ** input_type);
gboolean (*set_src_caps) (GstMFAudioEnc * mfenc, gboolean (*set_src_caps) (GstMFAudioEncoder * encoder,
GstAudioInfo * info); GstAudioInfo * info);
}; };
GType gst_mf_audio_enc_get_type (void); GType gst_mf_audio_encoder_get_type (void);
G_END_DECLS G_END_DECLS
#endif /* __GST_MF_AUDIO_ENC_H__ */

31
subprojects/gst-plugins-bad/sys/mediafoundation/gstmfh264enc.cpp
View file

@ -39,7 +39,7 @@
#include <gst/gst.h> #include <gst/gst.h>
#include <gst/pbutils/pbutils.h> #include <gst/pbutils/pbutils.h>
#include "gstmfvideoenc.h" #include "gstmfvideoencoder.h"
#include "gstmfh264enc.h" #include "gstmfh264enc.h"
#include <wrl.h> #include <wrl.h>
@ -191,7 +191,7 @@ enum
typedef struct _GstMFH264Enc typedef struct _GstMFH264Enc
{ {
GstMFVideoEnc parent; GstMFVideoEncoder parent;
/* properties */ /* properties */
guint bitrate; guint bitrate;
@ -223,7 +223,7 @@ typedef struct _GstMFH264Enc
typedef struct _GstMFH264EncClass typedef struct _GstMFH264EncClass
{ {
GstMFVideoEncClass parent_class; GstMFVideoEncoderClass parent_class;
} GstMFH264EncClass; } GstMFH264EncClass;
static GstElementClass *parent_class = nullptr; static GstElementClass *parent_class = nullptr;
@ -233,9 +233,9 @@ static void gst_mf_h264_enc_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec); GValue * value, GParamSpec * pspec);
static void gst_mf_h264_enc_set_property (GObject * object, guint prop_id, static void gst_mf_h264_enc_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec); const GValue * value, GParamSpec * pspec);
static gboolean gst_mf_h264_enc_set_option (GstMFVideoEnc * mfenc, static gboolean gst_mf_h264_enc_set_option (GstMFVideoEncoder * mfenc,
GstVideoCodecState * state, IMFMediaType * output_type); GstVideoCodecState * state, IMFMediaType * output_type);
static gboolean gst_mf_h264_enc_set_src_caps (GstMFVideoEnc * mfenc, static gboolean gst_mf_h264_enc_set_src_caps (GstMFVideoEncoder * mfenc,
GstVideoCodecState * state, IMFMediaType * output_type); GstVideoCodecState * state, IMFMediaType * output_type);
static void static void
@ -243,9 +243,9 @@ gst_mf_h264_enc_class_init (GstMFH264EncClass * klass, gpointer data)
{ {
GObjectClass *gobject_class = G_OBJECT_CLASS (klass); GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
GstElementClass *element_class = GST_ELEMENT_CLASS (klass); GstElementClass *element_class = GST_ELEMENT_CLASS (klass);
GstMFVideoEncClass *mfenc_class = GST_MF_VIDEO_ENC_CLASS (klass); GstMFVideoEncoderClass *mfenc_class = GST_MF_VIDEO_ENCODER_CLASS (klass);
GstMFVideoEncClassData *cdata = (GstMFVideoEncClassData *) data; GstMFVideoEncoderClassData *cdata = (GstMFVideoEncoderClassData *) data;
GstMFVideoEncDeviceCaps *device_caps = &cdata->device_caps; GstMFVideoEncoderDeviceCaps *device_caps = &cdata->device_caps;
gchar *long_name; gchar *long_name;
gchar *classification; gchar *classification;
@ -571,7 +571,7 @@ gst_mf_h264_enc_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec) GValue * value, GParamSpec * pspec)
{ {
GstMFH264Enc *self = (GstMFH264Enc *) (object); GstMFH264Enc *self = (GstMFH264Enc *) (object);
GstMFVideoEncClass *klass = GST_MF_VIDEO_ENC_GET_CLASS (object); GstMFVideoEncoderClass *klass = GST_MF_VIDEO_ENCODER_GET_CLASS (object);
switch (prop_id) { switch (prop_id) {
case PROP_BITRATE: case PROP_BITRATE:
@ -782,12 +782,12 @@ gst_mf_h264_enc_content_type_to_enum (guint rc_mode)
} G_STMT_END } G_STMT_END
static gboolean static gboolean
gst_mf_h264_enc_set_option (GstMFVideoEnc * mfenc, GstVideoCodecState * state, gst_mf_h264_enc_set_option (GstMFVideoEncoder * mfenc,
IMFMediaType * output_type) GstVideoCodecState * state, IMFMediaType * output_type)
{ {
GstMFH264Enc *self = (GstMFH264Enc *) mfenc; GstMFH264Enc *self = (GstMFH264Enc *) mfenc;
GstMFVideoEncClass *klass = GST_MF_VIDEO_ENC_GET_CLASS (mfenc); GstMFVideoEncoderClass *klass = GST_MF_VIDEO_ENCODER_GET_CLASS (mfenc);
GstMFVideoEncDeviceCaps *device_caps = &klass->device_caps; GstMFVideoEncoderDeviceCaps *device_caps = &klass->device_caps;
HRESULT hr; HRESULT hr;
GstCaps *allowed_caps, *template_caps; GstCaps *allowed_caps, *template_caps;
eAVEncH264VProfile selected_profile = eAVEncH264VProfile_Main; eAVEncH264VProfile selected_profile = eAVEncH264VProfile_Main;
@ -1022,7 +1022,7 @@ gst_mf_h264_enc_set_option (GstMFVideoEnc * mfenc, GstVideoCodecState * state,
} }
static gboolean static gboolean
gst_mf_h264_enc_set_src_caps (GstMFVideoEnc * mfenc, gst_mf_h264_enc_set_src_caps (GstMFVideoEncoder * mfenc,
GstVideoCodecState * state, IMFMediaType * output_type) GstVideoCodecState * state, IMFMediaType * output_type)
{ {
GstMFH264Enc *self = (GstMFH264Enc *) mfenc; GstMFH264Enc *self = (GstMFH264Enc *) mfenc;
@ -1076,5 +1076,6 @@ gst_mf_h264_enc_plugin_init (GstPlugin * plugin, guint rank,
GST_DEBUG_CATEGORY_INIT (gst_mf_h264_enc_debug, "mfh264enc", 0, "mfh264enc"); GST_DEBUG_CATEGORY_INIT (gst_mf_h264_enc_debug, "mfh264enc", 0, "mfh264enc");
gst_mf_video_enc_register (plugin, rank, &subtype, &type_info, d3d11_device); gst_mf_video_encoder_register (plugin,
rank, &subtype, &type_info, d3d11_device);
} }

58
subprojects/gst-plugins-bad/sys/mediafoundation/gstmfh265enc.cpp
View file

@ -36,7 +36,7 @@
#endif #endif
#include <gst/gst.h> #include <gst/gst.h>
#include "gstmfvideoenc.h" #include "gstmfvideoencoder.h"
#include "gstmfh265enc.h" #include "gstmfh265enc.h"
#include <wrl.h> #include <wrl.h>
@ -142,7 +142,7 @@ enum
typedef struct _GstMFH265Enc typedef struct _GstMFH265Enc
{ {
GstMFVideoEnc parent; GstMFVideoEncoder parent;
/* properties */ /* properties */
guint bitrate; guint bitrate;
@ -168,7 +168,7 @@ typedef struct _GstMFH265Enc
typedef struct _GstMFH265EncClass typedef struct _GstMFH265EncClass
{ {
GstMFVideoEncClass parent_class; GstMFVideoEncoderClass parent_class;
} GstMFH265EncClass; } GstMFH265EncClass;
static GstElementClass *parent_class = nullptr; static GstElementClass *parent_class = nullptr;
@ -177,9 +177,9 @@ static void gst_mf_h265_enc_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec); GValue * value, GParamSpec * pspec);
static void gst_mf_h265_enc_set_property (GObject * object, guint prop_id, static void gst_mf_h265_enc_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec); const GValue * value, GParamSpec * pspec);
static gboolean gst_mf_h265_enc_set_option (GstMFVideoEnc * mfenc, static gboolean gst_mf_h265_enc_set_option (GstMFVideoEncoder * encoder,
GstVideoCodecState * state, IMFMediaType * output_type); GstVideoCodecState * state, IMFMediaType * output_type);
static gboolean gst_mf_h265_enc_set_src_caps (GstMFVideoEnc * mfenc, static gboolean gst_mf_h265_enc_set_src_caps (GstMFVideoEncoder * encoder,
GstVideoCodecState * state, IMFMediaType * output_type); GstVideoCodecState * state, IMFMediaType * output_type);
static void static void
@ -187,9 +187,9 @@ gst_mf_h265_enc_class_init (GstMFH265EncClass * klass, gpointer data)
{ {
GObjectClass *gobject_class = G_OBJECT_CLASS (klass); GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
GstElementClass *element_class = GST_ELEMENT_CLASS (klass); GstElementClass *element_class = GST_ELEMENT_CLASS (klass);
GstMFVideoEncClass *mfenc_class = GST_MF_VIDEO_ENC_CLASS (klass); GstMFVideoEncoderClass *encoder_class = GST_MF_VIDEO_ENCODER_CLASS (klass);
GstMFVideoEncClassData *cdata = (GstMFVideoEncClassData *) data; GstMFVideoEncoderClassData *cdata = (GstMFVideoEncoderClassData *) data;
GstMFVideoEncDeviceCaps *device_caps = &cdata->device_caps; GstMFVideoEncoderDeviceCaps *device_caps = &cdata->device_caps;
gchar *long_name; gchar *long_name;
gchar *classification; gchar *classification;
@ -404,13 +404,14 @@ gst_mf_h265_enc_class_init (GstMFH265EncClass * klass, gpointer data)
gst_pad_template_new ("src", GST_PAD_SRC, GST_PAD_ALWAYS, gst_pad_template_new ("src", GST_PAD_SRC, GST_PAD_ALWAYS,
cdata->src_caps)); cdata->src_caps));
mfenc_class->set_option = GST_DEBUG_FUNCPTR (gst_mf_h265_enc_set_option); encoder_class->set_option = GST_DEBUG_FUNCPTR (gst_mf_h265_enc_set_option);
mfenc_class->set_src_caps = GST_DEBUG_FUNCPTR (gst_mf_h265_enc_set_src_caps); encoder_class->set_src_caps =
GST_DEBUG_FUNCPTR (gst_mf_h265_enc_set_src_caps);
mfenc_class->codec_id = MFVideoFormat_HEVC; encoder_class->codec_id = MFVideoFormat_HEVC;
mfenc_class->enum_flags = cdata->enum_flags; encoder_class->enum_flags = cdata->enum_flags;
mfenc_class->device_index = cdata->device_index; encoder_class->device_index = cdata->device_index;
mfenc_class->device_caps = *device_caps; encoder_class->device_caps = *device_caps;
g_free (cdata->device_name); g_free (cdata->device_name);
gst_caps_unref (cdata->sink_caps); gst_caps_unref (cdata->sink_caps);
@ -444,7 +445,7 @@ gst_mf_h265_enc_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec) GValue * value, GParamSpec * pspec)
{ {
GstMFH265Enc *self = (GstMFH265Enc *) (object); GstMFH265Enc *self = (GstMFH265Enc *) (object);
GstMFVideoEncClass *klass = GST_MF_VIDEO_ENC_GET_CLASS (object); GstMFVideoEncoderClass *klass = GST_MF_VIDEO_ENCODER_GET_CLASS (object);
switch (prop_id) { switch (prop_id) {
case PROP_BITRATE: case PROP_BITRATE:
@ -608,20 +609,20 @@ gst_mf_h265_enc_content_type_to_enum (guint rc_mode)
} G_STMT_END } G_STMT_END
static gboolean static gboolean
gst_mf_h265_enc_set_option (GstMFVideoEnc * mfenc, GstVideoCodecState * state, gst_mf_h265_enc_set_option (GstMFVideoEncoder * encoder,
IMFMediaType * output_type) GstVideoCodecState * state, IMFMediaType * output_type)
{ {
GstMFH265Enc *self = (GstMFH265Enc *) mfenc; GstMFH265Enc *self = (GstMFH265Enc *) encoder;
GstMFVideoEncClass *klass = GST_MF_VIDEO_ENC_GET_CLASS (mfenc); GstMFVideoEncoderClass *klass = GST_MF_VIDEO_ENCODER_GET_CLASS (encoder);
GstMFVideoEncDeviceCaps *device_caps = &klass->device_caps; GstMFVideoEncoderDeviceCaps *device_caps = &klass->device_caps;
HRESULT hr; HRESULT hr;
GstMFTransform *transform = mfenc->transform; GstMFTransform *transform = encoder->transform;
hr = output_type->SetGUID (MF_MT_SUBTYPE, MFVideoFormat_HEVC); hr = output_type->SetGUID (MF_MT_SUBTYPE, MFVideoFormat_HEVC);
if (!gst_mf_result (hr)) if (!gst_mf_result (hr))
return FALSE; return FALSE;
if (GST_VIDEO_INFO_FORMAT (&mfenc->input_state->info) == if (GST_VIDEO_INFO_FORMAT (&encoder->input_state->info) ==
GST_VIDEO_FORMAT_P010_10LE) { GST_VIDEO_FORMAT_P010_10LE) {
hr = output_type->SetUINT32 (MF_MT_MPEG2_PROFILE, hr = output_type->SetUINT32 (MF_MT_MPEG2_PROFILE,
eAVEncH265VProfile_Main_420_10); eAVEncH265VProfile_Main_420_10);
@ -667,12 +668,12 @@ gst_mf_h265_enc_set_option (GstMFVideoEnc * mfenc, GstVideoCodecState * state,
WARNING_HR (hr, CODECAPI_AVEncCommonQualityVsSpeed); WARNING_HR (hr, CODECAPI_AVEncCommonQualityVsSpeed);
} }
mfenc->has_reorder_frame = FALSE; encoder->has_reorder_frame = FALSE;
if (device_caps->bframes) { if (device_caps->bframes) {
hr = gst_mf_transform_set_codec_api_uint32 (transform, hr = gst_mf_transform_set_codec_api_uint32 (transform,
&CODECAPI_AVEncMPVDefaultBPictureCount, self->bframes); &CODECAPI_AVEncMPVDefaultBPictureCount, self->bframes);
if (SUCCEEDED (hr) && self->bframes > 0) if (SUCCEEDED (hr) && self->bframes > 0)
mfenc->has_reorder_frame = TRUE; encoder->has_reorder_frame = TRUE;
WARNING_HR (hr, CODECAPI_AVEncMPVDefaultBPictureCount); WARNING_HR (hr, CODECAPI_AVEncMPVDefaultBPictureCount);
} }
@ -761,10 +762,10 @@ gst_mf_h265_enc_set_option (GstMFVideoEnc * mfenc, GstVideoCodecState * state,
} }
static gboolean static gboolean
gst_mf_h265_enc_set_src_caps (GstMFVideoEnc * mfenc, gst_mf_h265_enc_set_src_caps (GstMFVideoEncoder * encoder,
GstVideoCodecState * state, IMFMediaType * output_type) GstVideoCodecState * state, IMFMediaType * output_type)
{ {
GstMFH265Enc *self = (GstMFH265Enc *) mfenc; GstMFH265Enc *self = (GstMFH265Enc *) encoder;
GstVideoCodecState *out_state; GstVideoCodecState *out_state;
GstStructure *s; GstStructure *s;
GstCaps *out_caps; GstCaps *out_caps;
@ -776,7 +777,7 @@ gst_mf_h265_enc_set_src_caps (GstMFVideoEnc * mfenc,
gst_structure_set (s, "stream-format", G_TYPE_STRING, "byte-stream", gst_structure_set (s, "stream-format", G_TYPE_STRING, "byte-stream",
"alignment", G_TYPE_STRING, "au", nullptr); "alignment", G_TYPE_STRING, "au", nullptr);
if (GST_VIDEO_INFO_FORMAT (&mfenc->input_state->info) == if (GST_VIDEO_INFO_FORMAT (&encoder->input_state->info) ==
GST_VIDEO_FORMAT_P010_10LE) { GST_VIDEO_FORMAT_P010_10LE) {
gst_structure_set (s, "profile", G_TYPE_STRING, "main-10", nullptr); gst_structure_set (s, "profile", G_TYPE_STRING, "main-10", nullptr);
} else { } else {
@ -821,5 +822,6 @@ gst_mf_h265_enc_plugin_init (GstPlugin * plugin, guint rank,
GST_DEBUG_CATEGORY_INIT (gst_mf_h265_enc_debug, "mfh265enc", 0, "mfh265enc"); GST_DEBUG_CATEGORY_INIT (gst_mf_h265_enc_debug, "mfh265enc", 0, "mfh265enc");
gst_mf_video_enc_register (plugin, rank, &subtype, &type_info, d3d11_device); gst_mf_video_encoder_register (plugin,
rank, &subtype, &type_info, d3d11_device);
} }

50
subprojects/gst-plugins-bad/sys/mediafoundation/gstmfmp3enc.cpp
View file

@ -36,7 +36,7 @@
#include <gst/gst.h> #include <gst/gst.h>
#include <gst/pbutils/pbutils.h> #include <gst/pbutils/pbutils.h>
#include "gstmfaudioenc.h" #include "gstmfaudioencoder.h"
#include "gstmfmp3enc.h" #include "gstmfmp3enc.h"
#include <wrl.h> #include <wrl.h>
#include <set> #include <set>
@ -60,7 +60,7 @@ enum
typedef struct _GstMFMp3Enc typedef struct _GstMFMp3Enc
{ {
GstMFAudioEnc parent; GstMFAudioEncoder parent;
/* properties */ /* properties */
guint bitrate; guint bitrate;
@ -68,7 +68,7 @@ typedef struct _GstMFMp3Enc
typedef struct _GstMFMp3EncClass typedef struct _GstMFMp3EncClass
{ {
GstMFAudioEncClass parent_class; GstMFAudioEncoderClass parent_class;
} GstMFMp3EncClass; } GstMFMp3EncClass;
@ -90,11 +90,11 @@ static void gst_mf_mp3_enc_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec); GValue * value, GParamSpec * pspec);
static void gst_mf_mp3_enc_set_property (GObject * object, guint prop_id, static void gst_mf_mp3_enc_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec); const GValue * value, GParamSpec * pspec);
static gboolean gst_mf_mp3_enc_get_output_type (GstMFAudioEnc * mfenc, static gboolean gst_mf_mp3_enc_get_output_type (GstMFAudioEncoder * encoder,
GstAudioInfo * info, IMFMediaType ** output_type); GstAudioInfo * info, IMFMediaType ** output_type);
static gboolean gst_mf_mp3_enc_get_input_type (GstMFAudioEnc * mfenc, static gboolean gst_mf_mp3_enc_get_input_type (GstMFAudioEncoder * encoder,
GstAudioInfo * info, IMFMediaType ** input_type); GstAudioInfo * info, IMFMediaType ** input_type);
static gboolean gst_mf_mp3_enc_set_src_caps (GstMFAudioEnc * mfenc, static gboolean gst_mf_mp3_enc_set_src_caps (GstMFAudioEncoder * encoder,
GstAudioInfo * info); GstAudioInfo * info);
static void static void
@ -102,7 +102,7 @@ gst_mf_mp3_enc_class_init (GstMFMp3EncClass * klass, gpointer data)
{ {
GObjectClass *gobject_class = G_OBJECT_CLASS (klass); GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
GstElementClass *element_class = GST_ELEMENT_CLASS (klass); GstElementClass *element_class = GST_ELEMENT_CLASS (klass);
GstMFAudioEncClass *mfenc_class = GST_MF_AUDIO_ENC_CLASS (klass); GstMFAudioEncoderClass *encoder_class = GST_MF_AUDIO_ENCODER_CLASS (klass);
GstMFMp3EncClassData *cdata = (GstMFMp3EncClassData *) data; GstMFMp3EncClassData *cdata = (GstMFMp3EncClassData *) data;
gchar *long_name; gchar *long_name;
gchar *classification; gchar *classification;
@ -149,16 +149,16 @@ gst_mf_mp3_enc_class_init (GstMFMp3EncClass * klass, gpointer data)
gst_pad_template_new ("src", GST_PAD_SRC, GST_PAD_ALWAYS, gst_pad_template_new ("src", GST_PAD_SRC, GST_PAD_ALWAYS,
cdata->src_caps)); cdata->src_caps));
mfenc_class->get_output_type = encoder_class->get_output_type =
GST_DEBUG_FUNCPTR (gst_mf_mp3_enc_get_output_type); GST_DEBUG_FUNCPTR (gst_mf_mp3_enc_get_output_type);
mfenc_class->get_input_type = encoder_class->get_input_type =
GST_DEBUG_FUNCPTR (gst_mf_mp3_enc_get_input_type); GST_DEBUG_FUNCPTR (gst_mf_mp3_enc_get_input_type);
mfenc_class->set_src_caps = GST_DEBUG_FUNCPTR (gst_mf_mp3_enc_set_src_caps); encoder_class->set_src_caps = GST_DEBUG_FUNCPTR (gst_mf_mp3_enc_set_src_caps);
mfenc_class->codec_id = MFAudioFormat_MP3; encoder_class->codec_id = MFAudioFormat_MP3;
mfenc_class->enum_flags = cdata->enum_flags; encoder_class->enum_flags = cdata->enum_flags;
mfenc_class->device_index = cdata->device_index; encoder_class->device_index = cdata->device_index;
mfenc_class->frame_samples = 1152; encoder_class->frame_samples = 1152;
g_free (cdata->device_name); g_free (cdata->device_name);
gst_caps_unref (cdata->sink_caps); gst_caps_unref (cdata->sink_caps);
@ -205,11 +205,11 @@ gst_mf_mp3_enc_set_property (GObject * object, guint prop_id,
} }
static gboolean static gboolean
gst_mf_mp3_enc_get_output_type (GstMFAudioEnc * mfenc, GstAudioInfo * info, gst_mf_mp3_enc_get_output_type (GstMFAudioEncoder * encoder,
IMFMediaType ** output_type) GstAudioInfo * info, IMFMediaType ** output_type)
{ {
GstMFMp3Enc *self = (GstMFMp3Enc *) mfenc; GstMFMp3Enc *self = (GstMFMp3Enc *) encoder;
GstMFTransform *transform = mfenc->transform; GstMFTransform *transform = encoder->transform;
GList *output_list = nullptr; GList *output_list = nullptr;
GList *iter; GList *iter;
ComPtr < IMFMediaType > target_output; ComPtr < IMFMediaType > target_output;
@ -339,11 +339,11 @@ gst_mf_mp3_enc_get_output_type (GstMFAudioEnc * mfenc, GstAudioInfo * info,
} }
static gboolean static gboolean
gst_mf_mp3_enc_get_input_type (GstMFAudioEnc * mfenc, GstAudioInfo * info, gst_mf_mp3_enc_get_input_type (GstMFAudioEncoder * encoder, GstAudioInfo * info,
IMFMediaType ** input_type) IMFMediaType ** input_type)
{ {
GstMFMp3Enc *self = (GstMFMp3Enc *) mfenc; GstMFMp3Enc *self = (GstMFMp3Enc *) encoder;
GstMFTransform *transform = mfenc->transform; GstMFTransform *transform = encoder->transform;
GList *input_list = nullptr; GList *input_list = nullptr;
GList *iter; GList *iter;
ComPtr < IMFMediaType > target_input; ComPtr < IMFMediaType > target_input;
@ -416,15 +416,15 @@ gst_mf_mp3_enc_get_input_type (GstMFAudioEnc * mfenc, GstAudioInfo * info,
} }
static gboolean static gboolean
gst_mf_mp3_enc_set_src_caps (GstMFAudioEnc * mfenc, GstAudioInfo * info) gst_mf_mp3_enc_set_src_caps (GstMFAudioEncoder * encoder, GstAudioInfo * info)
{ {
GstMFMp3Enc *self = (GstMFMp3Enc *) mfenc; GstMFMp3Enc *self = (GstMFMp3Enc *) encoder;
GstCaps *src_caps; GstCaps *src_caps;
gboolean ret; gboolean ret;
ComPtr < IMFMediaType > output_type; ComPtr < IMFMediaType > output_type;
gint version = 1; gint version = 1;
if (!gst_mf_transform_get_output_current_type (mfenc->transform, if (!gst_mf_transform_get_output_current_type (encoder->transform,
&output_type)) { &output_type)) {
GST_ERROR_OBJECT (self, "Couldn't get current output type"); GST_ERROR_OBJECT (self, "Couldn't get current output type");
return FALSE; return FALSE;
@ -502,7 +502,7 @@ gst_mf_mp3_enc_register (GstPlugin * plugin, guint rank,
} }
type = type =
g_type_register_static (GST_TYPE_MF_AUDIO_ENC, type_name, &type_info, g_type_register_static (GST_TYPE_MF_AUDIO_ENCODER, type_name, &type_info,
(GTypeFlags) 0); (GTypeFlags) 0);
/* make lower rank than default device */ /* make lower rank than default device */

13
subprojects/gst-plugins-bad/sys/mediafoundation/gstmfsourcereader.cpp
View file

@ -244,10 +244,13 @@ gst_mf_enum_media_type_from_source_reader (IMFSourceReader * source_reader,
} }
done: done:
if (!list)
return FALSE;
list = g_list_reverse (list); list = g_list_reverse (list);
*media_types = list; *media_types = list;
return !!list; return TRUE;
} }
static void static void
@ -935,12 +938,14 @@ gst_mf_source_enum_device_activate (GstMFSourceReader * self,
} }
done: done:
ret = g_list_reverse (ret);
CoTaskMemFree (devices); CoTaskMemFree (devices);
*device_sources = ret; if (!ret)
return FALSE;
return !!ret; *device_sources = g_list_reverse (ret);
return TRUE;
} }
static void static void

16
subprojects/gst-plugins-bad/sys/mediafoundation/gstmftransform.cpp
View file

@ -537,7 +537,11 @@ gst_mf_transform_thread_func (GstMFTransform * self)
CoTaskMemFree (devices); CoTaskMemFree (devices);
self->hardware = !!(self->enum_params.enum_flags & MFT_ENUM_FLAG_HARDWARE); if ((self->enum_params.enum_flags & MFT_ENUM_FLAG_HARDWARE) != 0)
self->hardware = TRUE;
else
self->hardware = FALSE;
self->initialized = TRUE; self->initialized = TRUE;
run_loop: run_loop:
@ -1131,9 +1135,12 @@ gst_mf_transform_get_input_available_types (GstMFTransform * object,
index++; index++;
} while (SUCCEEDED (hr)); } while (SUCCEEDED (hr));
if (!list)
return FALSE;
*input_types = list; *input_types = list;
return !!list; return TRUE;
} }
gboolean gboolean
@ -1165,9 +1172,12 @@ gst_mf_transform_get_output_available_types (GstMFTransform * object,
index++; index++;
} while (SUCCEEDED (hr)); } while (SUCCEEDED (hr));
if (!list)
return FALSE;
*output_types = list; *output_types = list;
return !!list; return TRUE;
} }
gboolean gboolean

233
subprojects/gst-plugins-bad/sys/mediafoundation/gstmfvideoenc.cpp → subprojects/gst-plugins-bad/sys/mediafoundation/gstmfvideoencoder.cpp
View file

@ -23,7 +23,7 @@
#endif #endif
#include <gst/gst.h> #include <gst/gst.h>
#include "gstmfvideoenc.h" #include "gstmfvideoencoder.h"
#include "gstmfvideobuffer.h" #include "gstmfvideobuffer.h"
#include "gstmfplatloader.h" #include "gstmfplatloader.h"
#include <wrl.h> #include <wrl.h>
@ -38,72 +38,77 @@
using namespace Microsoft::WRL; using namespace Microsoft::WRL;
/* *INDENT-ON* */ /* *INDENT-ON* */
GST_DEBUG_CATEGORY_EXTERN (gst_mf_video_enc_debug); GST_DEBUG_CATEGORY_EXTERN (gst_mf_video_encoder_debug);
#define GST_CAT_DEFAULT gst_mf_video_enc_debug #define GST_CAT_DEFAULT gst_mf_video_encoder_debug
#define gst_mf_video_enc_parent_class parent_class #define gst_mf_video_encoder_parent_class parent_class
G_DEFINE_ABSTRACT_TYPE (GstMFVideoEnc, gst_mf_video_enc, G_DEFINE_ABSTRACT_TYPE (GstMFVideoEncoder, gst_mf_video_encoder,
GST_TYPE_VIDEO_ENCODER); GST_TYPE_VIDEO_ENCODER);
static void gst_mf_video_enc_dispose (GObject * object); static void gst_mf_video_encoder_dispose (GObject * object);
static void gst_mf_video_enc_set_context (GstElement * element, static void gst_mf_video_encoder_set_context (GstElement * element,
GstContext * context); GstContext * context);
static gboolean gst_mf_video_enc_open (GstVideoEncoder * enc); static gboolean gst_mf_video_encoder_open (GstVideoEncoder * enc);
static gboolean gst_mf_video_enc_close (GstVideoEncoder * enc); static gboolean gst_mf_video_encoder_close (GstVideoEncoder * enc);
static gboolean gst_mf_video_enc_start (GstVideoEncoder * enc); static gboolean gst_mf_video_encoder_start (GstVideoEncoder * enc);
static gboolean gst_mf_video_enc_set_format (GstVideoEncoder * enc, static gboolean gst_mf_video_encoder_set_format (GstVideoEncoder * enc,
GstVideoCodecState * state); GstVideoCodecState * state);
static GstFlowReturn gst_mf_video_enc_handle_frame (GstVideoEncoder * enc, static GstFlowReturn gst_mf_video_encoder_handle_frame (GstVideoEncoder * enc,
GstVideoCodecFrame * frame); GstVideoCodecFrame * frame);
static GstFlowReturn gst_mf_video_enc_finish (GstVideoEncoder * enc); static GstFlowReturn gst_mf_video_encoder_finish (GstVideoEncoder * enc);
static gboolean gst_mf_video_enc_flush (GstVideoEncoder * enc); static gboolean gst_mf_video_encoder_flush (GstVideoEncoder * enc);
static gboolean gst_mf_video_enc_propose_allocation (GstVideoEncoder * enc, static gboolean gst_mf_video_encoder_propose_allocation (GstVideoEncoder * enc,
GstQuery * query); GstQuery * query);
static gboolean gst_mf_video_enc_sink_query (GstVideoEncoder * enc, static gboolean gst_mf_video_encoder_sink_query (GstVideoEncoder * enc,
GstQuery * query); GstQuery * query);
static gboolean gst_mf_video_enc_src_query (GstVideoEncoder * enc, static gboolean gst_mf_video_encoder_src_query (GstVideoEncoder * enc,
GstQuery * query); GstQuery * query);
static HRESULT gst_mf_video_on_new_sample (GstMFTransform * object, static HRESULT gst_mf_video_on_new_sample (GstMFTransform * object,
IMFSample * sample, GstMFVideoEnc * self); IMFSample * sample, GstMFVideoEncoder * self);
static void static void
gst_mf_video_enc_class_init (GstMFVideoEncClass * klass) gst_mf_video_encoder_class_init (GstMFVideoEncoderClass * klass)
{ {
GObjectClass *gobject_class = G_OBJECT_CLASS (klass); GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
GstElementClass *element_class = GST_ELEMENT_CLASS (klass); GstElementClass *element_class = GST_ELEMENT_CLASS (klass);
GstVideoEncoderClass *videoenc_class = GST_VIDEO_ENCODER_CLASS (klass); GstVideoEncoderClass *videoenc_class = GST_VIDEO_ENCODER_CLASS (klass);
gobject_class->dispose = gst_mf_video_enc_dispose; gobject_class->dispose = gst_mf_video_encoder_dispose;
element_class->set_context = GST_DEBUG_FUNCPTR (gst_mf_video_enc_set_context); element_class->set_context =
GST_DEBUG_FUNCPTR (gst_mf_video_encoder_set_context);
videoenc_class->open = GST_DEBUG_FUNCPTR (gst_mf_video_enc_open); videoenc_class->open = GST_DEBUG_FUNCPTR (gst_mf_video_encoder_open);
videoenc_class->close = GST_DEBUG_FUNCPTR (gst_mf_video_enc_close); videoenc_class->close = GST_DEBUG_FUNCPTR (gst_mf_video_encoder_close);
videoenc_class->start = GST_DEBUG_FUNCPTR (gst_mf_video_enc_start); videoenc_class->start = GST_DEBUG_FUNCPTR (gst_mf_video_encoder_start);
videoenc_class->set_format = GST_DEBUG_FUNCPTR (gst_mf_video_enc_set_format); videoenc_class->set_format =
GST_DEBUG_FUNCPTR (gst_mf_video_encoder_set_format);
videoenc_class->handle_frame = videoenc_class->handle_frame =
GST_DEBUG_FUNCPTR (gst_mf_video_enc_handle_frame); GST_DEBUG_FUNCPTR (gst_mf_video_encoder_handle_frame);
videoenc_class->finish = GST_DEBUG_FUNCPTR (gst_mf_video_enc_finish); videoenc_class->finish = GST_DEBUG_FUNCPTR (gst_mf_video_encoder_finish);
videoenc_class->flush = GST_DEBUG_FUNCPTR (gst_mf_video_enc_flush); videoenc_class->flush = GST_DEBUG_FUNCPTR (gst_mf_video_encoder_flush);
videoenc_class->propose_allocation = videoenc_class->propose_allocation =
GST_DEBUG_FUNCPTR (gst_mf_video_enc_propose_allocation); GST_DEBUG_FUNCPTR (gst_mf_video_encoder_propose_allocation);
videoenc_class->sink_query = GST_DEBUG_FUNCPTR (gst_mf_video_enc_sink_query); videoenc_class->sink_query =
videoenc_class->src_query = GST_DEBUG_FUNCPTR (gst_mf_video_enc_src_query); GST_DEBUG_FUNCPTR (gst_mf_video_encoder_sink_query);
videoenc_class->src_query =
GST_DEBUG_FUNCPTR (gst_mf_video_encoder_src_query);
gst_type_mark_as_plugin_api (GST_TYPE_MF_VIDEO_ENC, (GstPluginAPIFlags) 0); gst_type_mark_as_plugin_api (GST_TYPE_MF_VIDEO_ENCODER,
(GstPluginAPIFlags) 0);
} }
static void static void
gst_mf_video_enc_init (GstMFVideoEnc * self) gst_mf_video_encoder_init (GstMFVideoEncoder * self)
{ {
} }
static void static void
gst_mf_video_enc_dispose (GObject * object) gst_mf_video_encoder_dispose (GObject * object)
{ {
#if GST_MF_HAVE_D3D11 #if GST_MF_HAVE_D3D11
GstMFVideoEnc *self = GST_MF_VIDEO_ENC (object); GstMFVideoEncoder *self = GST_MF_VIDEO_ENCODER (object);
gst_clear_object (&self->d3d11_device); gst_clear_object (&self->d3d11_device);
gst_clear_object (&self->other_d3d11_device); gst_clear_object (&self->other_d3d11_device);
@ -113,12 +118,12 @@ gst_mf_video_enc_dispose (GObject * object)
} }
static void static void
gst_mf_video_enc_set_context (GstElement * element, GstContext * context) gst_mf_video_encoder_set_context (GstElement * element, GstContext * context)
{ {
#if GST_MF_HAVE_D3D11 #if GST_MF_HAVE_D3D11
GstMFVideoEnc *self = GST_MF_VIDEO_ENC (element); GstMFVideoEncoder *self = GST_MF_VIDEO_ENCODER (element);
GstMFVideoEncClass *klass = GST_MF_VIDEO_ENC_GET_CLASS (self); GstMFVideoEncoderClass *klass = GST_MF_VIDEO_ENCODER_GET_CLASS (self);
GstMFVideoEncDeviceCaps *device_caps = &klass->device_caps; GstMFVideoEncoderDeviceCaps *device_caps = &klass->device_caps;
if (device_caps->d3d11_aware) { if (device_caps->d3d11_aware) {
gst_d3d11_handle_set_context_for_adapter_luid (element, context, gst_d3d11_handle_set_context_for_adapter_luid (element, context,
@ -130,14 +135,13 @@ gst_mf_video_enc_set_context (GstElement * element, GstContext * context)
} }
static gboolean static gboolean
gst_mf_video_enc_open (GstVideoEncoder * enc) gst_mf_video_encoder_open (GstVideoEncoder * enc)
{ {
GstMFVideoEnc *self = GST_MF_VIDEO_ENC (enc); GstMFVideoEncoder *self = GST_MF_VIDEO_ENCODER (enc);
GstMFVideoEncClass *klass = GST_MF_VIDEO_ENC_GET_CLASS (enc); GstMFVideoEncoderClass *klass = GST_MF_VIDEO_ENCODER_GET_CLASS (enc);
GstMFVideoEncDeviceCaps *device_caps = &klass->device_caps; GstMFVideoEncoderDeviceCaps *device_caps = &klass->device_caps;
GstMFTransformEnumParams enum_params = { 0, }; GstMFTransformEnumParams enum_params = { 0, };
MFT_REGISTER_TYPE_INFO output_type; MFT_REGISTER_TYPE_INFO output_type;
gboolean ret;
#if GST_MF_HAVE_D3D11 #if GST_MF_HAVE_D3D11
if (device_caps->d3d11_aware) { if (device_caps->d3d11_aware) {
@ -214,9 +218,7 @@ gst_mf_video_enc_open (GstVideoEncoder * enc)
device_caps->d3d11_aware, device_caps->adapter_luid); device_caps->d3d11_aware, device_caps->adapter_luid);
self->transform = gst_mf_transform_new (&enum_params); self->transform = gst_mf_transform_new (&enum_params);
ret = !!self->transform; if (!self->transform) {
if (!ret) {
GST_ERROR_OBJECT (self, "Cannot create MFT object"); GST_ERROR_OBJECT (self, "Cannot create MFT object");
return FALSE; return FALSE;
} }
@ -234,13 +236,13 @@ gst_mf_video_enc_open (GstVideoEncoder * enc)
self->async_mft = FALSE; self->async_mft = FALSE;
} }
return ret; return TRUE;
} }
static gboolean static gboolean
gst_mf_video_enc_close (GstVideoEncoder * enc) gst_mf_video_encoder_close (GstVideoEncoder * enc)
{ {
GstMFVideoEnc *self = GST_MF_VIDEO_ENC (enc); GstMFVideoEncoder *self = GST_MF_VIDEO_ENCODER (enc);
gst_clear_object (&self->transform); gst_clear_object (&self->transform);
@ -268,7 +270,7 @@ gst_mf_video_enc_close (GstVideoEncoder * enc)
} }
static gboolean static gboolean
gst_mf_video_enc_start (GstVideoEncoder * enc) gst_mf_video_encoder_start (GstVideoEncoder * enc)
{ {
/* Media Foundation Transform will shift PTS in case that B-frame is enabled. /* Media Foundation Transform will shift PTS in case that B-frame is enabled.
* We need to adjust DTS correspondingly */ * We need to adjust DTS correspondingly */
@ -278,10 +280,11 @@ gst_mf_video_enc_start (GstVideoEncoder * enc)
} }
static gboolean static gboolean
gst_mf_video_enc_set_format (GstVideoEncoder * enc, GstVideoCodecState * state) gst_mf_video_encoder_set_format (GstVideoEncoder * enc,
GstVideoCodecState * state)
{ {
GstMFVideoEnc *self = GST_MF_VIDEO_ENC (enc); GstMFVideoEncoder *self = GST_MF_VIDEO_ENCODER (enc);
GstMFVideoEncClass *klass = GST_MF_VIDEO_ENC_GET_CLASS (enc); GstMFVideoEncoderClass *klass = GST_MF_VIDEO_ENCODER_GET_CLASS (enc);
GstVideoInfo *info = &state->info; GstVideoInfo *info = &state->info;
ComPtr < IMFMediaType > in_type; ComPtr < IMFMediaType > in_type;
ComPtr < IMFMediaType > out_type; ComPtr < IMFMediaType > out_type;
@ -292,7 +295,7 @@ gst_mf_video_enc_set_format (GstVideoEncoder * enc, GstVideoCodecState * state)
GST_DEBUG_OBJECT (self, "Set format"); GST_DEBUG_OBJECT (self, "Set format");
gst_mf_video_enc_finish (enc); gst_mf_video_encoder_finish (enc);
self->mf_pts_offset = 0; self->mf_pts_offset = 0;
self->has_reorder_frame = FALSE; self->has_reorder_frame = FALSE;
@ -547,7 +550,7 @@ gst_mf_video_buffer_free (GstVideoFrame * frame)
} }
static gboolean static gboolean
gst_mf_video_enc_frame_needs_copy (GstVideoFrame * vframe) gst_mf_video_encoder_frame_needs_copy (GstVideoFrame * vframe)
{ {
/* Single plane data can be used without copy */ /* Single plane data can be used without copy */
if (GST_VIDEO_FRAME_N_PLANES (vframe) == 1) if (GST_VIDEO_FRAME_N_PLANES (vframe) == 1)
@ -632,19 +635,19 @@ gst_mf_video_enc_frame_needs_copy (GstVideoFrame * vframe)
typedef struct typedef struct
{ {
LONGLONG mf_pts; LONGLONG mf_pts;
} GstMFVideoEncFrameData; } GstMFVideoEncoderFrameData;
static gboolean static gboolean
gst_mf_video_enc_process_input (GstMFVideoEnc * self, gst_mf_video_encoder_process_input (GstMFVideoEncoder * self,
GstVideoCodecFrame * frame, IMFSample * sample) GstVideoCodecFrame * frame, IMFSample * sample)
{ {
GstMFVideoEncClass *klass = GST_MF_VIDEO_ENC_GET_CLASS (self); GstMFVideoEncoderClass *klass = GST_MF_VIDEO_ENCODER_GET_CLASS (self);
HRESULT hr; HRESULT hr;
gboolean unset_force_keyframe = FALSE; gboolean unset_force_keyframe = FALSE;
GstMFVideoEncFrameData *frame_data = nullptr; GstMFVideoEncoderFrameData *frame_data = nullptr;
gboolean res; gboolean res;
frame_data = g_new0 (GstMFVideoEncFrameData, 1); frame_data = g_new0 (GstMFVideoEncoderFrameData, 1);
frame_data->mf_pts = frame->pts / 100; frame_data->mf_pts = frame->pts / 100;
gst_video_codec_frame_set_user_data (frame, gst_video_codec_frame_set_user_data (frame,
@ -696,7 +699,8 @@ gst_mf_video_enc_process_input (GstMFVideoEnc * self,
} }
static GstVideoCodecFrame * static GstVideoCodecFrame *
gst_mf_video_enc_find_output_frame (GstMFVideoEnc * self, LONGLONG mf_pts) gst_mf_video_encoder_find_output_frame (GstMFVideoEncoder * self,
LONGLONG mf_pts)
{ {
GList *l, *walk = gst_video_encoder_get_frames (GST_VIDEO_ENCODER (self)); GList *l, *walk = gst_video_encoder_get_frames (GST_VIDEO_ENCODER (self));
GstVideoCodecFrame *ret = nullptr; GstVideoCodecFrame *ret = nullptr;
@ -705,7 +709,7 @@ gst_mf_video_enc_find_output_frame (GstMFVideoEnc * self, LONGLONG mf_pts)
for (l = walk; l; l = l->next) { for (l = walk; l; l = l->next) {
GstVideoCodecFrame *frame = (GstVideoCodecFrame *) l->data; GstVideoCodecFrame *frame = (GstVideoCodecFrame *) l->data;
GstMFVideoEncFrameData *data = (GstMFVideoEncFrameData *) GstMFVideoEncoderFrameData *data = (GstMFVideoEncoderFrameData *)
gst_video_codec_frame_get_user_data (frame); gst_video_codec_frame_get_user_data (frame);
LONGLONG abs_diff; LONGLONG abs_diff;
@ -746,7 +750,8 @@ gst_mf_video_enc_find_output_frame (GstMFVideoEnc * self, LONGLONG mf_pts)
} }
static HRESULT static HRESULT
gst_mf_video_enc_finish_sample (GstMFVideoEnc * self, IMFSample * sample) gst_mf_video_encoder_finish_sample (GstMFVideoEncoder * self,
IMFSample * sample)
{ {
HRESULT hr = S_OK; HRESULT hr = S_OK;
BYTE *data; BYTE *data;
@ -845,7 +850,7 @@ gst_mf_video_enc_finish_sample (GstMFVideoEnc * self, IMFSample * sample)
} }
} }
frame = gst_mf_video_enc_find_output_frame (self, target_mf_pts); frame = gst_mf_video_encoder_find_output_frame (self, target_mf_pts);
if (frame) { if (frame) {
if (keyframe) { if (keyframe) {
@ -906,7 +911,7 @@ done:
} }
static GstFlowReturn static GstFlowReturn
gst_mf_video_enc_process_output (GstMFVideoEnc * self) gst_mf_video_encoder_process_output (GstMFVideoEncoder * self)
{ {
ComPtr < IMFSample > sample; ComPtr < IMFSample > sample;
GstFlowReturn res = GST_FLOW_ERROR; GstFlowReturn res = GST_FLOW_ERROR;
@ -916,13 +921,13 @@ gst_mf_video_enc_process_output (GstMFVideoEnc * self)
if (res != GST_FLOW_OK) if (res != GST_FLOW_OK)
return res; return res;
gst_mf_video_enc_finish_sample (self, sample.Get ()); gst_mf_video_encoder_finish_sample (self, sample.Get ());
return self->last_ret; return self->last_ret;
} }
static gboolean static gboolean
gst_mf_video_enc_create_input_sample (GstMFVideoEnc * self, gst_mf_video_encoder_create_input_sample (GstMFVideoEncoder * self,
GstVideoCodecFrame * frame, IMFSample ** sample) GstVideoCodecFrame * frame, IMFSample ** sample)
{ {
HRESULT hr; HRESULT hr;
@ -948,7 +953,7 @@ gst_mf_video_enc_create_input_sample (GstMFVideoEnc * self,
goto error; goto error;
/* Check if we can forward this memory to Media Foundation without copy */ /* Check if we can forward this memory to Media Foundation without copy */
need_copy = gst_mf_video_enc_frame_needs_copy (vframe); need_copy = gst_mf_video_encoder_frame_needs_copy (vframe);
if (need_copy) { if (need_copy) {
GST_TRACE_OBJECT (self, "Copy input buffer into Media Foundation memory"); GST_TRACE_OBJECT (self, "Copy input buffer into Media Foundation memory");
hr = MFCreateMemoryBuffer (GST_VIDEO_INFO_SIZE (info), &media_buffer); hr = MFCreateMemoryBuffer (GST_VIDEO_INFO_SIZE (info), &media_buffer);
@ -1031,7 +1036,7 @@ error:
#if GST_MF_HAVE_D3D11 #if GST_MF_HAVE_D3D11
static gboolean static gboolean
gst_mf_video_enc_create_input_sample_d3d11 (GstMFVideoEnc * self, gst_mf_video_encoder_create_input_sample_d3d11 (GstMFVideoEncoder * self,
GstVideoCodecFrame * frame, IMFSample ** sample) GstVideoCodecFrame * frame, IMFSample ** sample)
{ {
HRESULT hr; HRESULT hr;
@ -1180,10 +1185,10 @@ gst_mf_video_enc_create_input_sample_d3d11 (GstMFVideoEnc * self,
#endif #endif
static GstFlowReturn static GstFlowReturn
gst_mf_video_enc_handle_frame (GstVideoEncoder * enc, gst_mf_video_encoder_handle_frame (GstVideoEncoder * enc,
GstVideoCodecFrame * frame) GstVideoCodecFrame * frame)
{ {
GstMFVideoEnc *self = GST_MF_VIDEO_ENC (enc); GstMFVideoEncoder *self = GST_MF_VIDEO_ENCODER (enc);
GstFlowReturn ret = GST_FLOW_OK; GstFlowReturn ret = GST_FLOW_OK;
ComPtr < IMFSample > sample; ComPtr < IMFSample > sample;
@ -1194,19 +1199,20 @@ gst_mf_video_enc_handle_frame (GstVideoEncoder * enc,
} }
#if GST_MF_HAVE_D3D11 #if GST_MF_HAVE_D3D11
if (self->mf_allocator && if (self->mf_allocator &&
!gst_mf_video_enc_create_input_sample_d3d11 (self, frame, &sample)) { !gst_mf_video_encoder_create_input_sample_d3d11 (self, frame, &sample)) {
GST_WARNING_OBJECT (self, "Failed to create IMFSample for D3D11"); GST_WARNING_OBJECT (self, "Failed to create IMFSample for D3D11");
sample = nullptr; sample = nullptr;
} }
#endif #endif
if (!sample && !gst_mf_video_enc_create_input_sample (self, frame, &sample)) { if (!sample
&& !gst_mf_video_encoder_create_input_sample (self, frame, &sample)) {
GST_ERROR_OBJECT (self, "Failed to create IMFSample"); GST_ERROR_OBJECT (self, "Failed to create IMFSample");
ret = GST_FLOW_ERROR; ret = GST_FLOW_ERROR;
goto done; goto done;
} }
if (!gst_mf_video_enc_process_input (self, frame, sample.Get ())) { if (!gst_mf_video_encoder_process_input (self, frame, sample.Get ())) {
GST_ERROR_OBJECT (self, "Failed to process input"); GST_ERROR_OBJECT (self, "Failed to process input");
ret = GST_FLOW_ERROR; ret = GST_FLOW_ERROR;
goto done; goto done;
@ -1217,7 +1223,7 @@ gst_mf_video_enc_handle_frame (GstVideoEncoder * enc,
* from Media Foundation's internal worker queue thread */ * from Media Foundation's internal worker queue thread */
if (!self->async_mft) { if (!self->async_mft) {
do { do {
ret = gst_mf_video_enc_process_output (self); ret = gst_mf_video_encoder_process_output (self);
} while (ret == GST_FLOW_OK); } while (ret == GST_FLOW_OK);
} }
@ -1231,9 +1237,9 @@ done:
} }
static GstFlowReturn static GstFlowReturn
gst_mf_video_enc_finish (GstVideoEncoder * enc) gst_mf_video_encoder_finish (GstVideoEncoder * enc)
{ {
GstMFVideoEnc *self = GST_MF_VIDEO_ENC (enc); GstMFVideoEncoder *self = GST_MF_VIDEO_ENCODER (enc);
GstFlowReturn ret = GST_FLOW_OK; GstFlowReturn ret = GST_FLOW_OK;
if (!self->transform) if (!self->transform)
@ -1251,7 +1257,7 @@ gst_mf_video_enc_finish (GstVideoEncoder * enc)
if (!self->async_mft) { if (!self->async_mft) {
do { do {
ret = gst_mf_video_enc_process_output (self); ret = gst_mf_video_encoder_process_output (self);
} while (ret == GST_FLOW_OK); } while (ret == GST_FLOW_OK);
} }
@ -1262,9 +1268,9 @@ gst_mf_video_enc_finish (GstVideoEncoder * enc)
} }
static gboolean static gboolean
gst_mf_video_enc_flush (GstVideoEncoder * enc) gst_mf_video_encoder_flush (GstVideoEncoder * enc)
{ {
GstMFVideoEnc *self = GST_MF_VIDEO_ENC (enc); GstMFVideoEncoder *self = GST_MF_VIDEO_ENCODER (enc);
if (!self->transform) if (!self->transform)
goto out; goto out;
@ -1285,10 +1291,11 @@ out:
} }
static gboolean static gboolean
gst_mf_video_enc_propose_allocation (GstVideoEncoder * enc, GstQuery * query) gst_mf_video_encoder_propose_allocation (GstVideoEncoder * enc,
GstQuery * query)
{ {
#if GST_MF_HAVE_D3D11 #if GST_MF_HAVE_D3D11
GstMFVideoEnc *self = GST_MF_VIDEO_ENC (enc); GstMFVideoEncoder *self = GST_MF_VIDEO_ENCODER (enc);
GstVideoInfo info; GstVideoInfo info;
GstBufferPool *pool = nullptr; GstBufferPool *pool = nullptr;
GstCaps *caps; GstCaps *caps;
@ -1393,10 +1400,10 @@ config_failed:
} }
static gboolean static gboolean
gst_mf_video_enc_sink_query (GstVideoEncoder * enc, GstQuery * query) gst_mf_video_encoder_sink_query (GstVideoEncoder * enc, GstQuery * query)
{ {
#if GST_MF_HAVE_D3D11 #if GST_MF_HAVE_D3D11
GstMFVideoEnc *self = GST_MF_VIDEO_ENC (enc); GstMFVideoEncoder *self = GST_MF_VIDEO_ENCODER (enc);
switch (GST_QUERY_TYPE (query)) { switch (GST_QUERY_TYPE (query)) {
case GST_QUERY_CONTEXT: case GST_QUERY_CONTEXT:
@ -1414,10 +1421,10 @@ gst_mf_video_enc_sink_query (GstVideoEncoder * enc, GstQuery * query)
} }
static gboolean static gboolean
gst_mf_video_enc_src_query (GstVideoEncoder * enc, GstQuery * query) gst_mf_video_encoder_src_query (GstVideoEncoder * enc, GstQuery * query)
{ {
#if GST_MF_HAVE_D3D11 #if GST_MF_HAVE_D3D11
GstMFVideoEnc *self = GST_MF_VIDEO_ENC (enc); GstMFVideoEncoder *self = GST_MF_VIDEO_ENCODER (enc);
switch (GST_QUERY_TYPE (query)) { switch (GST_QUERY_TYPE (query)) {
case GST_QUERY_CONTEXT: case GST_QUERY_CONTEXT:
@ -1436,14 +1443,14 @@ gst_mf_video_enc_src_query (GstVideoEncoder * enc, GstQuery * query)
static HRESULT static HRESULT
gst_mf_video_on_new_sample (GstMFTransform * object, gst_mf_video_on_new_sample (GstMFTransform * object,
IMFSample * sample, GstMFVideoEnc * self) IMFSample * sample, GstMFVideoEncoder * self)
{ {
GST_LOG_OBJECT (self, "New Sample callback"); GST_LOG_OBJECT (self, "New Sample callback");
/* NOTE: this callback will be called from Media Foundation's internal /* NOTE: this callback will be called from Media Foundation's internal
* worker queue thread */ * worker queue thread */
GST_VIDEO_ENCODER_STREAM_LOCK (self); GST_VIDEO_ENCODER_STREAM_LOCK (self);
gst_mf_video_enc_finish_sample (self, sample); gst_mf_video_encoder_finish_sample (self, sample);
GST_VIDEO_ENCODER_STREAM_UNLOCK (self); GST_VIDEO_ENCODER_STREAM_UNLOCK (self);
return S_OK; return S_OK;
@ -1453,11 +1460,11 @@ typedef struct
{ {
guint profile; guint profile;
const gchar *profile_str; const gchar *profile_str;
} GstMFVideoEncProfileMap; } GstMFVideoEncoderProfileMap;
static void static void
gst_mf_video_enc_enum_internal (GstMFTransform * transform, GUID & subtype, gst_mf_video_encoder_enum_internal (GstMFTransform * transform, GUID & subtype,
GstObject * d3d11_device, GstMFVideoEncDeviceCaps * device_caps, GstObject * d3d11_device, GstMFVideoEncoderDeviceCaps * device_caps,
GstCaps ** sink_template, GstCaps ** src_template) GstCaps ** sink_template, GstCaps ** src_template)
{ {
HRESULT hr; HRESULT hr;
@ -1478,18 +1485,18 @@ gst_mf_video_enc_enum_internal (GstMFTransform * transform, GUID & subtype,
IMFTransform *encoder; IMFTransform *encoder;
ICodecAPI *codec_api; ICodecAPI *codec_api;
ComPtr < IMFMediaType > out_type; ComPtr < IMFMediaType > out_type;
GstMFVideoEncProfileMap h264_profile_map[] = { GstMFVideoEncoderProfileMap h264_profile_map[] = {
{eAVEncH264VProfile_High, "high"}, {eAVEncH264VProfile_High, "high"},
{eAVEncH264VProfile_Main, "main"}, {eAVEncH264VProfile_Main, "main"},
{eAVEncH264VProfile_Base, "baseline"}, {eAVEncH264VProfile_Base, "baseline"},
{0, nullptr}, {0, nullptr},
}; };
GstMFVideoEncProfileMap hevc_profile_map[] = { GstMFVideoEncoderProfileMap hevc_profile_map[] = {
{eAVEncH265VProfile_Main_420_8, "main"}, {eAVEncH265VProfile_Main_420_8, "main"},
{eAVEncH265VProfile_Main_420_10, "main-10"}, {eAVEncH265VProfile_Main_420_10, "main-10"},
{0, nullptr}, {0, nullptr},
}; };
GstMFVideoEncProfileMap *profile_to_check = nullptr; GstMFVideoEncoderProfileMap *profile_to_check = nullptr;
static const gchar *h264_caps_str = static const gchar *h264_caps_str =
"video/x-h264, stream-format=(string) byte-stream, alignment=(string) au"; "video/x-h264, stream-format=(string) byte-stream, alignment=(string) au";
static const gchar *hevc_caps_str = static const gchar *hevc_caps_str =
@ -1785,8 +1792,8 @@ gst_mf_video_enc_enum_internal (GstMFTransform * transform, GUID & subtype,
} }
static GstMFTransform * static GstMFTransform *
gst_mf_video_enc_enum (guint enum_flags, GUID * subtype, guint device_index, gst_mf_video_encoder_enum (guint enum_flags, GUID * subtype, guint device_index,
GstMFVideoEncDeviceCaps * device_caps, GstObject * d3d11_device, GstMFVideoEncoderDeviceCaps * device_caps, GstObject * d3d11_device,
GstCaps ** sink_template, GstCaps ** src_template) GstCaps ** sink_template, GstCaps ** src_template)
{ {
GstMFTransformEnumParams enum_params = { 0, }; GstMFTransformEnumParams enum_params = { 0, };
@ -1796,7 +1803,7 @@ gst_mf_video_enc_enum (guint enum_flags, GUID * subtype, guint device_index,
*sink_template = nullptr; *sink_template = nullptr;
*src_template = nullptr; *src_template = nullptr;
memset (device_caps, 0, sizeof (GstMFVideoEncDeviceCaps)); memset (device_caps, 0, sizeof (GstMFVideoEncoderDeviceCaps));
if (!IsEqualGUID (MFVideoFormat_H264, *subtype) && if (!IsEqualGUID (MFVideoFormat_H264, *subtype) &&
!IsEqualGUID (MFVideoFormat_HEVC, *subtype) && !IsEqualGUID (MFVideoFormat_HEVC, *subtype) &&
@ -1827,16 +1834,16 @@ gst_mf_video_enc_enum (guint enum_flags, GUID * subtype, guint device_index,
if (!transform) if (!transform)
return nullptr; return nullptr;
gst_mf_video_enc_enum_internal (transform, output_type.guidSubtype, gst_mf_video_encoder_enum_internal (transform, output_type.guidSubtype,
d3d11_device, device_caps, sink_template, src_template); d3d11_device, device_caps, sink_template, src_template);
return transform; return transform;
} }
static void static void
gst_mf_video_enc_register_internal (GstPlugin * plugin, guint rank, gst_mf_video_encoder_register_internal (GstPlugin * plugin, guint rank,
GUID * subtype, GTypeInfo * type_info, GUID * subtype, GTypeInfo * type_info,
const GstMFVideoEncDeviceCaps * device_caps, const GstMFVideoEncoderDeviceCaps * device_caps,
guint32 enum_flags, guint device_index, GstMFTransform * transform, guint32 enum_flags, guint device_index, GstMFTransform * transform,
GstCaps * sink_caps, GstCaps * src_caps) GstCaps * sink_caps, GstCaps * src_caps)
{ {
@ -1845,7 +1852,7 @@ gst_mf_video_enc_register_internal (GstPlugin * plugin, guint rank,
gchar *type_name; gchar *type_name;
gchar *feature_name; gchar *feature_name;
gint i; gint i;
GstMFVideoEncClassData *cdata; GstMFVideoEncoderClassData *cdata;
gboolean is_default = TRUE; gboolean is_default = TRUE;
gchar *device_name = nullptr; gchar *device_name = nullptr;
const gchar *type_name_prefix = nullptr; const gchar *type_name_prefix = nullptr;
@ -1869,7 +1876,7 @@ gst_mf_video_enc_register_internal (GstPlugin * plugin, guint rank,
g_object_get (transform, "device-name", &device_name, nullptr); g_object_get (transform, "device-name", &device_name, nullptr);
g_assert (device_name != nullptr); g_assert (device_name != nullptr);
cdata = g_new0 (GstMFVideoEncClassData, 1); cdata = g_new0 (GstMFVideoEncoderClassData, 1);
cdata->sink_caps = gst_caps_copy (sink_caps); cdata->sink_caps = gst_caps_copy (sink_caps);
cdata->src_caps = gst_caps_copy (src_caps); cdata->src_caps = gst_caps_copy (src_caps);
cdata->device_name = device_name; cdata->device_name = device_name;
@ -1901,7 +1908,7 @@ gst_mf_video_enc_register_internal (GstPlugin * plugin, guint rank,
cdata->is_default = is_default; cdata->is_default = is_default;
type = type =
g_type_register_static (GST_TYPE_MF_VIDEO_ENC, type_name, g_type_register_static (GST_TYPE_MF_VIDEO_ENCODER, type_name,
&local_type_info, (GTypeFlags) 0); &local_type_info, (GTypeFlags) 0);
/* make lower rank than default device */ /* make lower rank than default device */
@ -1919,14 +1926,14 @@ gst_mf_video_enc_register_internal (GstPlugin * plugin, guint rank,
} }
void void
gst_mf_video_enc_register (GstPlugin * plugin, guint rank, GUID * subtype, gst_mf_video_encoder_register (GstPlugin * plugin, guint rank, GUID * subtype,
GTypeInfo * type_info, GList * d3d11_device) GTypeInfo * type_info, GList * d3d11_device)
{ {
GstMFTransform *transform = nullptr; GstMFTransform *transform = nullptr;
GstCaps *sink_template = nullptr; GstCaps *sink_template = nullptr;
GstCaps *src_template = nullptr; GstCaps *src_template = nullptr;
guint enum_flags; guint enum_flags;
GstMFVideoEncDeviceCaps device_caps; GstMFVideoEncoderDeviceCaps device_caps;
guint i; guint i;
/* register hardware encoders first */ /* register hardware encoders first */
@ -1938,7 +1945,8 @@ gst_mf_video_enc_register (GstPlugin * plugin, guint rank, GUID * subtype,
for (iter = d3d11_device; iter; iter = g_list_next (iter)) { for (iter = d3d11_device; iter; iter = g_list_next (iter)) {
GstObject *device = (GstObject *) iter->data; GstObject *device = (GstObject *) iter->data;
transform = gst_mf_video_enc_enum (enum_flags, subtype, 0, &device_caps, transform =
gst_mf_video_encoder_enum (enum_flags, subtype, 0, &device_caps,
device, &sink_template, &src_template); device, &sink_template, &src_template);
/* No more MFT to enumerate */ /* No more MFT to enumerate */
@ -1951,7 +1959,7 @@ gst_mf_video_enc_register (GstPlugin * plugin, guint rank, GUID * subtype,
continue; continue;
} }
gst_mf_video_enc_register_internal (plugin, rank, subtype, type_info, gst_mf_video_encoder_register_internal (plugin, rank, subtype, type_info,
&device_caps, enum_flags, 0, transform, sink_template, src_template); &device_caps, enum_flags, 0, transform, sink_template, src_template);
gst_clear_object (&transform); gst_clear_object (&transform);
gst_clear_caps (&sink_template); gst_clear_caps (&sink_template);
@ -1960,7 +1968,8 @@ gst_mf_video_enc_register (GstPlugin * plugin, guint rank, GUID * subtype,
} else { } else {
/* AMD seems to be able to support up to 12 GPUs */ /* AMD seems to be able to support up to 12 GPUs */
for (i = 0; i < 12; i++) { for (i = 0; i < 12; i++) {
transform = gst_mf_video_enc_enum (enum_flags, subtype, i, &device_caps, transform =
gst_mf_video_encoder_enum (enum_flags, subtype, i, &device_caps,
nullptr, &sink_template, &src_template); nullptr, &sink_template, &src_template);
/* No more MFT to enumerate */ /* No more MFT to enumerate */
@ -1973,7 +1982,7 @@ gst_mf_video_enc_register (GstPlugin * plugin, guint rank, GUID * subtype,
continue; continue;
} }
gst_mf_video_enc_register_internal (plugin, rank, subtype, type_info, gst_mf_video_encoder_register_internal (plugin, rank, subtype, type_info,
&device_caps, enum_flags, i, transform, sink_template, src_template); &device_caps, enum_flags, i, transform, sink_template, src_template);
gst_clear_object (&transform); gst_clear_object (&transform);
gst_clear_caps (&sink_template); gst_clear_caps (&sink_template);
@ -1985,7 +1994,7 @@ gst_mf_video_enc_register (GstPlugin * plugin, guint rank, GUID * subtype,
enum_flags = (MFT_ENUM_FLAG_SYNCMFT | enum_flags = (MFT_ENUM_FLAG_SYNCMFT |
MFT_ENUM_FLAG_SORTANDFILTER | MFT_ENUM_FLAG_SORTANDFILTER_APPROVED_ONLY); MFT_ENUM_FLAG_SORTANDFILTER | MFT_ENUM_FLAG_SORTANDFILTER_APPROVED_ONLY);
transform = gst_mf_video_enc_enum (enum_flags, subtype, 0, &device_caps, transform = gst_mf_video_encoder_enum (enum_flags, subtype, 0, &device_caps,
nullptr, &sink_template, &src_template); nullptr, &sink_template, &src_template);
if (!transform) if (!transform)
@ -1994,7 +2003,7 @@ gst_mf_video_enc_register (GstPlugin * plugin, guint rank, GUID * subtype,
if (!sink_template) if (!sink_template)
goto done; goto done;
gst_mf_video_enc_register_internal (plugin, rank, subtype, type_info, gst_mf_video_encoder_register_internal (plugin, rank, subtype, type_info,
&device_caps, enum_flags, 0, transform, sink_template, src_template); &device_caps, enum_flags, 0, transform, sink_template, src_template);
done: done:

53
subprojects/gst-plugins-bad/sys/mediafoundation/gstmfvideoenc.h → subprojects/gst-plugins-bad/sys/mediafoundation/gstmfvideoencoder.h
View file

@ -18,8 +18,7 @@
* Boston, MA 02110-1301, USA. * Boston, MA 02110-1301, USA.
*/ */
#ifndef __GST_MF_VIDEO_ENC_H__ #pragma once
#define __GST_MF_VIDEO_ENC_H__
#include "gstmfconfig.h" #include "gstmfconfig.h"
@ -34,19 +33,19 @@
G_BEGIN_DECLS G_BEGIN_DECLS
#define GST_TYPE_MF_VIDEO_ENC (gst_mf_video_enc_get_type()) #define GST_TYPE_MF_VIDEO_ENCODER (gst_mf_video_encoder_get_type())
#define GST_MF_VIDEO_ENC(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_MF_VIDEO_ENC,GstMFVideoEnc)) #define GST_MF_VIDEO_ENCODER(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_MF_VIDEO_ENCODER,GstMFVideoEncoder))
#define GST_MF_VIDEO_ENC_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), GST_TYPE_MF_VIDEO_ENC,GstMFVideoEncClass)) #define GST_MF_VIDEO_ENCODER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), GST_TYPE_MF_VIDEO_ENCODER,GstMFVideoEncoderClass))
#define GST_MF_VIDEO_ENC_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), GST_TYPE_MF_VIDEO_ENC,GstMFVideoEncClass)) #define GST_MF_VIDEO_ENCODER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), GST_TYPE_MF_VIDEO_ENCODER,GstMFVideoEncoderClass))
#define GST_IS_MF_VIDEO_ENC(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_MF_VIDEO_ENC)) #define GST_IS_MF_VIDEO_ENCODER(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_MF_VIDEO_ENCODER))
#define GST_IS_MF_VIDEO_ENC_CLASS(obj) (G_TYPE_CHECK_CLASS_TYPE((klass), GST_TYPE_MF_VIDEO_ENC)) #define GST_IS_MF_VIDEO_ENCODER_CLASS(obj) (G_TYPE_CHECK_CLASS_TYPE((klass), GST_TYPE_MF_VIDEO_ENCODER))
typedef struct _GstMFVideoEnc GstMFVideoEnc; typedef struct _GstMFVideoEncoder GstMFVideoEncoder;
typedef struct _GstMFVideoEncClass GstMFVideoEncClass; typedef struct _GstMFVideoEncoderClass GstMFVideoEncoderClass;
typedef struct _GstMFVideoEncDeviceCaps GstMFVideoEncDeviceCaps; typedef struct _GstMFVideoEncoderDeviceCaps GstMFVideoEncoderDeviceCaps;
typedef struct _GstMFVideoEncClassData GstMFVideoEncClassData; typedef struct _GstMFVideoEncoderClassData GstMFVideoEncoderClassData;
struct _GstMFVideoEncDeviceCaps struct _GstMFVideoEncoderDeviceCaps
{ {
gboolean rc_mode; /* AVEncCommonRateControlMode */ gboolean rc_mode; /* AVEncCommonRateControlMode */
gboolean quality; /* AVEncCommonQuality */ gboolean quality; /* AVEncCommonQuality */
@ -79,18 +78,18 @@ struct _GstMFVideoEncDeviceCaps
gint64 adapter_luid; gint64 adapter_luid;
}; };
struct _GstMFVideoEncClassData struct _GstMFVideoEncoderClassData
{ {
GstCaps *sink_caps; GstCaps *sink_caps;
GstCaps *src_caps; GstCaps *src_caps;
gchar *device_name; gchar *device_name;
guint32 enum_flags; guint32 enum_flags;
guint device_index; guint device_index;
GstMFVideoEncDeviceCaps device_caps; GstMFVideoEncoderDeviceCaps device_caps;
gboolean is_default; gboolean is_default;
}; };
struct _GstMFVideoEnc struct _GstMFVideoEncoder
{ {
GstVideoEncoder parent; GstVideoEncoder parent;
@ -117,7 +116,7 @@ struct _GstMFVideoEnc
#endif #endif
}; };
struct _GstMFVideoEncClass struct _GstMFVideoEncoderClass
{ {
GstVideoEncoderClass parent_class; GstVideoEncoderClass parent_class;
@ -125,25 +124,23 @@ struct _GstMFVideoEncClass
GUID codec_id; /* Output subtype of MFT */ GUID codec_id; /* Output subtype of MFT */
guint32 enum_flags; /* MFT_ENUM_FLAG */ guint32 enum_flags; /* MFT_ENUM_FLAG */
guint device_index; /* Index of enumerated IMFActivate via MFTEnum */ guint device_index; /* Index of enumerated IMFActivate via MFTEnum */
GstMFVideoEncDeviceCaps device_caps; GstMFVideoEncoderDeviceCaps device_caps;
gboolean (*set_option) (GstMFVideoEnc * mfenc, gboolean (*set_option) (GstMFVideoEncoder * encoder,
GstVideoCodecState * state, GstVideoCodecState * state,
IMFMediaType * output_type); IMFMediaType * output_type);
gboolean (*set_src_caps) (GstMFVideoEnc * mfenc, gboolean (*set_src_caps) (GstMFVideoEncoder * encoder,
GstVideoCodecState * state, GstVideoCodecState * state,
IMFMediaType * output_type); IMFMediaType * output_type);
}; };
GType gst_mf_video_enc_get_type (void); GType gst_mf_video_encoder_get_type (void);
void gst_mf_video_enc_register (GstPlugin * plugin, void gst_mf_video_encoder_register (GstPlugin * plugin,
guint rank, guint rank,
GUID * subtype, GUID * subtype,
GTypeInfo * type_info, GTypeInfo * type_info,
GList * d3d11_device); GList * d3d11_device);
G_END_DECLS G_END_DECLS
#endif /* __GST_MF_VIDEO_ENC_H__ */

49
subprojects/gst-plugins-bad/sys/mediafoundation/gstmfvp9enc.cpp
View file

@ -35,7 +35,7 @@
#endif #endif
#include <gst/gst.h> #include <gst/gst.h>
#include "gstmfvideoenc.h" #include "gstmfvideoencoder.h"
#include "gstmfvp9enc.h" #include "gstmfvp9enc.h"
#include <wrl.h> #include <wrl.h>
@ -122,7 +122,7 @@ enum
typedef struct _GstMFVP9Enc typedef struct _GstMFVP9Enc
{ {
GstMFVideoEnc parent; GstMFVideoEncoder parent;
/* properties */ /* properties */
guint bitrate; guint bitrate;
@ -139,7 +139,7 @@ typedef struct _GstMFVP9Enc
typedef struct _GstMFVP9EncClass typedef struct _GstMFVP9EncClass
{ {
GstMFVideoEncClass parent_class; GstMFVideoEncoderClass parent_class;
} GstMFVP9EncClass; } GstMFVP9EncClass;
static GstElementClass *parent_class = nullptr; static GstElementClass *parent_class = nullptr;
@ -148,9 +148,9 @@ static void gst_mf_vp9_enc_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec); GValue * value, GParamSpec * pspec);
static void gst_mf_vp9_enc_set_property (GObject * object, guint prop_id, static void gst_mf_vp9_enc_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec); const GValue * value, GParamSpec * pspec);
static gboolean gst_mf_vp9_enc_set_option (GstMFVideoEnc * mfenc, static gboolean gst_mf_vp9_enc_set_option (GstMFVideoEncoder * encoder,
GstVideoCodecState * state, IMFMediaType * output_type); GstVideoCodecState * state, IMFMediaType * output_type);
static gboolean gst_mf_vp9_enc_set_src_caps (GstMFVideoEnc * mfenc, static gboolean gst_mf_vp9_enc_set_src_caps (GstMFVideoEncoder * encoder,
GstVideoCodecState * state, IMFMediaType * output_type); GstVideoCodecState * state, IMFMediaType * output_type);
static void static void
@ -158,9 +158,9 @@ gst_mf_vp9_enc_class_init (GstMFVP9EncClass * klass, gpointer data)
{ {
GObjectClass *gobject_class = G_OBJECT_CLASS (klass); GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
GstElementClass *element_class = GST_ELEMENT_CLASS (klass); GstElementClass *element_class = GST_ELEMENT_CLASS (klass);
GstMFVideoEncClass *mfenc_class = GST_MF_VIDEO_ENC_CLASS (klass); GstMFVideoEncoderClass *encoder_class = GST_MF_VIDEO_ENCODER_CLASS (klass);
GstMFVideoEncClassData *cdata = (GstMFVideoEncClassData *) data; GstMFVideoEncoderClassData *cdata = (GstMFVideoEncoderClassData *) data;
GstMFVideoEncDeviceCaps *device_caps = &cdata->device_caps; GstMFVideoEncoderDeviceCaps *device_caps = &cdata->device_caps;
gchar *long_name; gchar *long_name;
gchar *classification; gchar *classification;
@ -301,13 +301,13 @@ gst_mf_vp9_enc_class_init (GstMFVP9EncClass * klass, gpointer data)
gst_pad_template_new ("src", GST_PAD_SRC, GST_PAD_ALWAYS, gst_pad_template_new ("src", GST_PAD_SRC, GST_PAD_ALWAYS,
cdata->src_caps)); cdata->src_caps));
mfenc_class->set_option = GST_DEBUG_FUNCPTR (gst_mf_vp9_enc_set_option); encoder_class->set_option = GST_DEBUG_FUNCPTR (gst_mf_vp9_enc_set_option);
mfenc_class->set_src_caps = GST_DEBUG_FUNCPTR (gst_mf_vp9_enc_set_src_caps); encoder_class->set_src_caps = GST_DEBUG_FUNCPTR (gst_mf_vp9_enc_set_src_caps);
mfenc_class->codec_id = MFVideoFormat_VP90; encoder_class->codec_id = MFVideoFormat_VP90;
mfenc_class->enum_flags = cdata->enum_flags; encoder_class->enum_flags = cdata->enum_flags;
mfenc_class->device_index = cdata->device_index; encoder_class->device_index = cdata->device_index;
mfenc_class->device_caps = *device_caps; encoder_class->device_caps = *device_caps;
g_free (cdata->device_name); g_free (cdata->device_name);
gst_caps_unref (cdata->sink_caps); gst_caps_unref (cdata->sink_caps);
@ -333,7 +333,7 @@ gst_mf_vp9_enc_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec) GValue * value, GParamSpec * pspec)
{ {
GstMFVP9Enc *self = (GstMFVP9Enc *) (object); GstMFVP9Enc *self = (GstMFVP9Enc *) (object);
GstMFVideoEncClass *klass = GST_MF_VIDEO_ENC_GET_CLASS (object); GstMFVideoEncoderClass *klass = GST_MF_VIDEO_ENCODER_GET_CLASS (object);
switch (prop_id) { switch (prop_id) {
case PROP_BITRATE: case PROP_BITRATE:
@ -443,14 +443,14 @@ gst_mf_vp9_enc_content_type_to_enum (guint rc_mode)
} G_STMT_END } G_STMT_END
static gboolean static gboolean
gst_mf_vp9_enc_set_option (GstMFVideoEnc * mfenc, GstVideoCodecState * state, gst_mf_vp9_enc_set_option (GstMFVideoEncoder * encoder,
IMFMediaType * output_type) GstVideoCodecState * state, IMFMediaType * output_type)
{ {
GstMFVP9Enc *self = (GstMFVP9Enc *) mfenc; GstMFVP9Enc *self = (GstMFVP9Enc *) encoder;
GstMFVideoEncClass *klass = GST_MF_VIDEO_ENC_GET_CLASS (mfenc); GstMFVideoEncoderClass *klass = GST_MF_VIDEO_ENCODER_GET_CLASS (encoder);
GstMFVideoEncDeviceCaps *device_caps = &klass->device_caps; GstMFVideoEncoderDeviceCaps *device_caps = &klass->device_caps;
HRESULT hr; HRESULT hr;
GstMFTransform *transform = mfenc->transform; GstMFTransform *transform = encoder->transform;
hr = output_type->SetGUID (MF_MT_SUBTYPE, MFVideoFormat_VP90); hr = output_type->SetGUID (MF_MT_SUBTYPE, MFVideoFormat_VP90);
if (!gst_mf_result (hr)) if (!gst_mf_result (hr))
@ -536,10 +536,10 @@ gst_mf_vp9_enc_set_option (GstMFVideoEnc * mfenc, GstVideoCodecState * state,
} }
static gboolean static gboolean
gst_mf_vp9_enc_set_src_caps (GstMFVideoEnc * mfenc, gst_mf_vp9_enc_set_src_caps (GstMFVideoEncoder * encoder,
GstVideoCodecState * state, IMFMediaType * output_type) GstVideoCodecState * state, IMFMediaType * output_type)
{ {
GstMFVP9Enc *self = (GstMFVP9Enc *) mfenc; GstMFVP9Enc *self = (GstMFVP9Enc *) encoder;
GstVideoCodecState *out_state; GstVideoCodecState *out_state;
GstStructure *s; GstStructure *s;
GstCaps *out_caps; GstCaps *out_caps;
@ -586,5 +586,6 @@ gst_mf_vp9_enc_plugin_init (GstPlugin * plugin, guint rank,
GST_DEBUG_CATEGORY_INIT (gst_mf_vp9_enc_debug, "mfvp9enc", 0, "mfvp9enc"); GST_DEBUG_CATEGORY_INIT (gst_mf_vp9_enc_debug, "mfvp9enc", 0, "mfvp9enc");
gst_mf_video_enc_register (plugin, rank, &subtype, &type_info, d3d11_device); gst_mf_video_encoder_register (plugin,
rank, &subtype, &type_info, d3d11_device);
} }

20
subprojects/gst-plugins-bad/sys/mediafoundation/meson.build
View file

@ -1,18 +1,18 @@
mf_sources = [ mf_sources = [
'gstmfutils.cpp', 'gstmfaacenc.cpp',
'gstmftransform.cpp', 'gstmfaudioencoder.cpp',
'gstmfvideoenc.cpp', 'gstmfdevice.cpp',
'gstmfh264enc.cpp', 'gstmfh264enc.cpp',
'gstmfh265enc.cpp', 'gstmfh265enc.cpp',
'gstmfvp9enc.cpp',
'gstmfvideosrc.cpp',
'gstmfsourceobject.cpp',
'gstmfdevice.cpp',
'gstmfaudioenc.cpp',
'gstmfaacenc.cpp',
'gstmfmp3enc.cpp', 'gstmfmp3enc.cpp',
'gstmfvideobuffer.cpp',
'gstmfplatloader.cpp', 'gstmfplatloader.cpp',
'gstmfsourceobject.cpp',
'gstmftransform.cpp',
'gstmfutils.cpp',
'gstmfvideobuffer.cpp',
'gstmfvideoencoder.cpp',
'gstmfvideosrc.cpp',
'gstmfvp9enc.cpp',
'plugin.cpp', 'plugin.cpp',
] ]

6
subprojects/gst-plugins-bad/sys/mediafoundation/plugin.cpp
View file

@ -83,7 +83,7 @@ GST_DEBUG_CATEGORY (gst_mf_utils_debug);
GST_DEBUG_CATEGORY (gst_mf_source_object_debug); GST_DEBUG_CATEGORY (gst_mf_source_object_debug);
GST_DEBUG_CATEGORY (gst_mf_transform_debug); GST_DEBUG_CATEGORY (gst_mf_transform_debug);
GST_DEBUG_CATEGORY (gst_mf_video_buffer_debug); GST_DEBUG_CATEGORY (gst_mf_video_buffer_debug);
GST_DEBUG_CATEGORY (gst_mf_video_enc_debug); GST_DEBUG_CATEGORY (gst_mf_video_encoder_debug);
#define GST_CAT_DEFAULT gst_mf_debug #define GST_CAT_DEFAULT gst_mf_debug
@ -201,8 +201,8 @@ plugin_init (GstPlugin * plugin)
"mftransform", 0, "mftransform"); "mftransform", 0, "mftransform");
GST_DEBUG_CATEGORY_INIT (gst_mf_video_buffer_debug, GST_DEBUG_CATEGORY_INIT (gst_mf_video_buffer_debug,
"mfvideobuffer", 0, "mfvideobuffer"); "mfvideobuffer", 0, "mfvideobuffer");
GST_DEBUG_CATEGORY_INIT (gst_mf_video_enc_debug, GST_DEBUG_CATEGORY_INIT (gst_mf_video_encoder_debug,
"mfvideoenc", 0, "mfvideoenc"); "mfvideoencoder", 0, "mfvideoencoder");
hr = MFStartup (MF_VERSION, MFSTARTUP_NOSOCKET); hr = MFStartup (MF_VERSION, MFSTARTUP_NOSOCKET);
if (!gst_mf_result (hr)) { if (!gst_mf_result (hr)) {