nvcodec: Add new Direct3D11/CUDA mode encoder implementation

Adding new encoder elements nvd3d11{h264,h265}enc for Direct3D11
input support and re-written nvcuda{h264,h265}enc elements.
Newly writeen elements have some differences compared with old
nv{h264,h265}enc including non-backward compatible changes.

* RGBA is not a supported input format any more:
  New elements will support only YUV formats to avoid implicit conversion
  done by hardware. Ideally it should be done by upstream element
  in order to have more control on it. Moreover, RGBA support can cause
  redundant RGBA -> YUV conversion if multiple encoders are
  used for the same RGBA input
* Subsampled planar format support is dropped:
  I420 and YV12 format are not supported formats for Direct3D11.
  Although it's supported in CUDA mode, it's not a hardware friendly
  memory layout and it will waste GPU memory since UV planes
  will have large padding due to the memory layout requirement of NVENC.
* GL support is dropped: Similar to the RGBA case,
  GL support in encoder would be suboptimal if GL input is
  used by multiple encoders, because each encoder will copy GL memory
  into CUDA memory.
  Upstream cudaupload element can be used for GL <-> CUDA
  interop instead.
* No more pre-allocation of encoder input surfaces. New implementation
  will use input CUDA memory without copy (zero-copy) or
  will copy into a NVENC's input buffer struct in case of
  system memory input.

Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/1997>
This commit is contained in:
Seungha Yang 2022-03-16 04:58:16 +09:00 committed by GStreamer Marge Bot
parent ea2f686487
commit 60735deded
12 changed files with 6367 additions and 36 deletions

View file

@ -261,6 +261,20 @@ NvEncEncodePicture (void *encoder, NV_ENC_PIC_PARAMS * pic_params)
return nvenc_api.nvEncEncodePicture (encoder, pic_params); return nvenc_api.nvEncEncodePicture (encoder, pic_params);
} }
NVENCSTATUS NVENCAPI
NvEncRegisterAsyncEvent (void *encoder, NV_ENC_EVENT_PARAMS * event_params)
{
g_assert (nvenc_api.nvEncRegisterAsyncEvent != NULL);
return nvenc_api.nvEncRegisterAsyncEvent (encoder, event_params);
}
NVENCSTATUS NVENCAPI
NvEncUnregisterAsyncEvent (void *encoder, NV_ENC_EVENT_PARAMS * event_params)
{
g_assert (nvenc_api.nvEncUnregisterAsyncEvent != NULL);
return nvenc_api.nvEncUnregisterAsyncEvent (encoder, event_params);
}
gboolean gboolean
gst_nvenc_cmp_guid (GUID g1, GUID g2) gst_nvenc_cmp_guid (GUID g1, GUID g2)
{ {

View file

@ -26,6 +26,8 @@
#include "gstcudaloader.h" #include "gstcudaloader.h"
#include "nvEncodeAPI.h" #include "nvEncodeAPI.h"
G_BEGIN_DECLS
gboolean gst_nvenc_cmp_guid (GUID g1, GUID g2); gboolean gst_nvenc_cmp_guid (GUID g1, GUID g2);
NV_ENC_BUFFER_FORMAT gst_nvenc_get_nv_buffer_format (GstVideoFormat fmt); NV_ENC_BUFFER_FORMAT gst_nvenc_get_nv_buffer_format (GstVideoFormat fmt);
@ -89,4 +91,6 @@ guint32 gst_nvenc_get_open_encode_session_ex_params_version (voi
gboolean gst_nvenc_load_library (guint * api_major_ver, gboolean gst_nvenc_load_library (guint * api_major_ver,
guint * api_minor_ver); guint * api_minor_ver);
G_END_DECLS
#endif /* __GST_NVENC_H_INCLUDED__ */ #endif /* __GST_NVENC_H_INCLUDED__ */

File diff suppressed because it is too large Load diff

View file

@ -0,0 +1,173 @@
/* GStreamer
* Copyright (C) 2022 Seungha Yang <seungha@centricular.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#pragma once
#include <gst/gst.h>
#include <gst/video/video.h>
#ifdef HAVE_NVCODEC_GST_D3D11
#include <gst/d3d11/gstd3d11.h>
#endif
#include <string.h>
#include "nvEncodeAPI.h"
#include "gstnvenc.h"
#include "gstcudamemory.h"
G_BEGIN_DECLS
#define GST_TYPE_NV_ENCODER (gst_nv_encoder_get_type())
#define GST_NV_ENCODER(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), GST_TYPE_NV_ENCODER, GstNvEncoder))
#define GST_NV_ENCODER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), GST_TYPE_NV_ENCODER, GstNvEncoderClass))
#define GST_IS_NV_ENCODER(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), GST_TYPE_NV_ENCODER))
#define GST_IS_NV_ENCODER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GST_TYPE_NV_ENCODER))
#define GST_NV_ENCODER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), GST_TYPE_NV_ENCODER, GstNvEncoderClass))
#define GST_NV_ENCODER_CAST(obj) ((GstNvEncoder *)obj)
typedef struct _GstNvEncoder GstNvEncoder;
typedef struct _GstNvEncoderClass GstNvEncoderClass;
typedef struct _GstNvEncoderPrivate GstNvEncoderPrivate;
typedef enum
{
GST_NV_ENCODER_RECONFIGURE_NONE,
GST_NV_ENCODER_RECONFIGURE_BITRATE,
GST_NV_ENCODER_RECONFIGURE_FULL,
} GstNvEncoderReconfigure;
#define GST_TYPE_NV_ENCODER_PRESET (gst_nv_encoder_preset_get_type())
GType gst_nv_encoder_preset_get_type (void);
typedef enum
{
GST_NV_ENCODER_PRESET_DEFAULT,
GST_NV_ENCODER_PRESET_HP,
GST_NV_ENCODER_PRESET_HQ,
GST_NV_ENCODER_PRESET_LOW_LATENCY_DEFAULT,
GST_NV_ENCODER_PRESET_LOW_LATENCY_HQ,
GST_NV_ENCODER_PRESET_LOW_LATENCY_HP,
GST_NV_ENCODER_PRESET_LOSSLESS_DEFAULT,
GST_NV_ENCODER_PRESET_LOSSLESS_HP,
} GstNvEncoderPreset;
#define GST_TYPE_NV_ENCODER_RC_MODE (gst_nv_encoder_rc_mode_get_type())
GType gst_nv_encoder_rc_mode_get_type (void);
typedef enum
{
GST_NV_ENCODER_RC_MODE_DEFAULT,
GST_NV_ENCODER_RC_MODE_CONSTQP,
GST_NV_ENCODER_RC_MODE_VBR,
GST_NV_ENCODER_RC_MODE_CBR,
GST_NV_ENCODER_RC_MODE_CBR_LOWDELAY_HQ,
GST_NV_ENCODER_RC_MODE_CBR_HQ,
GST_NV_ENCODER_RC_MODE_VBR_HQ,
} GstNvEncoderRCMode;
typedef struct
{
/* without ref */
GstNvEncoder *encoder;
/* Holds ownership */
GstBuffer *buffer;
GstMapInfo map_info;
NV_ENC_REGISTER_RESOURCE register_resource;
NV_ENC_MAP_INPUT_RESOURCE mapped_resource;
/* Used when input resource cannot be registered */
NV_ENC_CREATE_INPUT_BUFFER input_buffer;
NV_ENC_LOCK_INPUT_BUFFER lk_input_buffer;
NV_ENC_OUTPUT_PTR output_ptr;
gpointer event_handle;
gboolean is_eos;
} GstNvEncoderTask;
struct _GstNvEncoder
{
GstVideoEncoder parent;
GstNvEncoderPrivate *priv;
};
struct _GstNvEncoderClass
{
GstVideoEncoderClass parent_class;
gboolean (*set_format) (GstNvEncoder * encoder,
GstVideoCodecState * state,
gpointer session,
NV_ENC_INITIALIZE_PARAMS * init_params,
NV_ENC_CONFIG * config);
gboolean (*set_output_state) (GstNvEncoder * encoder,
GstVideoCodecState * state,
gpointer session);
GstBuffer * (*create_output_buffer) (GstNvEncoder * encoder,
NV_ENC_LOCK_BITSTREAM * bitstream);
GstNvEncoderReconfigure (*check_reconfigure) (GstNvEncoder * encoder,
NV_ENC_CONFIG * config);
};
GType gst_nv_encoder_get_type (void);
guint gst_nv_encoder_get_task_size (GstNvEncoder * encoder);
const gchar * gst_nv_encoder_status_to_string (NVENCSTATUS status);
#define GST_NVENC_STATUS_FORMAT "s (%d)"
#define GST_NVENC_STATUS_ARGS(s) gst_nv_encoder_status_to_string (s), s
void gst_nv_encoder_preset_to_guid (GstNvEncoderPreset preset,
GUID * guid);
NV_ENC_PARAMS_RC_MODE gst_nv_encoder_rc_mode_to_native (GstNvEncoderRCMode rc_mode);
void gst_nv_encoder_set_cuda_device_id (GstNvEncoder * encoder,
guint device_id);
void gst_nv_encoder_set_dxgi_adapter_luid (GstNvEncoder * encoder,
gint64 adapter_luid);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(GstNvEncoder, gst_object_unref)
G_END_DECLS
#ifdef __cplusplus
#ifndef G_OS_WIN32
inline bool is_equal_guid(const GUID & lhs, const GUID & rhs)
{
return !!memcmp(&lhs, &rhs, sizeof (GUID));
}
inline bool operator==(const GUID & lhs, const GUID & rhs)
{
return is_equal_guid(lhs, rhs);
}
inline bool operator!=(const GUID & lhs, const GUID & rhs)
{
return !(lhs == rhs);
}
#endif /* G_OS_WIN32 */
#endif /* __cplusplus */

File diff suppressed because it is too large Load diff

View file

@ -0,0 +1,37 @@
/* GStreamer
* Copyright (C) 2022 Seungha Yang <seungha@centricular.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#pragma once
#include "gstnvencoder.h"
G_BEGIN_DECLS
void gst_nv_h264_encoder_register_cuda (GstPlugin * plugin,
GstCudaContext * context,
guint rank);
#ifdef HAVE_NVCODEC_GST_D3D11
void gst_nv_h264_encoder_register_d3d11 (GstPlugin * plugin,
GstD3D11Device * device,
guint rank);
#endif
G_END_DECLS

File diff suppressed because it is too large Load diff

View file

@ -0,0 +1,36 @@
/* GStreamer
* Copyright (C) 2022 Seungha Yang <seungha@centricular.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#pragma once
#include "gstnvencoder.h"
G_BEGIN_DECLS
void gst_nv_h265_encoder_register_cuda (GstPlugin * plugin,
GstCudaContext * context,
guint rank);
#ifdef HAVE_NVCODEC_GST_D3D11
void gst_nv_h265_encoder_register_d3d11 (GstPlugin * plugin,
GstD3D11Device * device,
guint rank);
#endif
G_END_DECLS

View file

@ -25,6 +25,9 @@ nvcodec_sources = [
'gstcudascale.c', 'gstcudascale.c',
'gstnvvp8dec.c', 'gstnvvp8dec.c',
'gstnvvp9dec.c', 'gstnvvp9dec.c',
'gstnvencoder.cpp',
'gstnvh264encoder.cpp',
'gstnvh265encoder.cpp',
] ]
nvmm_sources = [ nvmm_sources = [
@ -36,14 +39,14 @@ if get_option('nvcodec').disabled()
endif endif
plugin_incdirs = [configinc, include_directories('./stub')] plugin_incdirs = [configinc, include_directories('./stub')]
extra_c_args = ['-DGST_USE_UNSTABLE_API'] extra_args = ['-DGST_USE_UNSTABLE_API']
if gstgl_dep.found() if gstgl_dep.found()
extra_c_args += ['-DHAVE_NVCODEC_GST_GL=1'] extra_args += ['-DHAVE_NVCODEC_GST_GL=1']
endif endif
if gstd3d11_dep.found() if gstd3d11_dep.found()
extra_c_args += ['-DHAVE_NVCODEC_GST_D3D11=1', '-DCOBJMACROS'] extra_args += ['-DHAVE_NVCODEC_GST_D3D11=1', '-DCOBJMACROS']
endif endif
if host_system == 'linux' if host_system == 'linux'
@ -57,14 +60,29 @@ if host_system == 'linux'
endif endif
if have_nvmm if have_nvmm
extra_c_args += ['-DHAVE_NVCODEC_NVMM'] extra_args += ['-DHAVE_NVCODEC_NVMM']
nvcodec_sources += nvmm_sources nvcodec_sources += nvmm_sources
endif endif
endif endif
override_opt = []
if host_system == 'windows'
# MinGW 32bits compiler seems to be complaining about redundant-decls
# when ComPtr is in use. Let's just disable the warning
if cc.get_id() != 'msvc'
extra_args += cc.get_supported_arguments([
'-Wno-redundant-decls',
])
endif
else
override_opt += ['cpp_std=c++11']
endif
gstnvcodec = library('gstnvcodec', gstnvcodec = library('gstnvcodec',
nvcodec_sources, nvcodec_sources,
c_args : gst_plugins_bad_args + extra_c_args, c_args : gst_plugins_bad_args + extra_args,
cpp_args : gst_plugins_bad_args + extra_args,
override_options: override_opt,
include_directories : plugin_incdirs, include_directories : plugin_incdirs,
dependencies : [gstbase_dep, gstvideo_dep, gstpbutils_dep, gstgl_dep, gstglproto_dep, gmodule_dep, gstcodecs_dep, gstd3d11_dep], dependencies : [gstbase_dep, gstvideo_dep, gstpbutils_dep, gstgl_dep, gstglproto_dep, gmodule_dep, gstcodecs_dep, gstd3d11_dep],
install : true, install : true,

View file

@ -43,6 +43,12 @@
#include "gstcudanvmm.h" #include "gstcudanvmm.h"
#endif #endif
#ifdef HAVE_NVCODEC_GST_D3D11
#include <gst/d3d11/gstd3d11.h>
#endif
#include "gstnvh264encoder.h"
#include "gstnvh265encoder.h"
GST_DEBUG_CATEGORY (gst_nvcodec_debug); GST_DEBUG_CATEGORY (gst_nvcodec_debug);
GST_DEBUG_CATEGORY (gst_nvdec_debug); GST_DEBUG_CATEGORY (gst_nvdec_debug);
GST_DEBUG_CATEGORY (gst_nvenc_debug); GST_DEBUG_CATEGORY (gst_nvenc_debug);
@ -59,7 +65,7 @@ plugin_init (GstPlugin * plugin)
{ {
CUresult cuda_ret; CUresult cuda_ret;
gint dev_count = 0; gint dev_count = 0;
gint i; guint i;
gboolean nvdec_available = TRUE; gboolean nvdec_available = TRUE;
gboolean nvenc_available = TRUE; gboolean nvenc_available = TRUE;
/* hardcoded minimum supported version */ /* hardcoded minimum supported version */
@ -139,24 +145,15 @@ plugin_init (GstPlugin * plugin)
} }
for (i = 0; i < dev_count; i++) { for (i = 0; i < dev_count; i++) {
CUdevice cuda_device; GstCudaContext *context = gst_cuda_context_new (i);
CUcontext cuda_ctx; CUcontext cuda_ctx;
cuda_ret = CuDeviceGet (&cuda_device, i); if (!context) {
if (cuda_ret != CUDA_SUCCESS) { GST_WARNING ("Failed to create context for deevice %d", i);
GST_WARNING ("Failed to get device handle %d, ret: 0x%x", i,
(gint) cuda_ret);
continue; continue;
} }
cuda_ret = CuCtxCreate (&cuda_ctx, 0, cuda_device); cuda_ctx = gst_cuda_context_get_handle (context);
if (cuda_ret != CUDA_SUCCESS) {
GST_WARNING ("Failed to create cuda context, ret: 0x%x", (gint) cuda_ret);
continue;
}
CuCtxPopCurrent (NULL);
if (nvdec_available) { if (nvdec_available) {
gint j; gint j;
@ -237,10 +234,32 @@ plugin_init (GstPlugin * plugin)
} }
} }
if (nvenc_available) if (nvenc_available) {
gst_nvenc_plugin_init (plugin, i, cuda_ctx); #ifdef HAVE_NVCODEC_GST_D3D11
if (g_win32_check_windows_version (6, 0, 0, G_WIN32_OS_ANY)) {
gint64 adapter_luid;
GstD3D11Device *d3d11_device;
CuCtxDestroy (cuda_ctx); g_object_get (context, "dxgi-adapter-luid", &adapter_luid, NULL);
d3d11_device = gst_d3d11_device_new_for_adapter_luid (adapter_luid,
D3D11_CREATE_DEVICE_BGRA_SUPPORT);
if (!d3d11_device) {
GST_WARNING ("Failed to d3d11 create device");
} else {
gst_nv_h264_encoder_register_d3d11 (plugin,
d3d11_device, GST_RANK_NONE);
gst_nv_h265_encoder_register_d3d11 (plugin,
d3d11_device, GST_RANK_NONE);
gst_object_unref (d3d11_device);
}
}
#endif
gst_nv_h264_encoder_register_cuda (plugin, context, GST_RANK_NONE);
gst_nv_h265_encoder_register_cuda (plugin, context, GST_RANK_NONE);
gst_nvenc_plugin_init (plugin, i, cuda_ctx);
}
gst_object_unref (context);
} }
gst_cuda_memory_copy_register (plugin, GST_RANK_NONE); gst_cuda_memory_copy_register (plugin, GST_RANK_NONE);

View file

@ -34,16 +34,20 @@
#include <termios.h> #include <termios.h>
#endif #endif
#ifdef G_OS_WIN32
#include <windows.h>
#include <io.h>
#endif
#include <gst/gst.h> #include <gst/gst.h>
/* This is all not thread-safe, but doesn't have to be really */ /* This is all not thread-safe, but doesn't have to be really */
#ifdef G_OS_UNIX
static struct termios term_settings;
static gboolean term_settings_saved = FALSE;
static GstNvCodecPlayKbFunc kb_callback; static GstNvCodecPlayKbFunc kb_callback;
static gpointer kb_callback_data; static gpointer kb_callback_data;
#ifdef G_OS_UNIX
static struct termios term_settings;
static gboolean term_settings_saved = FALSE;
static gulong io_watch_id; static gulong io_watch_id;
static gboolean static gboolean
@ -129,7 +133,158 @@ gst_nvcodec_kb_set_key_handler (GstNvCodecPlayKbFunc kb_func,
return TRUE; return TRUE;
} }
#else /* !G_OS_UNIX */ #elif defined(G_OS_WIN32)
typedef struct
{
GThread *thread;
HANDLE event_handle;
HANDLE console_handle;
gboolean closing;
GMutex lock;
} Win32KeyHandler;
static Win32KeyHandler *win32_handler = NULL;
static gboolean
gst_nvcodec_kb_source_cb (Win32KeyHandler * handler)
{
HANDLE h_input = handler->console_handle;
INPUT_RECORD buffer;
DWORD n;
if (PeekConsoleInput (h_input, &buffer, 1, &n) && n == 1) {
ReadConsoleInput (h_input, &buffer, 1, &n);
if (buffer.EventType == KEY_EVENT && buffer.Event.KeyEvent.bKeyDown) {
gchar key_val[2] = { 0 };
switch (buffer.Event.KeyEvent.wVirtualKeyCode) {
case VK_RIGHT:
kb_callback (GST_NVCODEC_KB_ARROW_RIGHT, kb_callback_data);
break;
case VK_LEFT:
kb_callback (GST_NVCODEC_KB_ARROW_LEFT, kb_callback_data);
break;
case VK_UP:
kb_callback (GST_NVCODEC_KB_ARROW_UP, kb_callback_data);
break;
case VK_DOWN:
kb_callback (GST_NVCODEC_KB_ARROW_DOWN, kb_callback_data);
break;
default:
key_val[0] = buffer.Event.KeyEvent.uChar.AsciiChar;
kb_callback (key_val, kb_callback_data);
break;
}
}
}
return G_SOURCE_REMOVE;
}
static gpointer
gst_nvcodec_kb_win32_thread (gpointer user_data)
{
Win32KeyHandler *handler = (Win32KeyHandler *) user_data;
HANDLE handles[2];
handles[0] = handler->event_handle;
handles[1] = handler->console_handle;
if (!kb_callback)
return NULL;
while (TRUE) {
DWORD ret = WaitForMultipleObjects (2, handles, FALSE, INFINITE);
if (ret == WAIT_FAILED) {
GST_WARNING ("WaitForMultipleObject Failed");
return NULL;
}
g_mutex_lock (&handler->lock);
if (handler->closing) {
g_mutex_unlock (&handler->lock);
return NULL;
}
g_mutex_unlock (&handler->lock);
g_idle_add ((GSourceFunc) gst_nvcodec_kb_source_cb, handler);
}
return NULL;
}
gboolean
gst_nvcodec_kb_set_key_handler (GstNvCodecPlayKbFunc kb_func,
gpointer user_data)
{
gint fd = _fileno (stdin);
if (!_isatty (fd)) {
GST_INFO ("stdin is not connected to a terminal");
return FALSE;
}
if (win32_handler) {
g_mutex_lock (&win32_handler->lock);
win32_handler->closing = TRUE;
g_mutex_unlock (&win32_handler->lock);
SetEvent (win32_handler->event_handle);
g_thread_join (win32_handler->thread);
CloseHandle (win32_handler->event_handle);
g_mutex_clear (&win32_handler->lock);
g_free (win32_handler);
win32_handler = NULL;
}
if (kb_func) {
SECURITY_ATTRIBUTES sec_attrs;
sec_attrs.nLength = sizeof (SECURITY_ATTRIBUTES);
sec_attrs.lpSecurityDescriptor = NULL;
sec_attrs.bInheritHandle = FALSE;
win32_handler = g_new0 (Win32KeyHandler, 1);
/* create cancellable event handle */
win32_handler->event_handle = CreateEvent (&sec_attrs, TRUE, FALSE, NULL);
if (!win32_handler->event_handle) {
GST_WARNING ("Couldn't create event handle");
g_free (win32_handler);
win32_handler = NULL;
return FALSE;
}
win32_handler->console_handle = GetStdHandle (STD_INPUT_HANDLE);
if (!win32_handler->console_handle) {
GST_WARNING ("Couldn't get console handle");
CloseHandle (win32_handler->event_handle);
g_free (win32_handler);
win32_handler = NULL;
return FALSE;
}
g_mutex_init (&win32_handler->lock);
win32_handler->thread =
g_thread_new ("gst-play-kb", gst_nvcodec_kb_win32_thread,
win32_handler);
}
kb_callback = kb_func;
kb_callback_data = user_data;
return TRUE;
}
#else
gboolean gboolean
gst_nvcodec_kb_set_key_handler (GstNvCodecPlayKbFunc key_func, gst_nvcodec_kb_set_key_handler (GstNvCodecPlayKbFunc key_func,

View file

@ -231,14 +231,15 @@ bus_msg (GstBus * bus, GstMessage * msg, gpointer user_data)
} }
static gboolean static gboolean
check_nvcodec_available (void) check_nvcodec_available (const gchar * encoder_name)
{ {
gboolean ret = TRUE; gboolean ret = TRUE;
GstElement *elem; GstElement *elem;
elem = gst_element_factory_make ("nvh264enc", NULL); elem = gst_element_factory_make (encoder_name, NULL);
if (!elem) { if (!elem) {
GST_WARNING ("nvh264enc is not available, possibly driver load failure"); GST_WARNING ("%s is not available, possibly driver load failure",
encoder_name);
return FALSE; return FALSE;
} }
@ -332,13 +333,16 @@ main (gint argc, gchar ** argv)
GstCaps *caps; GstCaps *caps;
TestCallbackData data = { 0, }; TestCallbackData data = { 0, };
GstPad *pad; GstPad *pad;
gchar *encoder_name = NULL;
/* *INDENT-OFF* */
GOptionEntry options[] = { GOptionEntry options[] = {
{"use-gl", 0, 0, G_OPTION_ARG_NONE, &use_gl, {"use-gl", 0, 0, G_OPTION_ARG_NONE, &use_gl,
"Use OpenGL memory as input to the nvenc", NULL} "Use OpenGL memory as input to the nvenc", NULL},
, {"encoder", 0, 0, G_OPTION_ARG_STRING, &encoder_name,
"NVENC encoder element to test, default: nvh264enc"},
{NULL} {NULL}
}; };
/* *INDENT-ON* */
option_ctx = g_option_context_new ("nvcodec dynamic reconfigure example"); option_ctx = g_option_context_new ("nvcodec dynamic reconfigure example");
g_option_context_add_main_entries (option_ctx, options, NULL); g_option_context_add_main_entries (option_ctx, options, NULL);
@ -352,7 +356,10 @@ main (gint argc, gchar ** argv)
g_option_context_free (option_ctx); g_option_context_free (option_ctx);
gst_init (NULL, NULL); gst_init (NULL, NULL);
if (!check_nvcodec_available ()) { if (!encoder_name)
encoder_name = g_strdup ("nvh264enc");
if (!check_nvcodec_available (encoder_name)) {
g_printerr ("Cannot load nvcodec plugin"); g_printerr ("Cannot load nvcodec plugin");
exit (1); exit (1);
} }
@ -404,7 +411,7 @@ main (gint argc, gchar ** argv)
capsfilter = gst_element_factory_make ("capsfilter", NULL); capsfilter = gst_element_factory_make ("capsfilter", NULL);
queue = gst_element_factory_make ("queue", NULL); queue = gst_element_factory_make ("queue", NULL);
enc = gst_element_factory_make ("nvh264enc", NULL); enc = gst_element_factory_make (encoder_name, NULL);
parse = gst_element_factory_make ("h264parse", NULL); parse = gst_element_factory_make ("h264parse", NULL);
/* vbr with target bitrate */ /* vbr with target bitrate */
@ -471,6 +478,7 @@ terminate:
gst_object_unref (pipeline); gst_object_unref (pipeline);
g_main_loop_unref (loop); g_main_loop_unref (loop);
g_free (encoder_name);
return exitcode; return exitcode;
} }