From f2831c4a36823b2c1bf92083d1374f094a2899e4 Mon Sep 17 00:00:00 2001 From: Sebastian Lackner Date: Sun, 8 Feb 2015 08:40:31 +0100 Subject: [PATCH] Added patch to implement NVIDIA video encoder library (nvencodeapi). --- README.md | 3 +- debian/changelog | 1 + ...001-nvencodeapi-First-implementation.patch | 748 ++++++++++++++++++ patches/nvencodeapi-Video_Encoder/definition | 2 + patches/patchinstall.sh | 24 + 5 files changed, 777 insertions(+), 1 deletion(-) create mode 100644 patches/nvencodeapi-Video_Encoder/0001-nvencodeapi-First-implementation.patch create mode 100644 patches/nvencodeapi-Video_Encoder/definition diff --git a/README.md b/README.md index 85a7677d..ba464c57 100644 --- a/README.md +++ b/README.md @@ -38,7 +38,7 @@ Wine. All those differences are also documented on the Included bug fixes and improvements =================================== -**Bugfixes and features included in the next upcoming release [12]:** +**Bugfixes and features included in the next upcoming release [13]:** * Add implementation for CreateThreadpool ([Wine Bug #35192](https://bugs.winehq.org/show_bug.cgi?id=35192)) * Add library override instead of closing winecfg when pressing ENTER over the combobox ([Wine Bug #12804](https://bugs.winehq.org/show_bug.cgi?id=12804)) @@ -52,6 +52,7 @@ Included bug fixes and improvements * Implement threadpool wait objects * Implement threadpool work items ([Wine Bug #32531](https://bugs.winehq.org/show_bug.cgi?id=32531)) * Jedi Knight: Dark Forces II crashes with winmm set to native ([Wine Bug #37983](https://bugs.winehq.org/show_bug.cgi?id=37983)) +* Support for NVIDIA video encoder library (nvencodeapi) **Bugs fixed in Wine Staging 1.7.35 [146]:** diff --git a/debian/changelog b/debian/changelog index a4e9661c..bebfc5ac 100644 --- a/debian/changelog +++ b/debian/changelog @@ -12,6 +12,7 @@ wine-staging (1.7.36) UNRELEASED; urgency=low * Added patch to add library override instead of closing winecfg when pressing ENTER over the combobox. * Added patchset for various improvements and cleanup of reg.exe. * Added patch to add performance library registry keys needed by MS SQL Server Management Studio Express 2008 R2. + * Added patch to implement NVIDIA video encoder library (nvencodeapi). * Removed patch to add additional tests for SLGetWindowsInformationDWORD (accepted upstream). * Removed patch to avoid filling KdHelp structure for usermode applications (accepted upstream). -- Sebastian Lackner Sun, 25 Jan 2015 05:58:36 +0100 diff --git a/patches/nvencodeapi-Video_Encoder/0001-nvencodeapi-First-implementation.patch b/patches/nvencodeapi-Video_Encoder/0001-nvencodeapi-First-implementation.patch new file mode 100644 index 00000000..366d73df --- /dev/null +++ b/patches/nvencodeapi-Video_Encoder/0001-nvencodeapi-First-implementation.patch @@ -0,0 +1,748 @@ +From e8580b7171ce93196fd703d6ed36387f133f8a85 Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Michael=20M=C3=BCller?= +Date: Sun, 8 Feb 2015 06:10:26 +0100 +Subject: nvencodeapi: First implementation. + +--- + configure.ac | 2 + + dlls/nvencodeapi/Makefile.in | 4 + + dlls/nvencodeapi/nvencodeapi.c | 370 ++++++++++++++++++++++++++++++++++ + dlls/nvencodeapi/nvencodeapi.spec | 1 + + dlls/nvencodeapi64/Makefile.in | 5 + + dlls/nvencodeapi64/nvencodeapi64.spec | 1 + + include/Makefile.in | 1 + + include/nvencodeapi.h | 281 ++++++++++++++++++++++++++ + 8 files changed, 665 insertions(+) + create mode 100644 dlls/nvencodeapi/Makefile.in + create mode 100644 dlls/nvencodeapi/nvencodeapi.c + create mode 100644 dlls/nvencodeapi/nvencodeapi.spec + create mode 100644 dlls/nvencodeapi64/Makefile.in + create mode 100644 dlls/nvencodeapi64/nvencodeapi64.spec + create mode 100644 include/nvencodeapi.h + +diff --git a/configure.ac b/configure.ac +index 89b8d58..fcd6bc4 100644 +--- a/configure.ac ++++ b/configure.ac +@@ -3153,6 +3153,8 @@ WINE_CONFIG_DLL(nvapi64,enable_win64) + WINE_CONFIG_DLL(nvcuda) + WINE_CONFIG_TEST(dlls/nvcuda/tests) + WINE_CONFIG_DLL(nvcuvid) ++WINE_CONFIG_DLL(nvencodeapi,enable_win32) ++WINE_CONFIG_DLL(nvencodeapi64,enable_win64) + WINE_CONFIG_DLL(objsel,,[clean]) + WINE_CONFIG_DLL(odbc32,,[implib]) + WINE_CONFIG_DLL(odbccp32,,[implib]) +diff --git a/dlls/nvencodeapi/Makefile.in b/dlls/nvencodeapi/Makefile.in +new file mode 100644 +index 0000000..a2e58ac +--- /dev/null ++++ b/dlls/nvencodeapi/Makefile.in +@@ -0,0 +1,4 @@ ++MODULE = nvencodeapi.dll ++ ++C_SRCS = \ ++ nvencodeapi.c +diff --git a/dlls/nvencodeapi/nvencodeapi.c b/dlls/nvencodeapi/nvencodeapi.c +new file mode 100644 +index 0000000..7a0f531 +--- /dev/null ++++ b/dlls/nvencodeapi/nvencodeapi.c +@@ -0,0 +1,370 @@ ++/* ++ * Copyright (C) 2015 Michael Müller ++ * ++ * This library is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU Lesser General Public ++ * License as published by the Free Software Foundation; either ++ * version 2.1 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 ++ * Lesser General Public License for more details. ++ * ++ * You should have received a copy of the GNU Lesser 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 ++ */ ++ ++#include "config.h" ++#include "wine/port.h" ++ ++#include ++ ++#include "windef.h" ++#include "winbase.h" ++#include "wine/debug.h" ++#include "wine/library.h" ++ ++#include "nvencodeapi.h" ++ ++WINE_DEFAULT_DEBUG_CHANNEL(nvencodeapi); ++ ++static void *libnvidia_encode_handle = NULL; ++static LINUX_NV_ENCODE_API_FUNCTION_LIST origFunctions; ++ ++static NVENCSTATUS (*pNvEncodeAPICreateInstance)(LINUX_NV_ENCODE_API_FUNCTION_LIST *functionList); ++ ++static NVENCSTATUS WINAPI NvEncOpenEncodeSession(void *device, uint32_t deviceType, void **encoder) ++{ ++ TRACE("(%p, %u, %p)\n", device, deviceType, encoder); ++ return origFunctions.nvEncOpenEncodeSession(device, deviceType, encoder); ++} ++ ++static NVENCSTATUS WINAPI NvEncGetEncodeGUIDCount(void *encoder, uint32_t *encodeGUIDCount) ++{ ++ TRACE("(%p, %p)\n", encoder, encodeGUIDCount); ++ return origFunctions.nvEncGetEncodeGUIDCount(encoder, encodeGUIDCount); ++} ++ ++static NVENCSTATUS WINAPI NvEncGetEncodeGUIDs(void *encoder, GUID *GUIDs, uint32_t guidArraySize, uint32_t *GUIDCount) ++{ ++ TRACE("(%p, %p, %u, %p)\n", encoder, GUIDs, guidArraySize, GUIDCount); ++ return origFunctions.nvEncGetEncodeGUIDs(encoder, GUIDs, guidArraySize, GUIDCount); ++} ++ ++static NVENCSTATUS WINAPI NvEncGetEncodeProfileGUIDCount(void *encoder, GUID encodeGUID, uint32_t *encodeProfileGUIDCount) ++{ ++ TRACE("(%p, %s, %p)\n", encoder, debugstr_guid(&encodeGUID), encodeProfileGUIDCount); ++ return origFunctions.nvEncGetEncodeProfileGUIDCount(encoder, encodeGUID, encodeProfileGUIDCount); ++} ++ ++static NVENCSTATUS WINAPI NvEncGetEncodeProfileGUIDs(void *encoder, GUID encodeGUID, GUID *profileGUIDs, ++ uint32_t guidArraySize, uint32_t *GUIDCount) ++{ ++ TRACE("(%p, %s, %p, %u, %p)\n", encoder, debugstr_guid(&encodeGUID), profileGUIDs, guidArraySize, GUIDCount); ++ return origFunctions.nvEncGetEncodeProfileGUIDs(encoder, encodeGUID, profileGUIDs, guidArraySize, GUIDCount); ++} ++ ++static NVENCSTATUS WINAPI NvEncGetInputFormatCount(void *encoder, GUID encodeGUID, uint32_t *inputFmtCount) ++{ ++ TRACE("(%p, %s, %p)\n", encoder, debugstr_guid(&encodeGUID), inputFmtCount); ++ return origFunctions.nvEncGetInputFormatCount(encoder, encodeGUID, inputFmtCount); ++} ++ ++static NVENCSTATUS WINAPI NvEncGetInputFormats(void *encoder, GUID encodeGUID, NV_ENC_BUFFER_FORMAT *inputFmts, ++ uint32_t inputFmtArraySize, uint32_t *inputFmtCount) ++{ ++ TRACE("(%p, %s, %p)\n", encoder, debugstr_guid(&encodeGUID), inputFmtCount); ++ return origFunctions.nvEncGetInputFormatCount(encoder, encodeGUID, inputFmtCount); ++} ++ ++static NVENCSTATUS WINAPI NvEncGetEncodeCaps(void *encoder, GUID encodeGUID, NV_ENC_CAPS_PARAM *capsParam, int *capsVal) ++{ ++ TRACE("(%p, %s, %p, %p)\n", encoder, debugstr_guid(&encodeGUID), capsParam, capsVal); ++ return origFunctions.nvEncGetEncodeCaps(encoder, encodeGUID, capsParam, capsVal); ++} ++ ++static NVENCSTATUS WINAPI NvEncGetEncodePresetCount(void *encoder, GUID encodeGUID, uint32_t *encodePresetGUIDCount) ++{ ++ TRACE("(%p, %s, %p)\n", encoder, debugstr_guid(&encodeGUID), encodePresetGUIDCount); ++ return origFunctions.nvEncGetEncodePresetCount(encoder, encodeGUID, encodePresetGUIDCount); ++} ++ ++static NVENCSTATUS WINAPI NvEncGetEncodePresetGUIDs(void *encoder, GUID encodeGUID, GUID *presetGUIDs, uint32_t guidArraySize, ++ uint32_t *encodePresetGUIDCount) ++{ ++ TRACE("(%p, %s, %p, %u, %p)\n", encoder, debugstr_guid(&encodeGUID), presetGUIDs, guidArraySize, encodePresetGUIDCount); ++ return origFunctions.nvEncGetEncodePresetGUIDs(encoder, encodeGUID, presetGUIDs, guidArraySize, encodePresetGUIDCount); ++} ++ ++static NVENCSTATUS WINAPI NvEncGetEncodePresetConfig(void *encoder, GUID encodeGUID, GUID presetGUID, NV_ENC_PRESET_CONFIG *presetConfig) ++{ ++ TRACE("(%p, %s, %s, %p)\n", encoder, debugstr_guid(&encodeGUID), debugstr_guid(&presetGUID), presetConfig); ++ return origFunctions.nvEncGetEncodePresetConfig(encoder, encodeGUID, presetGUID, presetConfig); ++} ++ ++static NVENCSTATUS WINAPI NvEncInitializeEncoder(void *encoder, NV_ENC_INITIALIZE_PARAMS *createEncodeParams) ++{ ++ NV_ENC_INITIALIZE_PARAMS linux_encode_params; ++ ++ TRACE("(%p, %p)\n", encoder, createEncodeParams); ++ ++ if (!createEncodeParams) ++ return NV_ENC_ERR_INVALID_PTR; ++ ++ if (createEncodeParams->enableEncodeAsync) ++ { ++ FIXME("Async encoding is not supported by the linux NVIDIA driver.\n"); ++ FIXME("Trying to emulate async mode, but this might not work for all applications.\n"); ++ ++ /* Forward modified information to the linux library. */ ++ linux_encode_params = *createEncodeParams; ++ createEncodeParams = &linux_encode_params; ++ linux_encode_params.enableEncodeAsync = 0; ++ } ++ ++ return origFunctions.nvEncInitializeEncoder(encoder, createEncodeParams); ++} ++ ++static NVENCSTATUS WINAPI NvEncCreateInputBuffer(void *encoder, NV_ENC_CREATE_INPUT_BUFFER *createInputBufferParams) ++{ ++ TRACE("(%p, %p)\n", encoder, createInputBufferParams); ++ return origFunctions.nvEncCreateInputBuffer(encoder, createInputBufferParams); ++} ++ ++static NVENCSTATUS WINAPI NvEncDestroyInputBuffer(void *encoder, NV_ENC_INPUT_PTR inputBuffer) ++{ ++ TRACE("(%p, %p)\n", encoder, inputBuffer); ++ return origFunctions.nvEncDestroyInputBuffer(encoder, inputBuffer); ++} ++ ++static NVENCSTATUS WINAPI NvEncCreateBitstreamBuffer(void *encoder, NV_ENC_CREATE_BITSTREAM_BUFFER *createBitstreamBufferParams) ++{ ++ TRACE("(%p, %p)\n", encoder, createBitstreamBufferParams); ++ return origFunctions.nvEncCreateBitstreamBuffer(encoder, createBitstreamBufferParams); ++} ++ ++static NVENCSTATUS WINAPI NvEncDestroyBitstreamBuffer(void *encoder, NV_ENC_OUTPUT_PTR bitstreamBuffer) ++{ ++ TRACE("(%p, %p)\n", encoder, bitstreamBuffer); ++ return origFunctions.nvEncDestroyBitstreamBuffer(encoder, bitstreamBuffer); ++} ++ ++static NVENCSTATUS WINAPI NvEncEncodePicture(void *encoder, NV_ENC_PIC_PARAMS *encodePicParams) ++{ ++ NVENCSTATUS result; ++ TRACE("(%p, %p)\n", encoder, encodePicParams); ++ ++ result = origFunctions.nvEncEncodePicture(encoder, encodePicParams); ++ ++ if (encodePicParams->completionEvent) ++ SetEvent(encodePicParams->completionEvent); ++ ++ return result; ++} ++ ++static NVENCSTATUS WINAPI NvEncLockBitstream(void *encoder, NV_ENC_LOCK_BITSTREAM *lockBitstreamBufferParams) ++{ ++ TRACE("(%p, %p)\n", encoder, lockBitstreamBufferParams); ++ return origFunctions.nvEncLockBitstream(encoder, lockBitstreamBufferParams); ++} ++ ++static NVENCSTATUS WINAPI NvEncUnlockBitstream(void *encoder, NV_ENC_OUTPUT_PTR bitstreamBuffer) ++{ ++ TRACE("(%p, %p)\n", encoder, bitstreamBuffer); ++ return origFunctions.nvEncUnlockBitstream(encoder, bitstreamBuffer); ++} ++ ++static NVENCSTATUS WINAPI NvEncLockInputBuffer(void *encoder, NV_ENC_LOCK_INPUT_BUFFER *lockInputBufferParams) ++{ ++ TRACE("(%p, %p)\n", encoder, lockInputBufferParams); ++ return origFunctions.nvEncLockInputBuffer(encoder, lockInputBufferParams); ++} ++ ++static NVENCSTATUS WINAPI NvEncUnlockInputBuffer(void *encoder, NV_ENC_INPUT_PTR inputBuffer) ++{ ++ TRACE("(%p, %p)\n", encoder, inputBuffer); ++ return origFunctions.nvEncUnlockInputBuffer(encoder, inputBuffer); ++} ++ ++static NVENCSTATUS WINAPI NvEncGetEncodeStats(void *encoder, NV_ENC_STAT *encodeStats) ++{ ++ TRACE("(%p, %p)\n", encoder, encodeStats); ++ return origFunctions.nvEncGetEncodeStats(encoder, encodeStats); ++} ++ ++static NVENCSTATUS WINAPI NvEncGetSequenceParams(void *encoder, NV_ENC_SEQUENCE_PARAM_PAYLOAD *sequenceParamPayload) ++{ ++ TRACE("(%p, %p)\n", encoder, sequenceParamPayload); ++ return origFunctions.nvEncGetSequenceParams(encoder, sequenceParamPayload); ++} ++ ++static NVENCSTATUS WINAPI NvEncRegisterAsyncEvent(void *encoder, NV_ENC_EVENT_PARAMS *eventParams) ++{ ++ TRACE("(%p, %p)\n", encoder, eventParams); ++ /* This function will always fail as the linux NVIDIA driver doesn't support async mode */ ++ /* return origFunctions.nvEncRegisterAsyncEvent(encoder, eventParams); */ ++ return NV_ENC_SUCCESS; ++} ++ ++static NVENCSTATUS WINAPI NvEncUnregisterAsyncEvent(void *encoder, NV_ENC_EVENT_PARAMS *eventParams) ++{ ++ TRACE("(%p, %p)\n", encoder, eventParams); ++ /* This function will always fail as the linux NVIDIA driver doesn't support async mode */ ++ /* return origFunctions.nvEncUnregisterAsyncEvent(encoder, eventParams); */ ++ return NV_ENC_SUCCESS; ++} ++ ++static NVENCSTATUS WINAPI NvEncMapInputResource(void *encoder, NV_ENC_MAP_INPUT_RESOURCE *mapInputResParams) ++{ ++ TRACE("(%p, %p)\n", encoder, mapInputResParams); ++ return origFunctions.nvEncMapInputResource(encoder, mapInputResParams); ++} ++ ++static NVENCSTATUS WINAPI NvEncUnmapInputResource(void *encoder, NV_ENC_INPUT_PTR mappedInputBuffer) ++{ ++ TRACE("(%p, %p)\n", encoder, mappedInputBuffer); ++ return origFunctions.nvEncUnmapInputResource(encoder, mappedInputBuffer); ++} ++ ++static NVENCSTATUS WINAPI NvEncDestroyEncoder(void *encoder) ++{ ++ TRACE("(%p)\n", encoder); ++ return origFunctions.nvEncDestroyEncoder(encoder); ++} ++ ++static NVENCSTATUS WINAPI NvEncInvalidateRefFrames(void *encoder, uint64_t invalidRefFrameTimeStamp) ++{ ++ TRACE("(%p, %llu)\n", encoder, invalidRefFrameTimeStamp); ++ return origFunctions.nvEncInvalidateRefFrames(encoder, invalidRefFrameTimeStamp); ++} ++ ++static NVENCSTATUS WINAPI NvEncOpenEncodeSessionEx(NV_ENC_OPEN_ENCODE_SESSION_EX_PARAMS *openSessionExParams, void **encoder) ++{ ++ TRACE("(%p, %p)\n", openSessionExParams, encoder); ++ return origFunctions.nvEncOpenEncodeSessionEx(openSessionExParams, encoder); ++} ++ ++static NVENCSTATUS WINAPI NvEncRegisterResource(void *encoder, NV_ENC_REGISTER_RESOURCE *registerResParams) ++{ ++ TRACE("(%p, %p)\n", encoder, registerResParams); ++ return origFunctions.nvEncRegisterResource(encoder, registerResParams); ++} ++ ++static NVENCSTATUS WINAPI NvEncUnregisterResource(void *encoder, NV_ENC_REGISTERED_PTR registeredResource) ++{ ++ TRACE("(%p, %p)\n", encoder, registeredResource); ++ return origFunctions.nvEncUnregisterResource(encoder, registeredResource); ++} ++ ++static NVENCSTATUS WINAPI NvEncReconfigureEncoder(void *encoder, NV_ENC_RECONFIGURE_PARAMS *reInitEncodeParams) ++{ ++ TRACE("(%p, %p)\n", encoder, reInitEncodeParams); ++ return origFunctions.nvEncReconfigureEncoder(encoder, reInitEncodeParams); ++} ++ ++ ++NVENCSTATUS WINAPI NvEncodeAPICreateInstance(NV_ENCODE_API_FUNCTION_LIST *functionList) ++{ ++ TRACE("(%p)\n", functionList); ++ ++ if (!functionList) ++ return NV_ENC_ERR_INVALID_PTR; ++ ++ /* FIXME: Provide forward/backwards compatibility */ ++ if (functionList->version != NV_ENCODE_API_FUNCTION_LIST_VER) ++ FIXME("Application expects nvencodeapi version %x, but wrapper only supports version %x\n", ++ functionList->version, NV_ENCODE_API_FUNCTION_LIST_VER); ++ ++ /* set all function points and reserved values to zero */ ++ memset(functionList, 0, sizeof(*functionList)); ++ functionList->version = origFunctions.version; ++ ++ #define SET_FUNCPTR(f) if (origFunctions.nv##f) functionList->nv##f = &Nv##f ++ ++ SET_FUNCPTR(EncOpenEncodeSession); ++ SET_FUNCPTR(EncGetEncodeGUIDCount); ++ SET_FUNCPTR(EncGetEncodeProfileGUIDCount); ++ SET_FUNCPTR(EncGetEncodeProfileGUIDs); ++ SET_FUNCPTR(EncGetEncodeGUIDs); ++ SET_FUNCPTR(EncGetInputFormatCount); ++ SET_FUNCPTR(EncGetInputFormats); ++ SET_FUNCPTR(EncGetEncodeCaps); ++ SET_FUNCPTR(EncGetEncodePresetCount); ++ SET_FUNCPTR(EncGetEncodePresetGUIDs); ++ SET_FUNCPTR(EncGetEncodePresetConfig); ++ SET_FUNCPTR(EncInitializeEncoder); ++ SET_FUNCPTR(EncCreateInputBuffer); ++ SET_FUNCPTR(EncDestroyInputBuffer); ++ SET_FUNCPTR(EncCreateBitstreamBuffer); ++ SET_FUNCPTR(EncDestroyBitstreamBuffer); ++ SET_FUNCPTR(EncEncodePicture); ++ SET_FUNCPTR(EncLockBitstream); ++ SET_FUNCPTR(EncUnlockBitstream); ++ SET_FUNCPTR(EncLockInputBuffer); ++ SET_FUNCPTR(EncUnlockInputBuffer); ++ SET_FUNCPTR(EncGetEncodeStats); ++ SET_FUNCPTR(EncGetSequenceParams); ++ SET_FUNCPTR(EncRegisterAsyncEvent); ++ SET_FUNCPTR(EncUnregisterAsyncEvent); ++ SET_FUNCPTR(EncMapInputResource); ++ SET_FUNCPTR(EncUnmapInputResource); ++ SET_FUNCPTR(EncDestroyEncoder); ++ SET_FUNCPTR(EncInvalidateRefFrames); ++ SET_FUNCPTR(EncOpenEncodeSessionEx); ++ SET_FUNCPTR(EncRegisterResource); ++ SET_FUNCPTR(EncUnregisterResource); ++ SET_FUNCPTR(EncReconfigureEncoder); ++ ++ #undef SET_FUNCPTR ++ ++ return NV_ENC_SUCCESS; ++} ++ ++static BOOL load_nvencode(void) ++{ ++ libnvidia_encode_handle = wine_dlopen("libnvidia-encode.so", RTLD_NOW, NULL, 0); ++ if (!libnvidia_encode_handle) ++ { ++ FIXME("Wine cannot find the libnvidia-encode.so library, NVIDIA video encoding support disabled.\n"); ++ return FALSE; ++ } ++ ++ pNvEncodeAPICreateInstance = wine_dlsym(libnvidia_encode_handle, "NvEncodeAPICreateInstance", NULL, 0); ++ if (!pNvEncodeAPICreateInstance) ++ { ++ FIXME("Can't find symbol NvEncodeAPICreateInstance.\n"); ++ return FALSE; ++ } ++ ++ memset(&origFunctions, 0, sizeof(origFunctions)); ++ origFunctions.version = NV_ENCODE_API_FUNCTION_LIST_VER; ++ if (pNvEncodeAPICreateInstance(&origFunctions)) ++ { ++ FIXME("Failed to get function pointers.\n"); ++ return FALSE; ++ } ++ ++ return TRUE; ++} ++ ++BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, LPVOID reserved) ++{ ++ TRACE("(%p, %u, %p)\n", instance, reason, reserved); ++ ++ switch (reason) ++ { ++ case DLL_PROCESS_ATTACH: ++ DisableThreadLibraryCalls(instance); ++ if (!load_nvencode()) return FALSE; ++ break; ++ case DLL_PROCESS_DETACH: ++ if (reserved) break; ++ if (libnvidia_encode_handle) ++ wine_dlclose(libnvidia_encode_handle, NULL, 0); ++ break; ++ } ++ ++ return TRUE; ++} +diff --git a/dlls/nvencodeapi/nvencodeapi.spec b/dlls/nvencodeapi/nvencodeapi.spec +new file mode 100644 +index 0000000..11d74e8 +--- /dev/null ++++ b/dlls/nvencodeapi/nvencodeapi.spec +@@ -0,0 +1 @@ ++@ stdcall NvEncodeAPICreateInstance(ptr) +diff --git a/dlls/nvencodeapi64/Makefile.in b/dlls/nvencodeapi64/Makefile.in +new file mode 100644 +index 0000000..8297ec3 +--- /dev/null ++++ b/dlls/nvencodeapi64/Makefile.in +@@ -0,0 +1,5 @@ ++MODULE = nvencodeapi64.dll ++PARENTSRC = ../nvencodeapi ++ ++C_SRCS = \ ++ nvencodeapi.c +diff --git a/dlls/nvencodeapi64/nvencodeapi64.spec b/dlls/nvencodeapi64/nvencodeapi64.spec +new file mode 100644 +index 0000000..11d74e8 +--- /dev/null ++++ b/dlls/nvencodeapi64/nvencodeapi64.spec +@@ -0,0 +1 @@ ++@ stdcall NvEncodeAPICreateInstance(ptr) +diff --git a/include/Makefile.in b/include/Makefile.in +index 72443e8..bc9148d 100644 +--- a/include/Makefile.in ++++ b/include/Makefile.in +@@ -482,6 +482,7 @@ SRCDIR_INCLUDES = \ + ntstatus.h \ + nvapi.h \ + nvcuvid.h \ ++ nvencodeapi.h \ + objbase.h \ + objsel.h \ + odbcinst.h \ +diff --git a/include/nvencodeapi.h b/include/nvencodeapi.h +new file mode 100644 +index 0000000..45e9fb9 +--- /dev/null ++++ b/include/nvencodeapi.h +@@ -0,0 +1,281 @@ ++/* ++ * Copyright (C) 2015 Michael Müller ++ * ++ * This library is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU Lesser General Public ++ * License as published by the Free Software Foundation; either ++ * version 2.1 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 ++ * Lesser General Public License for more details. ++ * ++ * You should have received a copy of the GNU Lesser 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 ++ */ ++ ++#include ++#include ++ ++#ifndef __WINE_NVENCODEAPI_H ++#define __WINE_NVENCODEAPI_H ++ ++#define NVENCAPI_MAJOR_VERSION 5 ++#define NVENCAPI_MINOR_VERSION 0 ++#define NVENCAPI_VERSION ((NVENCAPI_MAJOR_VERSION << 4) | (NVENCAPI_MINOR_VERSION)) ++#define NVENCAPI_STRUCT_VERSION(type, version) (uint32_t)(sizeof(type) | ((version)<<16) | (NVENCAPI_VERSION << 24)) ++ ++#define NVENCSTATUS int ++#define NV_ENC_SUCCESS 0 ++#define NV_ENC_ERR_INVALID_PTR 6 ++#define NV_ENC_ERR_UNSUPPORTED_PARAM 12 ++#define NV_ENC_ERR_INVALID_VERSION 15 ++ ++typedef void *NV_ENC_INPUT_PTR; ++typedef void *NV_ENC_OUTPUT_PTR; ++typedef void *NV_ENC_REGISTERED_PTR; ++ ++typedef struct _NV_ENC_CAPS_PARAM NV_ENC_CAPS_PARAM; ++typedef struct _NV_ENC_CREATE_INPUT_BUFFER NV_ENC_CREATE_INPUT_BUFFER; ++typedef struct _NV_ENC_CREATE_BITSTREAM_BUFFER NV_ENC_CREATE_BITSTREAM_BUFFER; ++typedef struct _NV_ENC_QP NV_ENC_QP; ++typedef struct _NV_ENC_RC_PARAMS NV_ENC_RC_PARAMS; ++typedef struct _NV_ENC_CONFIG_H264_VUI_PARAMETERS NV_ENC_CONFIG_H264_VUI_PARAMETERS; ++typedef struct _NV_ENC_CONFIG_H264 NV_ENC_CONFIG_H264; ++typedef struct _NV_ENC_CONFIG_HEVC NV_ENC_CONFIG_HEVC; ++typedef struct _NV_ENC_CONFIG NV_ENC_CONFIG; ++typedef struct _NV_ENC_RECONFIGURE_PARAMS NV_ENC_RECONFIGURE_PARAMS; ++typedef struct _NV_ENC_PRESET_CONFIG NV_ENC_PRESET_CONFIG; ++typedef struct _NV_ENC_H264_SEI_PAYLOAD NV_ENC_H264_SEI_PAYLOAD; ++typedef struct _NV_ENC_LOCK_BITSTREAM NV_ENC_LOCK_BITSTREAM; ++typedef struct _NV_ENC_LOCK_INPUT_BUFFER NV_ENC_LOCK_INPUT_BUFFER; ++typedef struct _NV_ENC_MAP_INPUT_RESOURCE NV_ENC_MAP_INPUT_RESOURCE; ++typedef struct _NV_ENC_REGISTER_RESOURCE NV_ENC_REGISTER_RESOURCE; ++typedef struct _NV_ENC_STAT NV_ENC_STAT; ++typedef struct _NV_ENC_SEQUENCE_PARAM_PAYLOAD NV_ENC_SEQUENCE_PARAM_PAYLOAD; ++typedef struct _NV_ENC_EVENT_PARAMS NV_ENC_EVENT_PARAMS; ++typedef struct _NV_ENC_OPEN_ENCODE_SESSIONEX_PARAMS NV_ENC_OPEN_ENCODE_SESSIONEX_PARAMS; ++typedef struct _NV_ENC_BUFFER_FORMAT NV_ENC_BUFFER_FORMAT; ++typedef struct _NV_ENC_OPEN_ENCODE_SESSION_EX_PARAMS NV_ENC_OPEN_ENCODE_SESSION_EX_PARAMS; ++ ++typedef struct _NVENC_EXTERNAL_ME_HINT_COUNTS_PER_BLOCKTYPE ++{ ++ uint32_t numCandsPerBlk16x16 : 4; ++ uint32_t numCandsPerBlk16x8 : 4; ++ uint32_t numCandsPerBlk8x16 : 4; ++ uint32_t numCandsPerBlk8x8 : 4; ++ uint32_t reserved : 16; ++ uint32_t reserved1[3]; ++} NVENC_EXTERNAL_ME_HINT_COUNTS_PER_BLOCKTYPE; ++ ++typedef struct _NV_ENC_INITIALIZE_PARAMS ++{ ++ uint32_t version; ++ GUID encodeGUID; ++ GUID presetGUID; ++ uint32_t encodeWidth; ++ uint32_t encodeHeight; ++ uint32_t darWidth; ++ uint32_t darHeight; ++ uint32_t frameRateNum; ++ uint32_t frameRateDen; ++ uint32_t enableEncodeAsync; ++ uint32_t enablePTD; ++ uint32_t reportSliceOffsets : 1; ++ uint32_t enableSubFrameWrite : 1; ++ uint32_t enableExternalMEHints : 1; ++ uint32_t reservedBitFields : 29; ++ uint32_t privDataSize; ++ void *privData; ++ void *encodeConfig; ++ uint32_t maxEncodeWidth; ++ uint32_t maxEncodeHeight; ++ NVENC_EXTERNAL_ME_HINT_COUNTS_PER_BLOCKTYPE maxMEHintCountsPerBlock[2]; ++ uint32_t reserved[289]; ++ void *reserved2[64]; ++} NV_ENC_INITIALIZE_PARAMS; ++ ++typedef struct _NV_ENC_PIC_PARAMS_H264 ++{ ++ uint32_t displayPOCSyntax; ++ uint32_t reserved3; ++ uint32_t refPicFlag; ++ uint32_t colourPlaneId; ++ uint32_t forceIntraRefreshWithFrameCnt; ++ uint32_t constrainedFrame : 1; ++ uint32_t sliceModeDataUpdate : 1; ++ uint32_t ltrMarkFrame : 1; ++ uint32_t ltrUseFrames : 1; ++ uint32_t reservedBitFields : 28; ++ uint8_t *sliceTypeData; ++ uint32_t sliceTypeArrayCnt; ++ uint32_t seiPayloadArrayCnt; ++ NV_ENC_H264_SEI_PAYLOAD *seiPayloadArray; ++ uint32_t sliceMode; ++ uint32_t sliceModeData; ++ uint32_t ltrMarkFrameIdx; ++ uint32_t ltrUseFrameBitmap; ++ uint32_t ltrUsageMode; ++ uint32_t reserved[243]; ++ void *reserved2[62]; ++} NV_ENC_PIC_PARAMS_H264; ++ ++typedef struct _NV_ENC_PIC_PARAMS_HEVC ++{ ++ uint32_t displayPOCSyntax; ++ uint32_t refPicFlag; ++ uint32_t temporalId; ++ uint32_t forceIntraRefreshWithFrameCnt; ++ uint32_t constrainedFrame : 1; ++ uint32_t sliceModeDataUpdate : 1; ++ uint32_t ltrMarkFrame : 1; ++ uint32_t ltrUseFrames : 1; ++ uint32_t reservedBitFields : 28; ++ uint8_t *sliceTypeData; ++ uint32_t sliceTypeArrayCnt; ++ uint32_t sliceMode; ++ uint32_t sliceModeData; ++ uint32_t ltrMarkFrameIdx; ++ uint32_t ltrUseFrameBitmap; ++ uint32_t ltrUsageMode; ++ uint32_t reserved[246]; ++ void *reserved2[62]; ++} NV_ENC_PIC_PARAMS_HEVC; ++ ++typedef union _NV_ENC_CODEC_PIC_PARAMS ++{ ++ NV_ENC_PIC_PARAMS_H264 h264PicParams; ++ NV_ENC_PIC_PARAMS_HEVC hevcPicParams; ++ uint32_t reserved[256]; ++} NV_ENC_CODEC_PIC_PARAMS; ++ ++struct _NVENC_EXTERNAL_ME_HINT ++{ ++ int32_t mvx : 12; ++ int32_t mvy : 10; ++ int32_t refidx : 5; ++ int32_t dir : 1; ++ int32_t partType : 2; ++ int32_t lastofPart : 1; ++ int32_t lastOfMB : 1; ++}; ++ ++typedef struct _NV_ENC_PIC_PARAMS ++{ ++ uint32_t version; ++ uint32_t inputWidth; ++ uint32_t inputHeight; ++ uint32_t inputPitch; ++ uint32_t encodePicFlags; ++ uint32_t frameIdx; ++ uint64_t inputTimeStamp; ++ uint64_t inputDuration; ++ void *inputBuffer; ++ void *outputBitstream; ++ void *completionEvent; ++ int bufferFmt; ++ int pictureStruct; ++ int pictureType; ++ NV_ENC_CODEC_PIC_PARAMS codecPicParams; ++ struct _NVENC_EXTERNAL_ME_HINT_COUNTS_PER_BLOCKTYPE meHintCountsPerBlock[2]; ++ struct _NVENC_EXTERNAL_ME_HINT *meExternalHints; ++ uint32_t reserved1[6]; ++ void *reserved2[2]; ++ int8_t *qpDeltaMap; ++ uint32_t qpDeltaMapSize; ++ uint32_t reservedBitFields; ++ uint32_t reserved3[287]; ++ void *reserved4[60]; ++} NV_ENC_PIC_PARAMS; ++ ++typedef struct __NV_ENCODE_API_FUNCTION_LIST ++{ ++ uint32_t version; ++ uint32_t reserved; ++ NVENCSTATUS (WINAPI *nvEncOpenEncodeSession)(void *device, uint32_t deviceType, void **encoder); ++ NVENCSTATUS (WINAPI *nvEncGetEncodeGUIDCount)(void *encoder, uint32_t *encodeGUIDCount); ++ NVENCSTATUS (WINAPI *nvEncGetEncodeProfileGUIDCount)(void *encoder, GUID encodeGUID, uint32_t *encodePresetGUIDCount); ++ NVENCSTATUS (WINAPI *nvEncGetEncodeProfileGUIDs)(void *encoder, GUID encodeGUID, GUID *presetGUIDs, uint32_t guidArraySize, ++ uint32_t *encodePresetGUIDCount); ++ NVENCSTATUS (WINAPI *nvEncGetEncodeGUIDs)(void *encoder, GUID *GUIDs, uint32_t guidArraySize, uint32_t *GUIDCount); ++ NVENCSTATUS (WINAPI *nvEncGetInputFormatCount)(void *encoder, GUID encodeGUID, uint32_t *inputFmtCount); ++ NVENCSTATUS (WINAPI *nvEncGetInputFormats)(void *encoder, GUID encodeGUID, NV_ENC_BUFFER_FORMAT *inputFmts, ++ uint32_t inputFmtArraySize, uint32_t *inputFmtCount); ++ NVENCSTATUS (WINAPI *nvEncGetEncodeCaps)(void *encoder, GUID encodeGUID, NV_ENC_CAPS_PARAM *capsParam, int *capsVal); ++ NVENCSTATUS (WINAPI *nvEncGetEncodePresetCount)(void *encoder, GUID encodeGUID, uint32_t *encodePresetGUIDCount); ++ NVENCSTATUS (WINAPI *nvEncGetEncodePresetGUIDs)(void *encoder, GUID encodeGUID, GUID *presetGUIDs, uint32_t guidArraySize, ++ uint32_t *encodePresetGUIDCount); ++ NVENCSTATUS (WINAPI *nvEncGetEncodePresetConfig)(void *encoder, GUID encodeGUID, GUID presetGUID, NV_ENC_PRESET_CONFIG *presetConfig); ++ NVENCSTATUS (WINAPI *nvEncInitializeEncoder)(void *encoder, NV_ENC_INITIALIZE_PARAMS *createEncodeParams); ++ NVENCSTATUS (WINAPI *nvEncCreateInputBuffer)(void *encoder, NV_ENC_CREATE_INPUT_BUFFER *createInputBufferParams); ++ NVENCSTATUS (WINAPI *nvEncDestroyInputBuffer)(void *encoder, NV_ENC_INPUT_PTR inputBuffer); ++ NVENCSTATUS (WINAPI *nvEncCreateBitstreamBuffer)(void *encoder, NV_ENC_CREATE_BITSTREAM_BUFFER *createBitstreamBufferParams); ++ NVENCSTATUS (WINAPI *nvEncDestroyBitstreamBuffer)(void *encoder, NV_ENC_OUTPUT_PTR bitstreamBuffer); ++ NVENCSTATUS (WINAPI *nvEncEncodePicture)(void *encoder, NV_ENC_PIC_PARAMS *encodePicParams); ++ NVENCSTATUS (WINAPI *nvEncLockBitstream)(void *encoder, NV_ENC_LOCK_BITSTREAM *lockBitstreamBufferParams); ++ NVENCSTATUS (WINAPI *nvEncUnlockBitstream)(void *encoder, NV_ENC_OUTPUT_PTR bitstreamBuffer); ++ NVENCSTATUS (WINAPI *nvEncLockInputBuffer)(void *encoder, NV_ENC_LOCK_INPUT_BUFFER *lockInputBufferParams); ++ NVENCSTATUS (WINAPI *nvEncUnlockInputBuffer)(void *encoder, NV_ENC_INPUT_PTR inputBuffer); ++ NVENCSTATUS (WINAPI *nvEncGetEncodeStats)(void *encoder, NV_ENC_STAT *encodeStats); ++ NVENCSTATUS (WINAPI *nvEncGetSequenceParams)(void *encoder, NV_ENC_SEQUENCE_PARAM_PAYLOAD *hsequenceParamPayload); ++ NVENCSTATUS (WINAPI *nvEncRegisterAsyncEvent)(void *encoder, NV_ENC_EVENT_PARAMS *eventParams); ++ NVENCSTATUS (WINAPI *nvEncUnregisterAsyncEvent)(void *encoder, NV_ENC_EVENT_PARAMS *eventParams); ++ NVENCSTATUS (WINAPI *nvEncMapInputResource)(void *encoder, NV_ENC_MAP_INPUT_RESOURCE *mapInputResParams); ++ NVENCSTATUS (WINAPI *nvEncUnmapInputResource)(void *encoder, NV_ENC_INPUT_PTR mappedInputBuffer); ++ NVENCSTATUS (WINAPI *nvEncDestroyEncoder)(void *encoder); ++ NVENCSTATUS (WINAPI *nvEncInvalidateRefFrames)(void *encoder, uint64_t invalidRefFrameTimeStamp); ++ NVENCSTATUS (WINAPI *nvEncOpenEncodeSessionEx)(NV_ENC_OPEN_ENCODE_SESSION_EX_PARAMS *openSessionExParams, void **encoder); ++ NVENCSTATUS (WINAPI *nvEncRegisterResource)(void *encoder, NV_ENC_REGISTER_RESOURCE *registerResParams); ++ NVENCSTATUS (WINAPI *nvEncUnregisterResource)(void *encoder, NV_ENC_REGISTERED_PTR registeredRes); ++ NVENCSTATUS (WINAPI *nvEncReconfigureEncoder)(void *encoder, NV_ENC_RECONFIGURE_PARAMS *reInitEncodeParams); ++ void *reserved2[285]; ++} NV_ENCODE_API_FUNCTION_LIST; ++ ++#define NV_ENCODE_API_FUNCTION_LIST_VER NVENCAPI_STRUCT_VERSION(NV_ENCODE_API_FUNCTION_LIST, 2) ++ ++typedef struct __LINUX_NV_ENCODE_API_FUNCTION_LIST ++{ ++ uint32_t version; ++ uint32_t reserved; ++ NVENCSTATUS (*nvEncOpenEncodeSession)(void *device, uint32_t deviceType, void **encoder); ++ NVENCSTATUS (*nvEncGetEncodeGUIDCount)(void *encoder, uint32_t *encodeGUIDCount); ++ NVENCSTATUS (*nvEncGetEncodeProfileGUIDCount)(void *encoder, GUID encodeGUID, uint32_t *encodePresetGUIDCount); ++ NVENCSTATUS (*nvEncGetEncodeProfileGUIDs)(void *encoder, GUID encodeGUID, GUID *presetGUIDs, uint32_t guidArraySize, ++ uint32_t *encodePresetGUIDCount); ++ NVENCSTATUS (*nvEncGetEncodeGUIDs)(void *encoder, GUID *GUIDs, uint32_t guidArraySize, uint32_t *GUIDCount); ++ NVENCSTATUS (*nvEncGetInputFormatCount)(void *encoder, GUID encodeGUID, uint32_t *inputFmtCount); ++ NVENCSTATUS (*nvEncGetInputFormats)(void *encoder, GUID encodeGUID, NV_ENC_BUFFER_FORMAT *inputFmts, ++ uint32_t inputFmtArraySize, uint32_t *inputFmtCount); ++ NVENCSTATUS (*nvEncGetEncodeCaps)(void *encoder, GUID encodeGUID, NV_ENC_CAPS_PARAM *capsParam, int *capsVal); ++ NVENCSTATUS (*nvEncGetEncodePresetCount)(void *encoder, GUID encodeGUID, uint32_t *encodePresetGUIDCount); ++ NVENCSTATUS (*nvEncGetEncodePresetGUIDs)(void *encoder, GUID encodeGUID, GUID *presetGUIDs, uint32_t guidArraySize, ++ uint32_t *encodePresetGUIDCount); ++ NVENCSTATUS (*nvEncGetEncodePresetConfig)(void *encoder, GUID encodeGUID, GUID presetGUID, NV_ENC_PRESET_CONFIG *presetConfig); ++ NVENCSTATUS (*nvEncInitializeEncoder)(void *encoder, NV_ENC_INITIALIZE_PARAMS *createEncodeParams); ++ NVENCSTATUS (*nvEncCreateInputBuffer)(void *encoder, NV_ENC_CREATE_INPUT_BUFFER *createInputBufferParams); ++ NVENCSTATUS (*nvEncDestroyInputBuffer)(void *encoder, NV_ENC_INPUT_PTR inputBuffer); ++ NVENCSTATUS (*nvEncCreateBitstreamBuffer)(void *encoder, NV_ENC_CREATE_BITSTREAM_BUFFER *createBitstreamBufferParams); ++ NVENCSTATUS (*nvEncDestroyBitstreamBuffer)(void *encoder, NV_ENC_OUTPUT_PTR bitstreamBuffer); ++ NVENCSTATUS (*nvEncEncodePicture)(void *encoder, NV_ENC_PIC_PARAMS *encodePicParams); ++ NVENCSTATUS (*nvEncLockBitstream)(void *encoder, NV_ENC_LOCK_BITSTREAM *lockBitstreamBufferParams); ++ NVENCSTATUS (*nvEncUnlockBitstream)(void *encoder, NV_ENC_OUTPUT_PTR bitstreamBuffer); ++ NVENCSTATUS (*nvEncLockInputBuffer)(void *encoder, NV_ENC_LOCK_INPUT_BUFFER *lockInputBufferParams); ++ NVENCSTATUS (*nvEncUnlockInputBuffer)(void *encoder, NV_ENC_INPUT_PTR inputBuffer); ++ NVENCSTATUS (*nvEncGetEncodeStats)(void *encoder, NV_ENC_STAT *encodeStats); ++ NVENCSTATUS (*nvEncGetSequenceParams)(void *encoder, NV_ENC_SEQUENCE_PARAM_PAYLOAD *hsequenceParamPayload); ++ NVENCSTATUS (*nvEncRegisterAsyncEvent)(void *encoder, NV_ENC_EVENT_PARAMS *eventParams); ++ NVENCSTATUS (*nvEncUnregisterAsyncEvent)(void *encoder, NV_ENC_EVENT_PARAMS *eventParams); ++ NVENCSTATUS (*nvEncMapInputResource)(void *encoder, NV_ENC_MAP_INPUT_RESOURCE *mapInputResParams); ++ NVENCSTATUS (*nvEncUnmapInputResource)(void *encoder, NV_ENC_INPUT_PTR mappedInputBuffer); ++ NVENCSTATUS (*nvEncDestroyEncoder)(void *encoder); ++ NVENCSTATUS (*nvEncInvalidateRefFrames)(void *encoder, uint64_t invalidRefFrameTimeStamp); ++ NVENCSTATUS (*nvEncOpenEncodeSessionEx)(NV_ENC_OPEN_ENCODE_SESSION_EX_PARAMS *openSessionExParams, void **encoder); ++ NVENCSTATUS (*nvEncRegisterResource)(void *encoder, NV_ENC_REGISTER_RESOURCE *registerResParams); ++ NVENCSTATUS (*nvEncUnregisterResource)(void *encoder, NV_ENC_REGISTERED_PTR registeredRes); ++ NVENCSTATUS (*nvEncReconfigureEncoder)(void *encoder, NV_ENC_RECONFIGURE_PARAMS *reInitEncodeParams); ++ void *reserved2[285]; ++} LINUX_NV_ENCODE_API_FUNCTION_LIST; ++ ++#endif /* __WINE_NVENCODEAPI_H */ +-- +2.2.2 + diff --git a/patches/nvencodeapi-Video_Encoder/definition b/patches/nvencodeapi-Video_Encoder/definition new file mode 100644 index 00000000..691d0268 --- /dev/null +++ b/patches/nvencodeapi-Video_Encoder/definition @@ -0,0 +1,2 @@ +Fixes: Support for NVIDIA video encoder library (nvencodeapi) +Depends: nvcuvid-CUDA_Video_Support diff --git a/patches/patchinstall.sh b/patches/patchinstall.sh index 33a0bc40..7fb1f7e7 100755 --- a/patches/patchinstall.sh +++ b/patches/patchinstall.sh @@ -141,6 +141,7 @@ patch_enable_all () enable_nvapi_Stub_DLL="$1" enable_nvcuda_CUDA_Support="$1" enable_nvcuvid_CUDA_Video_Support="$1" + enable_nvencodeapi_Video_Encoder="$1" enable_ole32_CoWaitForMultipleHandles="$1" enable_quartz_MediaSeeking_Positions="$1" enable_reg_Cleanup="$1" @@ -449,6 +450,9 @@ patch_enable () nvcuvid-CUDA_Video_Support) enable_nvcuvid_CUDA_Video_Support="$2" ;; + nvencodeapi-Video_Encoder) + enable_nvencodeapi_Video_Encoder="$2" + ;; ole32-CoWaitForMultipleHandles) enable_ole32_CoWaitForMultipleHandles="$2" ;; @@ -910,6 +914,13 @@ if test "$enable_server_Stored_ACLs" -eq 1; then enable_ntdll_DOS_Attributes=1 fi +if test "$enable_nvencodeapi_Video_Encoder" -eq 1; then + if test "$enable_nvcuvid_CUDA_Video_Support" -gt 1; then + abort "Patchset nvcuvid-CUDA_Video_Support disabled, but nvencodeapi-Video_Encoder depends on that." + fi + enable_nvcuvid_CUDA_Video_Support=1 +fi + if test "$enable_nvcuvid_CUDA_Video_Support" -eq 1; then if test "$enable_nvapi_Stub_DLL" -gt 1; then abort "Patchset nvapi-Stub_DLL disabled, but nvcuvid-CUDA_Video_Support depends on that." @@ -2413,6 +2424,19 @@ if test "$enable_nvcuvid_CUDA_Video_Support" -eq 1; then ) >> "$patchlist" fi +# Patchset nvencodeapi-Video_Encoder +# | +# | Modified files: +# | * configure.ac, dlls/nvencodeapi/Makefile.in, dlls/nvencodeapi/nvencodeapi.c, dlls/nvencodeapi/nvencodeapi.spec, +# | dlls/nvencodeapi64/Makefile.in, dlls/nvencodeapi64/nvencodeapi64.spec, include/Makefile.in, include/nvencodeapi.h +# | +if test "$enable_nvencodeapi_Video_Encoder" -eq 1; then + patch_apply nvencodeapi-Video_Encoder/0001-nvencodeapi-First-implementation.patch + ( + echo '+ { "Michael Müller", "nvencodeapi: First implementation.", 1 },'; + ) >> "$patchlist" +fi + # Patchset ole32-CoWaitForMultipleHandles # | # | Modified files: