Refactor

apps/LoopThroughWithOpenGLCompositing/gl/GLExtensions.cpp

@@ -0,0 +1,206 @@
+/* -LICENSE-START-
+ ** Copyright (c) 2012 Blackmagic Design
+ **  
+ ** Permission is hereby granted, free of charge, to any person or organization 
+ ** obtaining a copy of the software and accompanying documentation (the 
+ ** "Software") to use, reproduce, display, distribute, sub-license, execute, 
+ ** and transmit the Software, and to prepare derivative works of the Software, 
+ ** and to permit third-parties to whom the Software is furnished to do so, in 
+ ** accordance with:
+ ** 
+ ** (1) if the Software is obtained from Blackmagic Design, the End User License 
+ ** Agreement for the Software Development Kit ("EULA") available at 
+ ** https://www.blackmagicdesign.com/EULA/DeckLinkSDK; or
+ ** 
+ ** (2) if the Software is obtained from any third party, such licensing terms 
+ ** as notified by that third party,
+ ** 
+ ** and all subject to the following:
+ ** 
+ ** (3) the copyright notices in the Software and this entire statement, 
+ ** including the above license grant, this restriction and the following 
+ ** disclaimer, must be included in all copies of the Software, in whole or in 
+ ** part, and all derivative works of the Software, unless such copies or 
+ ** derivative works are solely in the form of machine-executable object code 
+ ** generated by a source language processor.
+ ** 
+ ** (4) THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 
+ ** OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ ** FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT 
+ ** SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE 
+ ** FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, 
+ ** ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 
+ ** DEALINGS IN THE SOFTWARE.
+ ** 
+ ** A copy of the Software is available free of charge at 
+ ** https://www.blackmagicdesign.com/desktopvideo_sdk under the EULA.
+ ** 
+ ** -LICENSE-END-
+ */
+//
+//  GLExtensions.cpp
+//  LoopThroughWithOpenGLCompositing
+//
+
+#include "GLExtensions.h"
+
+PFNGLGENFRAMEBUFFERSPROC glGenFramebuffers;
+PFNGLGENRENDERBUFFERSPROC glGenRenderbuffers;
+PFNGLBINDRENDERBUFFERPROC glBindRenderbuffer;
+PFNGLRENDERBUFFERSTORAGEPROC glRenderbufferStorage;
+PFNGLDELETEFRAMEBUFFERSPROC glDeleteFramebuffers;
+PFNGLDELETERENDERBUFFERSPROC glDeleteRenderbuffers;
+PFNGLBINDFRAMEBUFFERPROC glBindFramebuffer;
+PFNGLFRAMEBUFFERTEXTURE2DPROC glFramebufferTexture2D;
+PFNGLFRAMEBUFFERRENDERBUFFERPROC glFramebufferRenderbuffer;
+PFNGLCHECKFRAMEBUFFERSTATUSPROC glCheckFramebufferStatus;
+PFNGLBLITFRAMEBUFFERPROC glBlitFramebuffer;
+PFNGLFENCESYNCPROC glFenceSync;
+PFNGLCLIENTWAITSYNCPROC glClientWaitSync;
+PFNGLDELETESYNCPROC glDeleteSync;
+PFNGLGENBUFFERSPROC glGenBuffers;
+PFNGLDELETEBUFFERSPROC glDeleteBuffers;
+PFNGLBINDBUFFERPROC glBindBuffer;
+PFNGLBUFFERDATAPROC glBufferData;
+PFNGLBUFFERSUBDATAPROC glBufferSubData;
+PFNGLBINDBUFFERBASEPROC glBindBufferBase;
+PFNGLACTIVETEXTUREPROC glActiveTexture;
+PFNGLGENVERTEXARRAYSPROC glGenVertexArrays;
+PFNGLDELETEVERTEXARRAYSPROC glDeleteVertexArrays;
+PFNGLBINDVERTEXARRAYPROC glBindVertexArray;
+PFNGLCREATESHADERPROC glCreateShader;
+PFNGLDELETESHADERPROC glDeleteShader;
+PFNGLDELETEPROGRAMPROC glDeleteProgram;
+PFNGLSHADERSOURCEPROC glShaderSource;
+PFNGLCOMPILESHADERPROC glCompileShader;
+PFNGLGETSHADERIVPROC glGetShaderiv;
+PFNGLGETSHADERINFOLOGPROC glGetShaderInfoLog;
+PFNGLCREATEPROGRAMPROC glCreateProgram;
+PFNGLATTACHSHADERPROC glAttachShader;
+PFNGLLINKPROGRAMPROC glLinkProgram;
+PFNGLGETPROGRAMIVPROC glGetProgramiv;
+PFNGLGETPROGRAMINFOLOGPROC glGetProgramInfoLog;
+PFNGLUSEPROGRAMPROC glUseProgram;
+PFNGLGETUNIFORMLOCATIONPROC glGetUniformLocation;
+PFNGLGETUNIFORMBLOCKINDEXPROC glGetUniformBlockIndex;
+PFNGLUNIFORMBLOCKBINDINGPROC glUniformBlockBinding;
+PFNGLUNIFORM1IPROC glUniform1i;
+PFNGLUNIFORM1FPROC glUniform1f;
+PFNGLUNIFORM2FPROC glUniform2f;
+PFNGLUNIFORM4FPROC glUniform4f;
+
+bool ResolveGLExtensions()
+{
+	glGenFramebuffers = (PFNGLGENFRAMEBUFFERSPROC) wglGetProcAddress("glGenFramebuffers");
+	if (!glGenFramebuffers)
+		glGenFramebuffers = (PFNGLGENFRAMEBUFFERSPROC) wglGetProcAddress("glGenFramebuffersEXT");
+	glGenRenderbuffers = (PFNGLGENRENDERBUFFERSPROC) wglGetProcAddress("glGenRenderbuffers");
+	if (!glGenRenderbuffers)
+		glGenRenderbuffers = (PFNGLGENRENDERBUFFERSPROC) wglGetProcAddress("glGenRenderbuffersEXT");
+	glBindRenderbuffer = (PFNGLBINDRENDERBUFFERPROC) wglGetProcAddress("glBindRenderbuffer");
+	if (!glBindRenderbuffer)
+		glBindRenderbuffer = (PFNGLBINDRENDERBUFFERPROC) wglGetProcAddress("glBindRenderbufferEXT");
+	glRenderbufferStorage = (PFNGLRENDERBUFFERSTORAGEPROC) wglGetProcAddress("glRenderbufferStorage");
+	if (!glRenderbufferStorage)
+		glRenderbufferStorage = (PFNGLRENDERBUFFERSTORAGEPROC) wglGetProcAddress("glRenderbufferStorageEXT");
+	glDeleteFramebuffers = (PFNGLDELETEFRAMEBUFFERSPROC) wglGetProcAddress("glDeleteFramebuffers");
+	if (!glDeleteFramebuffers)
+		glDeleteFramebuffers = (PFNGLDELETEFRAMEBUFFERSPROC) wglGetProcAddress("glDeleteFramebuffersEXT");
+	glDeleteRenderbuffers = (PFNGLDELETERENDERBUFFERSPROC) wglGetProcAddress("glDeleteRenderbuffers");
+	if (!glDeleteRenderbuffers)
+		glDeleteRenderbuffers = (PFNGLDELETERENDERBUFFERSPROC) wglGetProcAddress("glDeleteRenderbuffersEXT");
+	glBindFramebuffer = (PFNGLBINDFRAMEBUFFERPROC) wglGetProcAddress("glBindFramebuffer");
+	if (!glBindFramebuffer)
+		glBindFramebuffer = (PFNGLBINDFRAMEBUFFERPROC) wglGetProcAddress("glBindFramebufferEXT");
+	glFramebufferTexture2D = (PFNGLFRAMEBUFFERTEXTURE2DPROC) wglGetProcAddress("glFramebufferTexture2D");
+	if (!glFramebufferTexture2D)
+		glFramebufferTexture2D = (PFNGLFRAMEBUFFERTEXTURE2DPROC) wglGetProcAddress("glFramebufferTexture2DEXT");
+	glFramebufferRenderbuffer = (PFNGLFRAMEBUFFERRENDERBUFFERPROC) wglGetProcAddress("glFramebufferRenderbuffer");
+	if (!glFramebufferRenderbuffer)
+		glFramebufferRenderbuffer = (PFNGLFRAMEBUFFERRENDERBUFFERPROC) wglGetProcAddress("glFramebufferRenderbufferEXT");
+	glCheckFramebufferStatus = (PFNGLCHECKFRAMEBUFFERSTATUSPROC) wglGetProcAddress("glCheckFramebufferStatus");
+	if (!glCheckFramebufferStatus)
+		glCheckFramebufferStatus = (PFNGLCHECKFRAMEBUFFERSTATUSPROC) wglGetProcAddress("glCheckFramebufferStatusEXT");
+	glBlitFramebuffer = (PFNGLBLITFRAMEBUFFERPROC) wglGetProcAddress("glBlitFramebuffer");
+	if (!glBlitFramebuffer)
+		glBlitFramebuffer = (PFNGLBLITFRAMEBUFFERPROC) wglGetProcAddress("glBlitFramebufferEXT");
+	glFenceSync = (PFNGLFENCESYNCPROC) wglGetProcAddress("glFenceSync");
+	glClientWaitSync = (PFNGLCLIENTWAITSYNCPROC) wglGetProcAddress("glClientWaitSync");
+	glDeleteSync = (PFNGLDELETESYNCPROC) wglGetProcAddress("glDeleteSync");
+	glGenBuffers = (PFNGLGENBUFFERSPROC) wglGetProcAddress("glGenBuffers");
+	glDeleteBuffers = (PFNGLDELETEBUFFERSPROC) wglGetProcAddress("glDeleteBuffers");
+	glBindBuffer = (PFNGLBINDBUFFERPROC) wglGetProcAddress("glBindBuffer");
+	glBufferData = (PFNGLBUFFERDATAPROC) wglGetProcAddress("glBufferData");
+	glBufferSubData = (PFNGLBUFFERSUBDATAPROC) wglGetProcAddress("glBufferSubData");
+	glBindBufferBase = (PFNGLBINDBUFFERBASEPROC) wglGetProcAddress("glBindBufferBase");
+	glActiveTexture = (PFNGLACTIVETEXTUREPROC) wglGetProcAddress("glActiveTexture");
+	glGenVertexArrays = (PFNGLGENVERTEXARRAYSPROC) wglGetProcAddress("glGenVertexArrays");
+	glDeleteVertexArrays = (PFNGLDELETEVERTEXARRAYSPROC) wglGetProcAddress("glDeleteVertexArrays");
+	glBindVertexArray = (PFNGLBINDVERTEXARRAYPROC) wglGetProcAddress("glBindVertexArray");
+	glCreateShader = (PFNGLCREATESHADERPROC) wglGetProcAddress("glCreateShader");
+	glDeleteShader = (PFNGLDELETESHADERPROC) wglGetProcAddress("glDeleteShader");
+	glDeleteProgram = (PFNGLDELETEPROGRAMPROC) wglGetProcAddress("glDeleteProgram");
+	glShaderSource = (PFNGLSHADERSOURCEPROC) wglGetProcAddress("glShaderSource");
+	glCompileShader = (PFNGLCOMPILESHADERPROC) wglGetProcAddress("glCompileShader");
+	glGetShaderiv = (PFNGLGETSHADERIVPROC) wglGetProcAddress("glGetShaderiv");
+	glGetShaderInfoLog = (PFNGLGETSHADERINFOLOGPROC) wglGetProcAddress("glGetShaderInfoLog");
+	glCreateProgram = (PFNGLCREATEPROGRAMPROC) wglGetProcAddress("glCreateProgram");
+	glAttachShader = (PFNGLATTACHSHADERPROC) wglGetProcAddress("glAttachShader");
+	glLinkProgram = (PFNGLLINKPROGRAMPROC) wglGetProcAddress("glLinkProgram");
+	glGetProgramiv = (PFNGLGETPROGRAMIVPROC) wglGetProcAddress("glGetProgramiv");
+	glGetProgramInfoLog = (PFNGLGETPROGRAMINFOLOGPROC) wglGetProcAddress("glGetProgramInfoLog");
+	glUseProgram = (PFNGLUSEPROGRAMPROC) wglGetProcAddress("glUseProgram");
+	glGetUniformLocation = (PFNGLGETUNIFORMLOCATIONPROC) wglGetProcAddress("glGetUniformLocation");
+	glGetUniformBlockIndex = (PFNGLGETUNIFORMBLOCKINDEXPROC) wglGetProcAddress("glGetUniformBlockIndex");
+	glUniformBlockBinding = (PFNGLUNIFORMBLOCKBINDINGPROC) wglGetProcAddress("glUniformBlockBinding");
+	glUniform1i = (PFNGLUNIFORM1IPROC) wglGetProcAddress("glUniform1i");
+	glUniform1f = (PFNGLUNIFORM1FPROC) wglGetProcAddress("glUniform1f");
+	glUniform2f = (PFNGLUNIFORM2FPROC) wglGetProcAddress("glUniform2f");
+	glUniform4f = (PFNGLUNIFORM4FPROC) wglGetProcAddress("glUniform4f");
+
+	return	glGenFramebuffers
+			&& glGenRenderbuffers
+			&& glBindRenderbuffer
+			&& glRenderbufferStorage
+			&& glDeleteFramebuffers
+			&& glDeleteRenderbuffers
+			&& glBindFramebuffer
+			&& glFramebufferTexture2D
+			&& glFramebufferRenderbuffer
+			&& glCheckFramebufferStatus
+			&& glBlitFramebuffer
+			&& glFenceSync
+			&& glClientWaitSync
+			&& glDeleteSync
+			&& glGenBuffers
+			&& glDeleteBuffers
+			&& glBindBuffer
+			&& glBufferData
+			&& glBufferSubData
+			&& glBindBufferBase
+			&& glActiveTexture
+			&& glGenVertexArrays
+			&& glDeleteVertexArrays
+			&& glBindVertexArray
+			&& glCreateShader
+			&& glDeleteShader
+			&& glDeleteProgram
+			&& glShaderSource
+			&& glCompileShader
+			&& glGetShaderiv
+			&& glGetShaderInfoLog
+			&& glCreateProgram
+			&& glAttachShader
+			&& glLinkProgram
+			&& glGetProgramiv
+			&& glGetProgramInfoLog
+			&& glUseProgram
+			&& glGetUniformLocation
+			&& glGetUniformBlockIndex
+			&& glUniformBlockBinding
+			&& glUniform1i
+			&& glUniform1f
+			&& glUniform2f
+			&& glUniform4f
+			;
+}

apps/LoopThroughWithOpenGLCompositing/gl/GLExtensions.h

@@ -0,0 +1,186 @@
+/* -LICENSE-START-
+ ** Copyright (c) 2012 Blackmagic Design
+ **  
+ ** Permission is hereby granted, free of charge, to any person or organization 
+ ** obtaining a copy of the software and accompanying documentation (the 
+ ** "Software") to use, reproduce, display, distribute, sub-license, execute, 
+ ** and transmit the Software, and to prepare derivative works of the Software, 
+ ** and to permit third-parties to whom the Software is furnished to do so, in 
+ ** accordance with:
+ ** 
+ ** (1) if the Software is obtained from Blackmagic Design, the End User License 
+ ** Agreement for the Software Development Kit ("EULA") available at 
+ ** https://www.blackmagicdesign.com/EULA/DeckLinkSDK; or
+ ** 
+ ** (2) if the Software is obtained from any third party, such licensing terms 
+ ** as notified by that third party,
+ ** 
+ ** and all subject to the following:
+ ** 
+ ** (3) the copyright notices in the Software and this entire statement, 
+ ** including the above license grant, this restriction and the following 
+ ** disclaimer, must be included in all copies of the Software, in whole or in 
+ ** part, and all derivative works of the Software, unless such copies or 
+ ** derivative works are solely in the form of machine-executable object code 
+ ** generated by a source language processor.
+ ** 
+ ** (4) THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 
+ ** OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ ** FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT 
+ ** SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE 
+ ** FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, 
+ ** ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 
+ ** DEALINGS IN THE SOFTWARE.
+ ** 
+ ** A copy of the Software is available free of charge at 
+ ** https://www.blackmagicdesign.com/desktopvideo_sdk under the EULA.
+ ** 
+ ** -LICENSE-END-
+ */
+//
+//  GLExtensions.h
+//  LoopThroughWithOpenGLCompositing
+//
+
+#ifndef __GLEXTENSIONS_H__
+#define __GLEXTENSIONS_H__
+
+#include <windows.h>
+#include <gl/gl.h>
+
+#ifndef APIENTRYP
+#define APIENTRYP APIENTRY *
+#endif
+
+#define GL_BGRA									0x80E1
+#define GL_UNSIGNED_INT_8_8_8_8_REV				0x8367
+#define GL_STREAM_DRAW							0x88E0
+#define GL_STREAM_READ							0x88E1
+#define GL_STREAM_COPY							0x88E2
+#define GL_DYNAMIC_DRAW							0x88E8
+#define GL_UNIFORM_BUFFER						0x8A11
+#define GL_RGBA8								0x8058
+#define GL_ARRAY_BUFFER							0x8892
+#define GL_PIXEL_PACK_BUFFER					0x88EB
+#define GL_PIXEL_UNPACK_BUFFER					0x88EC
+#define GL_FRAGMENT_SHADER						0x8B30
+#define GL_VERTEX_SHADER						0x8B31
+#define GL_COMPILE_STATUS						0x8B81
+#define GL_LINK_STATUS							0x8B82
+#define GL_RENDERBUFFER_EXT						0x8D41
+#define GL_FRAMEBUFFER_EXT						0x8D40
+#define GL_FRAMEBUFFER_COMPLETE_EXT				0x8CD5
+#define GL_COLOR_ATTACHMENT0_EXT				0x8CE0
+#define GL_READ_FRAMEBUFFER						0x8CA8
+#define GL_DRAW_FRAMEBUFFER						0x8CA9
+#define GL_RENDERBUFFER							0x8D41
+#define GL_FRAMEBUFFER							0x8D40
+#define GL_FRAMEBUFFER_COMPLETE					0x8CD5
+#define GL_COLOR_ATTACHMENT0					0x8CE0
+#define GL_DEPTH_COMPONENT24					0x81A6
+#define GL_CLAMP_TO_EDGE						0x812F
+#define GL_DEPTH_ATTACHMENT_EXT					0x8D00
+#define GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD	0x9160
+#define GL_SYNC_GPU_COMMANDS_COMPLETE			0x9117
+#define GL_SYNC_FLUSH_COMMANDS_BIT				0x00000001
+
+typedef struct __GLsync *GLsync;
+typedef unsigned __int64 GLuint64;
+typedef ptrdiff_t GLintptr;
+typedef ptrdiff_t GLsizeiptr;
+typedef char GLchar;
+
+typedef void (APIENTRYP PFNGLBINDBUFFERPROC) (GLenum target, GLuint buffer);
+typedef void (APIENTRYP PFNGLDELETEBUFFERSPROC) (GLsizei n, const GLuint *buffers);
+typedef void (APIENTRYP PFNGLGENBUFFERSPROC) (GLsizei n, GLuint *buffers);
+typedef void (APIENTRYP PFNGLBUFFERDATAPROC) (GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage);
+typedef void (APIENTRYP PFNGLATTACHSHADERPROC) (GLuint program, GLuint shader);
+typedef void (APIENTRYP PFNGLCOMPILESHADERPROC) (GLuint shader);
+typedef GLuint (APIENTRYP PFNGLCREATEPROGRAMPROC) (void);
+typedef GLuint (APIENTRYP PFNGLCREATESHADERPROC) (GLenum type);
+typedef void (APIENTRYP PFNGLDELETESHADERPROC) (GLuint shader);
+typedef void (APIENTRYP PFNGLDELETEPROGRAMPROC) (GLuint program);
+typedef void (APIENTRYP PFNGLGETPROGRAMIVPROC) (GLuint program, GLenum pname, GLint *params);
+typedef void (APIENTRYP PFNGLGETPROGRAMINFOLOGPROC) (GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
+typedef void (APIENTRYP PFNGLGETSHADERIVPROC) (GLuint shader, GLenum pname, GLint *params);
+typedef void (APIENTRYP PFNGLGETSHADERINFOLOGPROC) (GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
+typedef GLint (APIENTRYP PFNGLGETUNIFORMLOCATIONPROC) (GLuint program, const GLchar *name);
+typedef void (APIENTRYP PFNGLLINKPROGRAMPROC) (GLuint program);
+typedef void (APIENTRYP PFNGLSHADERSOURCEPROC) (GLuint shader, GLsizei count, const GLchar* *string, const GLint *length);
+typedef void (APIENTRYP PFNGLUSEPROGRAMPROC) (GLuint program);
+typedef void (APIENTRYP PFNGLUNIFORM1FPROC) (GLint location, GLfloat v0);
+typedef void (APIENTRYP PFNGLUNIFORM1IPROC) (GLint location, GLint v0);
+typedef void (APIENTRYP PFNGLUNIFORM2FPROC) (GLint location, GLfloat v0, GLfloat v1);
+typedef void (APIENTRYP PFNGLUNIFORM4FPROC) (GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
+typedef GLuint (APIENTRYP PFNGLGETUNIFORMBLOCKINDEXPROC) (GLuint program, const GLchar* uniformBlockName);
+typedef void (APIENTRYP PFNGLUNIFORMBLOCKBINDINGPROC) (GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding);
+typedef void (APIENTRYP PFNGLACTIVETEXTUREPROC) (GLenum texture);
+typedef void (APIENTRYP PFNGLBINDBUFFERBASEPROC) (GLenum target, GLuint index, GLuint buffer);
+typedef void (APIENTRYP PFNGLBUFFERSUBDATAPROC) (GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data);
+typedef void (APIENTRYP PFNGLBINDVERTEXARRAYPROC) (GLuint array);
+typedef void (APIENTRYP PFNGLDELETEVERTEXARRAYSPROC) (GLsizei n, const GLuint* arrays);
+typedef void (APIENTRYP PFNGLGENVERTEXARRAYSPROC) (GLsizei n, GLuint* arrays);
+typedef GLsync (APIENTRYP PFNGLFENCESYNCPROC) (GLenum condition, GLbitfield flags);
+typedef void (APIENTRYP PFNGLDELETESYNCPROC) (GLsync sync);
+typedef GLenum (APIENTRYP PFNGLCLIENTWAITSYNCPROC) (GLsync sync, GLbitfield flags, GLuint64 timeout);
+typedef void (APIENTRYP PFNGLBINDRENDERBUFFERPROC) (GLenum target, GLuint renderbuffer);
+typedef void (APIENTRYP PFNGLDELETERENDERBUFFERSPROC) (GLsizei n, const GLuint *renderbuffers);
+typedef void (APIENTRYP PFNGLGENRENDERBUFFERSPROC) (GLsizei n, GLuint *renderbuffers);
+typedef void (APIENTRYP PFNGLRENDERBUFFERSTORAGEPROC) (GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
+typedef void (APIENTRYP PFNGLBINDFRAMEBUFFERPROC) (GLenum target, GLuint framebuffer);
+typedef void (APIENTRYP PFNGLDELETEFRAMEBUFFERSPROC) (GLsizei n, const GLuint *framebuffers);
+typedef void (APIENTRYP PFNGLGENFRAMEBUFFERSPROC) (GLsizei n, GLuint *framebuffers);
+typedef GLenum (APIENTRYP PFNGLCHECKFRAMEBUFFERSTATUSPROC) (GLenum target);
+typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURE2DPROC) (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
+typedef void (APIENTRYP PFNGLFRAMEBUFFERRENDERBUFFERPROC) (GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
+typedef void (APIENTRYP PFNGLBLITFRAMEBUFFERPROC) (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
+
+extern PFNGLGENFRAMEBUFFERSPROC glGenFramebuffers;
+extern PFNGLGENRENDERBUFFERSPROC glGenRenderbuffers;
+extern PFNGLBINDRENDERBUFFERPROC glBindRenderbuffer;
+extern PFNGLRENDERBUFFERSTORAGEPROC glRenderbufferStorage;
+extern PFNGLDELETEFRAMEBUFFERSPROC glDeleteFramebuffers;
+extern PFNGLDELETERENDERBUFFERSPROC glDeleteRenderbuffers;
+extern PFNGLBINDFRAMEBUFFERPROC glBindFramebuffer;
+extern PFNGLFRAMEBUFFERTEXTURE2DPROC glFramebufferTexture2D;
+extern PFNGLFRAMEBUFFERRENDERBUFFERPROC glFramebufferRenderbuffer;
+extern PFNGLCHECKFRAMEBUFFERSTATUSPROC glCheckFramebufferStatus;
+extern PFNGLBLITFRAMEBUFFERPROC glBlitFramebuffer;
+extern PFNGLFENCESYNCPROC glFenceSync;
+extern PFNGLCLIENTWAITSYNCPROC glClientWaitSync;
+extern PFNGLDELETESYNCPROC glDeleteSync;
+extern PFNGLGENBUFFERSPROC glGenBuffers;
+extern PFNGLDELETEBUFFERSPROC glDeleteBuffers;
+extern PFNGLBINDBUFFERPROC glBindBuffer;
+extern PFNGLBUFFERDATAPROC glBufferData;
+extern PFNGLBUFFERSUBDATAPROC glBufferSubData;
+extern PFNGLBINDBUFFERBASEPROC glBindBufferBase;
+extern PFNGLACTIVETEXTUREPROC glActiveTexture;
+extern PFNGLGENVERTEXARRAYSPROC glGenVertexArrays;
+extern PFNGLDELETEVERTEXARRAYSPROC glDeleteVertexArrays;
+extern PFNGLBINDVERTEXARRAYPROC glBindVertexArray;
+extern PFNGLCREATESHADERPROC glCreateShader;
+extern PFNGLDELETESHADERPROC glDeleteShader;
+extern PFNGLDELETEPROGRAMPROC glDeleteProgram;
+extern PFNGLSHADERSOURCEPROC glShaderSource;
+extern PFNGLCOMPILESHADERPROC glCompileShader;
+extern PFNGLGETSHADERIVPROC glGetShaderiv;
+extern PFNGLGETSHADERINFOLOGPROC glGetShaderInfoLog;
+extern PFNGLCREATEPROGRAMPROC glCreateProgram;
+extern PFNGLATTACHSHADERPROC glAttachShader;
+extern PFNGLLINKPROGRAMPROC glLinkProgram;
+extern PFNGLGETPROGRAMIVPROC glGetProgramiv;
+extern PFNGLGETPROGRAMINFOLOGPROC glGetProgramInfoLog;
+extern PFNGLUSEPROGRAMPROC glUseProgram;
+extern PFNGLGETUNIFORMLOCATIONPROC glGetUniformLocation;
+extern PFNGLGETUNIFORMBLOCKINDEXPROC glGetUniformBlockIndex;
+extern PFNGLUNIFORMBLOCKBINDINGPROC glUniformBlockBinding;
+extern PFNGLUNIFORM1IPROC glUniform1i;
+extern PFNGLUNIFORM1FPROC glUniform1f;
+extern PFNGLUNIFORM2FPROC glUniform2f;
+extern PFNGLUNIFORM4FPROC glUniform4f;
+
+bool ResolveGLExtensions();
+
+#endif // __GLEXTENSIONS_H__
+

apps/LoopThroughWithOpenGLCompositing/gl/GlScopedObjects.h

@@ -0,0 +1,57 @@
+#pragma once
+
+#include <gl/gl.h>
+
+class ScopedGlShader
+{
+public:
+	explicit ScopedGlShader(GLuint shader = 0) : mShader(shader) {}
+	~ScopedGlShader() { reset(); }
+
+	ScopedGlShader(const ScopedGlShader&) = delete;
+	ScopedGlShader& operator=(const ScopedGlShader&) = delete;
+
+	GLuint get() const { return mShader; }
+	GLuint release()
+	{
+		GLuint shader = mShader;
+		mShader = 0;
+		return shader;
+	}
+	void reset(GLuint shader = 0)
+	{
+		if (mShader != 0)
+			glDeleteShader(mShader);
+		mShader = shader;
+	}
+
+private:
+	GLuint mShader;
+};
+
+class ScopedGlProgram
+{
+public:
+	explicit ScopedGlProgram(GLuint program = 0) : mProgram(program) {}
+	~ScopedGlProgram() { reset(); }
+
+	ScopedGlProgram(const ScopedGlProgram&) = delete;
+	ScopedGlProgram& operator=(const ScopedGlProgram&) = delete;
+
+	GLuint get() const { return mProgram; }
+	GLuint release()
+	{
+		GLuint program = mProgram;
+		mProgram = 0;
+		return program;
+	}
+	void reset(GLuint program = 0)
+	{
+		if (mProgram != 0)
+			glDeleteProgram(mProgram);
+		mProgram = program;
+	}
+
+private:
+	GLuint mProgram;
+};

apps/LoopThroughWithOpenGLCompositing/gl/OpenGLComposite.h

@@ -0,0 +1,240 @@
+/* -LICENSE-START-
+ ** Copyright (c) 2012 Blackmagic Design
+ **  
+ ** Permission is hereby granted, free of charge, to any person or organization 
+ ** obtaining a copy of the software and accompanying documentation (the 
+ ** "Software") to use, reproduce, display, distribute, sub-license, execute, 
+ ** and transmit the Software, and to prepare derivative works of the Software, 
+ ** and to permit third-parties to whom the Software is furnished to do so, in 
+ ** accordance with:
+ ** 
+ ** (1) if the Software is obtained from Blackmagic Design, the End User License 
+ ** Agreement for the Software Development Kit ("EULA") available at 
+ ** https://www.blackmagicdesign.com/EULA/DeckLinkSDK; or
+ ** 
+ ** (2) if the Software is obtained from any third party, such licensing terms 
+ ** as notified by that third party,
+ ** 
+ ** and all subject to the following:
+ ** 
+ ** (3) the copyright notices in the Software and this entire statement, 
+ ** including the above license grant, this restriction and the following 
+ ** disclaimer, must be included in all copies of the Software, in whole or in 
+ ** part, and all derivative works of the Software, unless such copies or 
+ ** derivative works are solely in the form of machine-executable object code 
+ ** generated by a source language processor.
+ ** 
+ ** (4) THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 
+ ** OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ ** FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT 
+ ** SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE 
+ ** FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, 
+ ** ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 
+ ** DEALINGS IN THE SOFTWARE.
+ ** 
+ ** A copy of the Software is available free of charge at 
+ ** https://www.blackmagicdesign.com/desktopvideo_sdk under the EULA.
+ ** 
+ ** -LICENSE-END-
+ */
+
+#ifndef __OPENGL_COMPOSITE_H__
+#define __OPENGL_COMPOSITE_H__
+
+#include <windows.h>
+#include <process.h>
+#include <tchar.h>
+#include <gl/gl.h>
+#include <gl/glu.h>
+
+#include <objbase.h>
+#include <atlbase.h>
+#include <comutil.h>
+#include "DeckLinkAPI_h.h"
+
+#include "GLExtensions.h"
+#include "RuntimeHost.h"
+
+#include <atomic>
+#include <functional>
+#include <map>
+#include <memory>
+#include <vector>
+#include <deque>
+
+class PlayoutDelegate;
+class CaptureDelegate;
+class PinnedMemoryAllocator;
+class ControlServer;
+class OscServer;
+
+
+class OpenGLComposite
+{
+public:
+	OpenGLComposite(HWND hWnd, HDC hDC, HGLRC hRC);
+	~OpenGLComposite();
+
+	bool InitDeckLink();
+	bool Start();
+	bool Stop();
+	bool ReloadShader();
+	std::string GetRuntimeStateJson() const;
+	bool AddLayer(const std::string& shaderId, std::string& error);
+	bool RemoveLayer(const std::string& layerId, std::string& error);
+	bool MoveLayer(const std::string& layerId, int direction, std::string& error);
+	bool MoveLayerToIndex(const std::string& layerId, std::size_t targetIndex, std::string& error);
+	bool SetLayerBypass(const std::string& layerId, bool bypassed, std::string& error);
+	bool SetLayerShader(const std::string& layerId, const std::string& shaderId, std::string& error);
+	bool UpdateLayerParameterJson(const std::string& layerId, const std::string& parameterId, const std::string& valueJson, std::string& error);
+	bool UpdateLayerParameterByControlKeyJson(const std::string& layerKey, const std::string& parameterKey, const std::string& valueJson, std::string& error);
+	bool ResetLayerParameters(const std::string& layerId, std::string& error);
+	bool SaveStackPreset(const std::string& presetName, std::string& error);
+	bool LoadStackPreset(const std::string& presetName, std::string& error);
+
+	void resizeGL(WORD width, WORD height);
+	void paintGL();
+
+	void VideoFrameArrived(IDeckLinkVideoInputFrame* inputFrame, bool hasNoInputSource);
+	void PlayoutFrameCompleted(IDeckLinkVideoFrame* completedFrame, BMDOutputFrameCompletionResult result);
+
+private:
+	void resizeWindow(int width, int height);
+	bool CheckOpenGLExtensions();
+
+	CaptureDelegate*						mCaptureDelegate;
+	PlayoutDelegate*						mPlayoutDelegate;
+	HWND									hGLWnd;
+	HDC										hGLDC;
+	HGLRC									hGLRC;
+	CRITICAL_SECTION						pMutex;
+
+	// DeckLink
+	IDeckLinkInput*							mDLInput;
+	IDeckLinkOutput*						mDLOutput;
+	IDeckLinkKeyer*							mDLKeyer;
+	std::deque<IDeckLinkMutableVideoFrame*>	mDLOutputVideoFrameQueue;
+	PinnedMemoryAllocator*					mPlayoutAllocator;
+	BMDTimeValue							mFrameDuration;
+	BMDTimeScale							mFrameTimescale;
+	unsigned								mTotalPlayoutFrames;
+	unsigned								mInputFrameWidth;
+	unsigned								mInputFrameHeight;
+	unsigned								mOutputFrameWidth;
+	unsigned								mOutputFrameHeight;
+	std::string								mInputDisplayModeName;
+	std::string								mOutputDisplayModeName;
+	bool									mHasNoInputSource;
+	std::string								mDeckLinkOutputModelName;
+	bool									mDeckLinkSupportsInternalKeying;
+	bool									mDeckLinkSupportsExternalKeying;
+	bool									mDeckLinkKeyerInterfaceAvailable;
+	bool									mDeckLinkExternalKeyingActive;
+	std::string								mDeckLinkStatusMessage;
+
+	// OpenGL data
+	bool									mFastTransferExtensionAvailable;
+	GLuint									mCaptureTexture;
+	GLuint									mDecodedTexture;
+	GLuint									mLayerTempTexture;
+	GLuint									mFBOTexture;
+	GLuint									mOutputTexture;
+	GLuint									mUnpinnedTextureBuffer;
+	GLuint									mDecodeFrameBuf;
+	GLuint									mLayerTempFrameBuf;
+	GLuint									mIdFrameBuf;
+	GLuint									mOutputFrameBuf;
+	GLuint									mIdColorBuf;
+	GLuint									mIdDepthBuf;
+	GLuint									mFullscreenVAO;
+	GLuint									mGlobalParamsUBO;
+	GLuint									mDecodeProgram;
+	GLuint									mDecodeVertexShader;
+	GLuint									mDecodeFragmentShader;
+	GLsizeiptr								mGlobalParamsUBOSize;
+	int										mViewWidth;
+	int										mViewHeight;
+	std::unique_ptr<RuntimeHost>				mRuntimeHost;
+	std::unique_ptr<ControlServer>			mControlServer;
+	std::unique_ptr<OscServer>				mOscServer;
+
+	struct LayerProgram
+	{
+		struct TextureBinding
+		{
+			std::string samplerName;
+			std::filesystem::path sourcePath;
+			GLuint texture = 0;
+		};
+
+		struct TextBinding
+		{
+			std::string parameterId;
+			std::string samplerName;
+			std::string fontId;
+			GLuint texture = 0;
+			std::string renderedText;
+			unsigned renderedWidth = 0;
+			unsigned renderedHeight = 0;
+		};
+
+		std::string layerId;
+		std::string shaderId;
+		GLuint shaderTextureBase = 0;
+		GLuint program = 0;
+		GLuint vertexShader = 0;
+		GLuint fragmentShader = 0;
+		std::vector<TextureBinding> textureBindings;
+		std::vector<TextBinding> textBindings;
+	};
+	std::vector<LayerProgram>				mLayerPrograms;
+
+	struct HistorySlot
+	{
+		GLuint texture = 0;
+		GLuint framebuffer = 0;
+	};
+
+	struct HistoryRing
+	{
+		std::vector<HistorySlot> slots;
+		std::size_t nextWriteIndex = 0;
+		std::size_t filledCount = 0;
+		unsigned effectiveLength = 0;
+		TemporalHistorySource historySource = TemporalHistorySource::None;
+	};
+
+	HistoryRing								mSourceHistoryRing;
+	std::map<std::string, HistoryRing>		mPreLayerHistoryByLayerId;
+	bool									mTemporalHistoryNeedsReset;
+
+	bool InitOpenGLState();
+	bool compileLayerPrograms(int errorMessageSize, char* errorMessage);
+	bool compileSingleLayerProgram(const RuntimeRenderState& state, LayerProgram& layerProgram, int errorMessageSize, char* errorMessage);
+	bool compileDecodeShader(int errorMessageSize, char* errorMessage);
+	void destroyLayerPrograms();
+	void destroySingleLayerProgram(LayerProgram& layerProgram);
+	void destroyDecodeShaderProgram();
+	void renderDecodePass();
+	void renderShaderProgram(GLuint sourceTexture, GLuint destinationFrameBuffer, LayerProgram& layerProgram, const RuntimeRenderState& state);
+	bool loadTextureAsset(const ShaderTextureAsset& textureAsset, GLuint& textureId, std::string& error);
+	bool renderTextBindingTexture(const RuntimeRenderState& state, LayerProgram::TextBinding& textBinding, std::string& error);
+	void bindLayerTextureAssets(const LayerProgram& layerProgram);
+	void renderEffect();
+	bool PollRuntimeChanges();
+	void broadcastRuntimeState();
+	bool updateGlobalParamsBuffer(const RuntimeRenderState& state, unsigned availableSourceHistoryLength, unsigned availableTemporalHistoryLength);
+	bool validateTemporalTextureUnitBudget(const std::vector<RuntimeRenderState>& layerStates, std::string& error) const;
+	bool ensureTemporalHistoryResources(const std::vector<RuntimeRenderState>& layerStates, std::string& error);
+	bool createHistoryRing(HistoryRing& ring, unsigned effectiveLength, TemporalHistorySource historySource, std::string& error);
+	void destroyHistoryRing(HistoryRing& ring);
+	void destroyTemporalHistoryResources();
+	void resetTemporalHistoryState();
+	void pushFramebufferToHistoryRing(GLuint sourceFramebuffer, HistoryRing& ring);
+	void bindHistorySamplers(const RuntimeRenderState& state, GLuint currentSourceTexture);
+	GLuint resolveHistoryTexture(const HistoryRing& ring, GLuint fallbackTexture, std::size_t framesAgo) const;
+	unsigned sourceHistoryAvailableCount() const;
+	unsigned temporalHistoryAvailableCountForLayer(const std::string& layerId) const;
+};
+
+#endif		// __OPENGL_COMPOSITE_H__

apps/LoopThroughWithOpenGLCompositing/gl/OpenGLCompositeRuntimeControls.cpp

@@ -0,0 +1,127 @@
+#include "OpenGLComposite.h"
+
+std::string OpenGLComposite::GetRuntimeStateJson() const
+{
+	return mRuntimeHost ? mRuntimeHost->BuildStateJson() : "{}";
+}
+
+bool OpenGLComposite::AddLayer(const std::string& shaderId, std::string& error)
+{
+	if (!mRuntimeHost->AddLayer(shaderId, error))
+		return false;
+
+	ReloadShader();
+	resetTemporalHistoryState();
+	broadcastRuntimeState();
+	return true;
+}
+
+bool OpenGLComposite::RemoveLayer(const std::string& layerId, std::string& error)
+{
+	if (!mRuntimeHost->RemoveLayer(layerId, error))
+		return false;
+
+	ReloadShader();
+	resetTemporalHistoryState();
+	broadcastRuntimeState();
+	return true;
+}
+
+bool OpenGLComposite::MoveLayer(const std::string& layerId, int direction, std::string& error)
+{
+	if (!mRuntimeHost->MoveLayer(layerId, direction, error))
+		return false;
+
+	ReloadShader();
+	resetTemporalHistoryState();
+	broadcastRuntimeState();
+	return true;
+}
+
+bool OpenGLComposite::MoveLayerToIndex(const std::string& layerId, std::size_t targetIndex, std::string& error)
+{
+	if (!mRuntimeHost->MoveLayerToIndex(layerId, targetIndex, error))
+		return false;
+
+	ReloadShader();
+	resetTemporalHistoryState();
+	broadcastRuntimeState();
+	return true;
+}
+
+bool OpenGLComposite::SetLayerBypass(const std::string& layerId, bool bypassed, std::string& error)
+{
+	if (!mRuntimeHost->SetLayerBypass(layerId, bypassed, error))
+		return false;
+
+	ReloadShader();
+	resetTemporalHistoryState();
+	broadcastRuntimeState();
+	return true;
+}
+
+bool OpenGLComposite::SetLayerShader(const std::string& layerId, const std::string& shaderId, std::string& error)
+{
+	if (!mRuntimeHost->SetLayerShader(layerId, shaderId, error))
+		return false;
+
+	ReloadShader();
+	resetTemporalHistoryState();
+	broadcastRuntimeState();
+	return true;
+}
+
+bool OpenGLComposite::UpdateLayerParameterJson(const std::string& layerId, const std::string& parameterId, const std::string& valueJson, std::string& error)
+{
+	JsonValue parsedValue;
+	if (!ParseJson(valueJson, parsedValue, error))
+		return false;
+
+	if (!mRuntimeHost->UpdateLayerParameter(layerId, parameterId, parsedValue, error))
+		return false;
+
+	broadcastRuntimeState();
+	return true;
+}
+
+bool OpenGLComposite::UpdateLayerParameterByControlKeyJson(const std::string& layerKey, const std::string& parameterKey, const std::string& valueJson, std::string& error)
+{
+	JsonValue parsedValue;
+	if (!ParseJson(valueJson, parsedValue, error))
+		return false;
+
+	if (!mRuntimeHost->UpdateLayerParameterByControlKey(layerKey, parameterKey, parsedValue, error))
+		return false;
+
+	broadcastRuntimeState();
+	return true;
+}
+
+bool OpenGLComposite::ResetLayerParameters(const std::string& layerId, std::string& error)
+{
+	if (!mRuntimeHost->ResetLayerParameters(layerId, error))
+		return false;
+
+	broadcastRuntimeState();
+	return true;
+}
+
+bool OpenGLComposite::SaveStackPreset(const std::string& presetName, std::string& error)
+{
+	if (!mRuntimeHost->SaveStackPreset(presetName, error))
+		return false;
+
+	broadcastRuntimeState();
+	return true;
+}
+
+bool OpenGLComposite::LoadStackPreset(const std::string& presetName, std::string& error)
+{
+	if (!mRuntimeHost->LoadStackPreset(presetName, error))
+		return false;
+
+	ReloadShader();
+	resetTemporalHistoryState();
+	broadcastRuntimeState();
+	return true;
+}

apps/LoopThroughWithOpenGLCompositing/gl/Std140Buffer.h

@@ -0,0 +1,48 @@
+#pragma once
+
+#include <cstddef>
+#include <cstring>
+#include <vector>
+
+inline std::size_t AlignStd140(std::size_t offset, std::size_t alignment)
+{
+	const std::size_t mask = alignment - 1;
+	return (offset + mask) & ~mask;
+}
+
+template <typename TValue>
+inline void AppendStd140Value(std::vector<unsigned char>& buffer, std::size_t alignment, const TValue& value)
+{
+	const std::size_t offset = AlignStd140(buffer.size(), alignment);
+	if (buffer.size() < offset + sizeof(TValue))
+		buffer.resize(offset + sizeof(TValue), 0);
+	std::memcpy(buffer.data() + offset, &value, sizeof(TValue));
+}
+
+inline void AppendStd140Float(std::vector<unsigned char>& buffer, float value)
+{
+	AppendStd140Value(buffer, 4, value);
+}
+
+inline void AppendStd140Int(std::vector<unsigned char>& buffer, int value)
+{
+	AppendStd140Value(buffer, 4, value);
+}
+
+inline void AppendStd140Vec2(std::vector<unsigned char>& buffer, float x, float y)
+{
+	const std::size_t offset = AlignStd140(buffer.size(), 8);
+	if (buffer.size() < offset + sizeof(float) * 2)
+		buffer.resize(offset + sizeof(float) * 2, 0);
+	float values[2] = { x, y };
+	std::memcpy(buffer.data() + offset, values, sizeof(values));
+}
+
+inline void AppendStd140Vec4(std::vector<unsigned char>& buffer, float x, float y, float z, float w)
+{
+	const std::size_t offset = AlignStd140(buffer.size(), 16);
+	if (buffer.size() < offset + sizeof(float) * 4)
+		buffer.resize(offset + sizeof(float) * 4, 0);
+	float values[4] = { x, y, z, w };
+	std::memcpy(buffer.data() + offset, values, sizeof(values));
+}

apps/LoopThroughWithOpenGLCompositing/gl/TextRasterizer.cpp

@@ -0,0 +1,316 @@
+#include "TextRasterizer.h"
+
+#include <windows.h>
+
+#include <algorithm>
+#include <cmath>
+#include <cstring>
+#include <fstream>
+#include <gdiplus.h>
+#include <memory>
+#include <sstream>
+
+namespace
+{
+constexpr int kTextSdfSpread = 20;
+constexpr unsigned kTextSdfBlurPasses = 1;
+constexpr float kTextFontPixelSize = 144.0f;
+constexpr float kTextLayoutPadding = 48.0f;
+
+class GdiplusSession
+{
+public:
+	GdiplusSession()
+	{
+		Gdiplus::GdiplusStartupInput startupInput;
+		mStarted = Gdiplus::GdiplusStartup(&mToken, &startupInput, NULL) == Gdiplus::Ok;
+	}
+
+	~GdiplusSession()
+	{
+		if (mStarted)
+			Gdiplus::GdiplusShutdown(mToken);
+	}
+
+	GdiplusSession(const GdiplusSession&) = delete;
+	GdiplusSession& operator=(const GdiplusSession&) = delete;
+
+	bool started() const { return mStarted; }
+
+private:
+	ULONG_PTR mToken = 0;
+	bool mStarted = false;
+};
+
+std::wstring Utf8ToWide(const std::string& text)
+{
+	if (text.empty())
+		return std::wstring();
+	const int required = MultiByteToWideChar(CP_UTF8, 0, text.c_str(), -1, NULL, 0);
+	if (required <= 1)
+		return std::wstring();
+	std::wstring wide(static_cast<std::size_t>(required - 1), L'\0');
+	MultiByteToWideChar(CP_UTF8, 0, text.c_str(), -1, wide.data(), required);
+	return wide;
+}
+
+std::vector<unsigned char> BuildLocalSdf(const std::vector<unsigned char>& alpha, unsigned width, unsigned height)
+{
+	std::vector<unsigned char> sdf(static_cast<std::size_t>(width) * height * 4, 0);
+	for (unsigned y = 0; y < height; ++y)
+	{
+		for (unsigned x = 0; x < width; ++x)
+		{
+			const bool inside = alpha[static_cast<std::size_t>(y) * width + x] > 127;
+			int bestDistanceSq = kTextSdfSpread * kTextSdfSpread;
+			for (int oy = -kTextSdfSpread; oy <= kTextSdfSpread; ++oy)
+			{
+				const int sy = static_cast<int>(y) + oy;
+				if (sy < 0 || sy >= static_cast<int>(height))
+					continue;
+				for (int ox = -kTextSdfSpread; ox <= kTextSdfSpread; ++ox)
+				{
+					const int sx = static_cast<int>(x) + ox;
+					if (sx < 0 || sx >= static_cast<int>(width))
+						continue;
+					const bool sampleInside = alpha[static_cast<std::size_t>(sy) * width + sx] > 127;
+					if (sampleInside == inside)
+						continue;
+					const int distanceSq = ox * ox + oy * oy;
+					if (distanceSq < bestDistanceSq)
+						bestDistanceSq = distanceSq;
+				}
+			}
+
+			const float distance = std::sqrt(static_cast<float>(bestDistanceSq));
+			const float signedDistance = (inside ? 1.0f : -1.0f) * distance;
+			float normalized = 0.5f + signedDistance / static_cast<float>(kTextSdfSpread * 2);
+			const unsigned char sourceAlpha = alpha[static_cast<std::size_t>(y) * width + x];
+			if (sourceAlpha > 0 && sourceAlpha < 255)
+				normalized = static_cast<float>(sourceAlpha) / 255.0f;
+			if (normalized < 0.0f)
+				normalized = 0.0f;
+			if (normalized > 1.0f)
+				normalized = 1.0f;
+			const unsigned char value = static_cast<unsigned char>(normalized * 255.0f + 0.5f);
+			const std::size_t out = (static_cast<std::size_t>(y) * width + x) * 4;
+			sdf[out + 0] = value;
+			sdf[out + 1] = value;
+			sdf[out + 2] = value;
+			sdf[out + 3] = value;
+		}
+	}
+	return sdf;
+}
+
+std::vector<unsigned char> BuildTextCoverageTexture(const std::vector<unsigned char>& alpha, unsigned width, unsigned height)
+{
+	std::vector<unsigned char> coverage(static_cast<std::size_t>(width) * height * 4, 0);
+	for (unsigned y = 0; y < height; ++y)
+	{
+		for (unsigned x = 0; x < width; ++x)
+		{
+			const unsigned char value = alpha[static_cast<std::size_t>(y) * width + x];
+			const std::size_t out = (static_cast<std::size_t>(y) * width + x) * 4;
+			coverage[out + 0] = value;
+			coverage[out + 1] = value;
+			coverage[out + 2] = value;
+			coverage[out + 3] = value;
+		}
+	}
+	return coverage;
+}
+
+std::vector<unsigned char> FlipTextTextureForShaderUv(const std::vector<unsigned char>& pixels, unsigned width, unsigned height)
+{
+	std::vector<unsigned char> flipped(pixels.size(), 0);
+	const std::size_t stride = static_cast<std::size_t>(width) * 4;
+	for (unsigned y = 0; y < height; ++y)
+	{
+		const std::size_t srcOffset = static_cast<std::size_t>(y) * stride;
+		const std::size_t dstOffset = static_cast<std::size_t>(height - 1 - y) * stride;
+		std::memcpy(flipped.data() + dstOffset, pixels.data() + srcOffset, stride);
+	}
+	return flipped;
+}
+
+std::vector<unsigned char> BlurTextSdf(const std::vector<unsigned char>& pixels, unsigned width, unsigned height, unsigned passes)
+{
+	std::vector<unsigned char> current = pixels;
+	std::vector<unsigned char> next(pixels.size(), 0);
+	for (unsigned pass = 0; pass < passes; ++pass)
+	{
+		for (unsigned y = 0; y < height; ++y)
+		{
+			for (unsigned x = 0; x < width; ++x)
+			{
+				unsigned weightedTotal = 0;
+				unsigned weightSum = 0;
+				for (int oy = -1; oy <= 1; ++oy)
+				{
+					const int sy = static_cast<int>(y) + oy;
+					if (sy < 0 || sy >= static_cast<int>(height))
+						continue;
+					for (int ox = -1; ox <= 1; ++ox)
+					{
+						const int sx = static_cast<int>(x) + ox;
+						if (sx < 0 || sx >= static_cast<int>(width))
+							continue;
+						const unsigned weight = (ox == 0 && oy == 0) ? 4u : ((ox == 0 || oy == 0) ? 2u : 1u);
+						const std::size_t sample = (static_cast<std::size_t>(sy) * width + sx) * 4;
+						weightedTotal += static_cast<unsigned>(current[sample]) * weight;
+						weightSum += weight;
+					}
+				}
+
+				const unsigned char value = static_cast<unsigned char>((weightedTotal + weightSum / 2) / weightSum);
+				const std::size_t out = (static_cast<std::size_t>(y) * width + x) * 4;
+				next[out + 0] = value;
+				next[out + 1] = value;
+				next[out + 2] = value;
+				next[out + 3] = value;
+			}
+		}
+		current.swap(next);
+	}
+	return current;
+}
+
+void WriteTextMaskDebugDump(const std::string& text, const std::vector<unsigned char>& alpha, const std::vector<unsigned char>& sdf, unsigned width, unsigned height)
+{
+	try
+	{
+		std::filesystem::path debugDir = std::filesystem::current_path() / "runtime";
+		std::filesystem::create_directories(debugDir);
+
+		auto writePgm = [width, height](const std::filesystem::path& path, const std::vector<unsigned char>& gray, std::size_t stride)
+		{
+			std::ofstream out(path, std::ios::binary);
+			if (!out)
+				return;
+			out << "P5\n" << width << " " << height << "\n255\n";
+			for (unsigned y = 0; y < height; ++y)
+			{
+				for (unsigned x = 0; x < width; ++x)
+					out.put(static_cast<char>(gray[(static_cast<std::size_t>(y) * width + x) * stride]));
+			}
+		};
+
+		writePgm(debugDir / "text-mask-alpha-debug.pgm", alpha, 1);
+		writePgm(debugDir / "text-mask-sdf-debug.pgm", sdf, 4);
+
+		unsigned alphaMin = 255;
+		unsigned alphaMax = 0;
+		unsigned sdfMin = 255;
+		unsigned sdfMax = 0;
+		std::size_t alphaLit = 0;
+		std::size_t sdfLit = 0;
+		for (unsigned char value : alpha)
+		{
+			alphaMin = std::min<unsigned>(alphaMin, value);
+			alphaMax = std::max<unsigned>(alphaMax, value);
+			if (value > 0)
+				++alphaLit;
+		}
+		for (std::size_t index = 0; index < sdf.size(); index += 4)
+		{
+			const unsigned char value = sdf[index];
+			sdfMin = std::min<unsigned>(sdfMin, value);
+			sdfMax = std::max<unsigned>(sdfMax, value);
+			if (value > 127)
+				++sdfLit;
+		}
+
+		std::ostringstream message;
+		message << "Text mask debug for '" << text << "': alpha min/max/lit=" << alphaMin << "/" << alphaMax << "/" << alphaLit
+			<< ", sdf min/max/gt127=" << sdfMin << "/" << sdfMax << "/" << sdfLit << "\n";
+		OutputDebugStringA(message.str().c_str());
+	}
+	catch (...)
+	{
+		OutputDebugStringA("Failed to write text mask debug dump.\n");
+	}
+}
+}
+
+bool RasterizeTextSdf(const std::string& text, const std::filesystem::path& fontPath, std::vector<unsigned char>& sdf, std::string& error)
+{
+	GdiplusSession gdiplus;
+	if (!gdiplus.started())
+	{
+		error = "Could not start GDI+ for text rendering.";
+		return false;
+	}
+
+	Gdiplus::PrivateFontCollection fontCollection;
+	Gdiplus::FontFamily fallbackFamily(L"Arial");
+	Gdiplus::FontFamily* fontFamily = &fallbackFamily;
+	std::unique_ptr<Gdiplus::FontFamily[]> families;
+	const std::wstring wideFontPath = fontPath.empty() ? std::wstring() : fontPath.wstring();
+	if (!wideFontPath.empty())
+	{
+		if (fontCollection.AddFontFile(wideFontPath.c_str()) != Gdiplus::Ok)
+		{
+			error = "Could not load packaged font file for text rendering: " + fontPath.string();
+			return false;
+		}
+
+		const INT familyCount = fontCollection.GetFamilyCount();
+		if (familyCount <= 0)
+		{
+			error = "Packaged font did not contain a usable font family: " + fontPath.string();
+			return false;
+		}
+
+		families.reset(new Gdiplus::FontFamily[familyCount]);
+		INT found = 0;
+		if (fontCollection.GetFamilies(familyCount, families.get(), &found) != Gdiplus::Ok || found <= 0)
+		{
+			error = "Could not read the packaged font family: " + fontPath.string();
+			return false;
+		}
+		fontFamily = &families[0];
+	}
+
+	Gdiplus::Bitmap bitmap(kTextTextureWidth, kTextTextureHeight, PixelFormat32bppARGB);
+	Gdiplus::Graphics graphics(&bitmap);
+	graphics.SetCompositingMode(Gdiplus::CompositingModeSourceCopy);
+	graphics.Clear(Gdiplus::Color(255, 0, 0, 0));
+	graphics.SetCompositingMode(Gdiplus::CompositingModeSourceOver);
+	graphics.SetTextRenderingHint(Gdiplus::TextRenderingHintAntiAlias);
+	graphics.SetSmoothingMode(Gdiplus::SmoothingModeHighQuality);
+	Gdiplus::Font font(fontFamily, kTextFontPixelSize, Gdiplus::FontStyleRegular, Gdiplus::UnitPixel);
+	Gdiplus::SolidBrush brush(Gdiplus::Color(255, 255, 255, 255));
+	Gdiplus::StringFormat format;
+	format.SetAlignment(Gdiplus::StringAlignmentNear);
+	format.SetLineAlignment(Gdiplus::StringAlignmentCenter);
+	format.SetFormatFlags(Gdiplus::StringFormatFlagsNoWrap | Gdiplus::StringFormatFlagsMeasureTrailingSpaces);
+	const Gdiplus::RectF layout(
+		kTextLayoutPadding,
+		0.0f,
+		static_cast<Gdiplus::REAL>(kTextTextureWidth) - (kTextLayoutPadding * 2.0f),
+		static_cast<Gdiplus::REAL>(kTextTextureHeight));
+	const std::wstring wideText = Utf8ToWide(text);
+	graphics.DrawString(wideText.c_str(), -1, &font, layout, &format, &brush);
+
+	std::vector<unsigned char> alpha(static_cast<std::size_t>(kTextTextureWidth) * kTextTextureHeight, 0);
+	for (unsigned y = 0; y < kTextTextureHeight; ++y)
+	{
+		for (unsigned x = 0; x < kTextTextureWidth; ++x)
+		{
+			Gdiplus::Color pixel;
+			bitmap.GetPixel(x, y, &pixel);
+			BYTE luminance = pixel.GetRed();
+			if (pixel.GetGreen() > luminance)
+				luminance = pixel.GetGreen();
+			if (pixel.GetBlue() > luminance)
+				luminance = pixel.GetBlue();
+			alpha[static_cast<std::size_t>(y) * kTextTextureWidth + x] = static_cast<unsigned char>(luminance);
+		}
+	}
+	sdf = BuildTextCoverageTexture(alpha, kTextTextureWidth, kTextTextureHeight);
+	sdf = BlurTextSdf(sdf, kTextTextureWidth, kTextTextureHeight, kTextSdfBlurPasses);
+	sdf = FlipTextTextureForShaderUv(sdf, kTextTextureWidth, kTextTextureHeight);
+	WriteTextMaskDebugDump(text, alpha, sdf, kTextTextureWidth, kTextTextureHeight);
+	return true;
+}

apps/LoopThroughWithOpenGLCompositing/gl/TextRasterizer.h

@@ -0,0 +1,10 @@
+#pragma once
+
+#include <filesystem>
+#include <string>
+#include <vector>
+
+constexpr unsigned kTextTextureWidth = 2048;
+constexpr unsigned kTextTextureHeight = 256;
+
+bool RasterizeTextSdf(const std::string& text, const std::filesystem::path& fontPath, std::vector<unsigned char>& sdf, std::string& error);

apps/LoopThroughWithOpenGLCompositing/gl/TextureAssetLoader.cpp

@@ -0,0 +1,114 @@
+#include "TextureAssetLoader.h"
+
+#include <windows.h>
+#include <wincodec.h>
+
+#include <atlbase.h>
+#include <cstring>
+#include <vector>
+
+bool LoadTextureAsset(const ShaderTextureAsset& textureAsset, GLuint& textureId, std::string& error)
+{
+	textureId = 0;
+
+	HRESULT comInitResult = CoInitializeEx(NULL, COINIT_MULTITHREADED);
+	const bool shouldUninitializeCom = (comInitResult == S_OK || comInitResult == S_FALSE);
+	if (FAILED(comInitResult) && comInitResult != RPC_E_CHANGED_MODE)
+	{
+		error = "Could not initialize COM to load shader texture assets.";
+		return false;
+	}
+
+	CComPtr<IWICImagingFactory> imagingFactory;
+	HRESULT result = CoCreateInstance(CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&imagingFactory));
+	if (FAILED(result) || !imagingFactory)
+	{
+		if (shouldUninitializeCom)
+			CoUninitialize();
+		error = "Could not create a WIC imaging factory to load shader texture assets.";
+		return false;
+	}
+
+	CComPtr<IWICBitmapDecoder> bitmapDecoder;
+	result = imagingFactory->CreateDecoderFromFilename(textureAsset.path.wstring().c_str(), NULL, GENERIC_READ, WICDecodeMetadataCacheOnLoad, &bitmapDecoder);
+	if (FAILED(result) || !bitmapDecoder)
+	{
+		if (shouldUninitializeCom)
+			CoUninitialize();
+		error = "Could not open shader texture asset: " + textureAsset.path.string();
+		return false;
+	}
+
+	CComPtr<IWICBitmapFrameDecode> bitmapFrame;
+	result = bitmapDecoder->GetFrame(0, &bitmapFrame);
+	if (FAILED(result) || !bitmapFrame)
+	{
+		if (shouldUninitializeCom)
+			CoUninitialize();
+		error = "Could not decode the first frame of shader texture asset: " + textureAsset.path.string();
+		return false;
+	}
+
+	CComPtr<IWICFormatConverter> formatConverter;
+	result = imagingFactory->CreateFormatConverter(&formatConverter);
+	if (FAILED(result) || !formatConverter)
+	{
+		if (shouldUninitializeCom)
+			CoUninitialize();
+		error = "Could not create a WIC format converter for shader texture asset: " + textureAsset.path.string();
+		return false;
+	}
+
+	result = formatConverter->Initialize(bitmapFrame, GUID_WICPixelFormat32bppBGRA, WICBitmapDitherTypeNone, NULL, 0.0, WICBitmapPaletteTypeCustom);
+	if (FAILED(result))
+	{
+		if (shouldUninitializeCom)
+			CoUninitialize();
+		error = "Could not convert shader texture asset to BGRA: " + textureAsset.path.string();
+		return false;
+	}
+
+	UINT width = 0;
+	UINT height = 0;
+	result = formatConverter->GetSize(&width, &height);
+	if (FAILED(result) || width == 0 || height == 0)
+	{
+		if (shouldUninitializeCom)
+			CoUninitialize();
+		error = "Shader texture asset has an invalid size: " + textureAsset.path.string();
+		return false;
+	}
+
+	const UINT stride = width * 4;
+	std::vector<unsigned char> pixels(static_cast<std::size_t>(stride) * static_cast<std::size_t>(height));
+	result = formatConverter->CopyPixels(NULL, stride, static_cast<UINT>(pixels.size()), pixels.data());
+	if (FAILED(result))
+	{
+		if (shouldUninitializeCom)
+			CoUninitialize();
+		error = "Could not read shader texture pixels: " + textureAsset.path.string();
+		return false;
+	}
+
+	std::vector<unsigned char> flippedPixels(pixels.size());
+	for (UINT row = 0; row < height; ++row)
+	{
+		const std::size_t srcOffset = static_cast<std::size_t>(row) * stride;
+		const std::size_t dstOffset = static_cast<std::size_t>(height - 1 - row) * stride;
+		std::memcpy(flippedPixels.data() + dstOffset, pixels.data() + srcOffset, stride);
+	}
+
+	glGenTextures(1, &textureId);
+	glBindTexture(GL_TEXTURE_2D, textureId);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, static_cast<GLsizei>(width), static_cast<GLsizei>(height), 0, GL_BGRA, GL_UNSIGNED_BYTE, flippedPixels.data());
+	glBindTexture(GL_TEXTURE_2D, 0);
+
+	if (shouldUninitializeCom)
+		CoUninitialize();
+
+	return true;
+}

apps/LoopThroughWithOpenGLCompositing/gl/TextureAssetLoader.h

@@ -0,0 +1,10 @@
+#pragma once
+
+#include "ShaderTypes.h"
+
+#include <windows.h>
+#include <gl/gl.h>
+
+#include <string>
+
+bool LoadTextureAsset(const ShaderTextureAsset& textureAsset, GLuint& textureId, std::string& error);

apps/LoopThroughWithOpenGLCompositing/gl/VideoFrameTransfer.cpp

@@ -0,0 +1,377 @@
+/* -LICENSE-START-
+ ** Copyright (c) 2012 Blackmagic Design
+ **  
+ ** Permission is hereby granted, free of charge, to any person or organization 
+ ** obtaining a copy of the software and accompanying documentation (the 
+ ** "Software") to use, reproduce, display, distribute, sub-license, execute, 
+ ** and transmit the Software, and to prepare derivative works of the Software, 
+ ** and to permit third-parties to whom the Software is furnished to do so, in 
+ ** accordance with:
+ ** 
+ ** (1) if the Software is obtained from Blackmagic Design, the End User License 
+ ** Agreement for the Software Development Kit ("EULA") available at 
+ ** https://www.blackmagicdesign.com/EULA/DeckLinkSDK; or
+ ** 
+ ** (2) if the Software is obtained from any third party, such licensing terms 
+ ** as notified by that third party,
+ ** 
+ ** and all subject to the following:
+ ** 
+ ** (3) the copyright notices in the Software and this entire statement, 
+ ** including the above license grant, this restriction and the following 
+ ** disclaimer, must be included in all copies of the Software, in whole or in 
+ ** part, and all derivative works of the Software, unless such copies or 
+ ** derivative works are solely in the form of machine-executable object code 
+ ** generated by a source language processor.
+ ** 
+ ** (4) THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 
+ ** OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ ** FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT 
+ ** SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE 
+ ** FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, 
+ ** ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 
+ ** DEALINGS IN THE SOFTWARE.
+ ** 
+ ** A copy of the Software is available free of charge at 
+ ** https://www.blackmagicdesign.com/desktopvideo_sdk under the EULA.
+ ** 
+ ** -LICENSE-END-
+ */
+
+#include "VideoFrameTransfer.h"
+#include "NativeHandles.h"
+
+
+#define DVP_CHECK(cmd) {						\
+    DVPStatus hr = (cmd);						\
+    if (DVP_STATUS_OK != hr) {                  \
+		OutputDebugStringA( #cmd " failed\n" );   \
+		ExitProcess(hr);						\
+    }                                           \
+}
+
+
+// Initialise static members
+bool								VideoFrameTransfer::mInitialized = false;
+bool								VideoFrameTransfer::mUseDvp = false;
+unsigned							VideoFrameTransfer::mWidth = 0;
+unsigned							VideoFrameTransfer::mHeight = 0;
+GLuint								VideoFrameTransfer::mCaptureTexture = 0;
+
+// NVIDIA specific static members
+DVPBufferHandle						VideoFrameTransfer::mDvpCaptureTextureHandle = 0;
+DVPBufferHandle						VideoFrameTransfer::mDvpPlaybackTextureHandle = 0;
+uint32_t							VideoFrameTransfer::mBufferAddrAlignment = 0;
+uint32_t							VideoFrameTransfer::mBufferGpuStrideAlignment = 0;
+uint32_t							VideoFrameTransfer::mSemaphoreAddrAlignment = 0;
+uint32_t							VideoFrameTransfer::mSemaphoreAllocSize = 0;
+uint32_t							VideoFrameTransfer::mSemaphorePayloadOffset = 0;
+uint32_t							VideoFrameTransfer::mSemaphorePayloadSize = 0;
+
+
+bool VideoFrameTransfer::isNvidiaDvpAvailable()
+{
+	// Look for supported graphics boards
+	const GLubyte* renderer = glGetString(GL_RENDERER);
+	if (renderer == NULL)
+		return false;
+
+	bool hasDvp = (strstr((char*)renderer, "Quadro") != NULL);
+	return hasDvp;
+}
+
+bool VideoFrameTransfer::isAMDPinnedMemoryAvailable()
+{
+	// GL_AMD_pinned_memory presence indicates GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD buffer target is supported
+	const GLubyte* strExt = glGetString(GL_EXTENSIONS);
+	if (strExt == NULL)
+	{
+		// In a core profile context GL_EXTENSIONS is no longer queryable via glGetString().
+		// Treat this as "extension unavailable" for now; the fast-transfer path is optional.
+		return false;
+	}
+
+	bool hasAMDPinned = (strstr((char*)strExt, "GL_AMD_pinned_memory") != NULL);
+	return hasAMDPinned;
+}
+
+bool VideoFrameTransfer::checkFastMemoryTransferAvailable()
+{
+	return (isNvidiaDvpAvailable() || isAMDPinnedMemoryAvailable());
+}
+
+bool VideoFrameTransfer::initialize(unsigned width, unsigned height, GLuint captureTexture, GLuint playbackTexture)
+{
+	if (mInitialized)
+		return false;
+
+	bool hasDvp = isNvidiaDvpAvailable();
+	bool hasAMDPinned = isAMDPinnedMemoryAvailable();
+
+	if (!hasDvp && !hasAMDPinned)
+		return false;
+
+	mUseDvp = hasDvp;
+	mWidth = width;
+	mHeight = height;
+	mCaptureTexture = captureTexture;
+
+	if (! initializeMemoryLocking(mWidth * mHeight * 4))		// BGRA uses 4 bytes per pixel
+		return false;
+
+	if (mUseDvp)
+	{
+		// DVP initialisation
+		DVP_CHECK(dvpInitGLContext(DVP_DEVICE_FLAGS_SHARE_APP_CONTEXT));
+		DVP_CHECK(dvpGetRequiredConstantsGLCtx(	&mBufferAddrAlignment, &mBufferGpuStrideAlignment,
+												&mSemaphoreAddrAlignment, &mSemaphoreAllocSize,
+												&mSemaphorePayloadOffset, &mSemaphorePayloadSize));
+	
+		// Register textures with DVP
+		DVP_CHECK(dvpCreateGPUTextureGL(captureTexture, &mDvpCaptureTextureHandle));
+		DVP_CHECK(dvpCreateGPUTextureGL(playbackTexture, &mDvpPlaybackTextureHandle));
+	}
+
+	mInitialized = true;
+
+	return true;
+}
+
+bool VideoFrameTransfer::initializeMemoryLocking(unsigned memSize)
+{
+	// Increase the process working set size to allow pinning of memory.
+    static SIZE_T	dwMin = 0, dwMax = 0;
+    UniqueHandle processHandle(OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_SET_QUOTA, FALSE, GetCurrentProcessId()));
+    if (!processHandle.valid())
+		return false;
+
+    // Retrieve the working set size of the process.
+    if (!dwMin && !GetProcessWorkingSetSize(processHandle.get(), &dwMin, &dwMax))
+		return false;
+
+	// Allow for 80 frames to be locked
+	BOOL res = SetProcessWorkingSetSize(processHandle.get(), memSize * 80 + dwMin, memSize * 80 + (dwMax-dwMin));
+    if (!res)
+		return false;
+
+	return true;
+}
+
+// SyncInfo sets up a semaphore which is shared between the GPU and CPU and used to
+// synchronise access to DVP buffers.
+struct SyncInfo
+{
+	SyncInfo(uint32_t semaphoreAllocSize, uint32_t semaphoreAddrAlignment);
+	~SyncInfo();
+
+	volatile uint32_t*	mSem; 
+	volatile uint32_t	mReleaseValue; 
+	volatile uint32_t	mAcquireValue;
+	DVPSyncObjectHandle	mDvpSync;
+};
+
+SyncInfo::SyncInfo(uint32_t semaphoreAllocSize, uint32_t semaphoreAddrAlignment)
+{
+	mSem = (uint32_t*)_aligned_malloc(semaphoreAllocSize, semaphoreAddrAlignment);
+    
+	// Initialise
+	mSem[0] = 0;
+	mReleaseValue = 0;
+	mAcquireValue = 0;
+
+	// Setup DVP sync object and import it
+	DVPSyncObjectDesc syncObjectDesc;
+	syncObjectDesc.externalClientWaitFunc = NULL;
+	syncObjectDesc.sem = (uint32_t*)mSem;
+
+	DVP_CHECK(dvpImportSyncObject(&syncObjectDesc, &mDvpSync));
+}
+
+SyncInfo::~SyncInfo()
+{
+	DVP_CHECK(dvpFreeSyncObject(mDvpSync));
+	_aligned_free((void*)mSem);
+}
+
+VideoFrameTransfer::VideoFrameTransfer(unsigned long memSize, void* address, Direction direction) :
+	mBuffer(address),
+	mMemSize(memSize),
+	mDirection(direction),
+	mExtSync(NULL),
+	mGpuSync(NULL),
+	mDvpSysMemHandle(0),
+	mBufferHandle(0)
+{
+	if (mUseDvp)
+	{
+		// Pin the memory
+		if (! VirtualLock(mBuffer, mMemSize))
+			throw std::runtime_error("Error pinning memory with VirtualLock");
+
+		// Create necessary sysmem and gpu sync objects
+		mExtSync = new SyncInfo(mSemaphoreAllocSize, mSemaphoreAddrAlignment);
+		mGpuSync = new SyncInfo(mSemaphoreAllocSize, mSemaphoreAddrAlignment);
+
+		// Register system memory buffers with DVP
+		DVPSysmemBufferDesc sysMemBuffersDesc;
+		sysMemBuffersDesc.width		= mWidth;
+		sysMemBuffersDesc.height	= mHeight;
+		sysMemBuffersDesc.stride	= mWidth * 4;
+		sysMemBuffersDesc.format	= DVP_BGRA;
+		sysMemBuffersDesc.type		= DVP_UNSIGNED_BYTE;
+		sysMemBuffersDesc.size		= mMemSize;
+		sysMemBuffersDesc.bufAddr	= mBuffer;
+
+		if (mDirection == CPUtoGPU)
+		{
+			// A UYVY 4:2:2 frame is transferred to the GPU, rather than RGB 4:4:4, so width is halved
+			sysMemBuffersDesc.width /= 2;
+			sysMemBuffersDesc.stride /= 2;
+		}
+
+		DVP_CHECK(dvpCreateBuffer(&sysMemBuffersDesc, &mDvpSysMemHandle));
+		DVP_CHECK(dvpBindToGLCtx(mDvpSysMemHandle));
+	}
+	else
+	{
+		// Create an OpenGL buffer handle to use for pinned memory
+		GLuint bufferHandle;
+		glGenBuffers(1, &bufferHandle);
+
+		// Pin memory by binding buffer to special AMD target.
+		glBindBuffer(GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD, bufferHandle);
+
+		// glBufferData() sets up the address so any OpenGL operation on this buffer will use system memory directly
+		// (assumes address is aligned to 4k boundary).
+		glBufferData(GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD, mMemSize, address, GL_STREAM_DRAW);
+		GLenum result = glGetError();
+		if (result != GL_NO_ERROR)
+		{
+			throw std::runtime_error("Error pinning memory with glBufferData(GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD, ...)");
+		}
+		glBindBuffer(GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD, 0);		// Unbind buffer to target
+
+		mBufferHandle = bufferHandle;
+	}
+}
+
+VideoFrameTransfer::~VideoFrameTransfer()
+{
+	if (mUseDvp)
+	{
+		DVP_CHECK(dvpUnbindFromGLCtx(mDvpSysMemHandle));
+		DVP_CHECK(dvpDestroyBuffer(mDvpSysMemHandle));
+
+		delete mExtSync;
+		delete mGpuSync;
+
+		VirtualUnlock(mBuffer, mMemSize);
+	}
+	else
+	{
+		// The buffer is un-pinned by the GPU when the buffer is deleted
+		glDeleteBuffers(1, &mBufferHandle);
+	}
+}
+
+bool VideoFrameTransfer::performFrameTransfer()
+{
+	if (mUseDvp)
+	{
+		// NVIDIA DVP transfers
+		DVPStatus status;
+
+		mGpuSync->mReleaseValue++;
+
+		dvpBegin();
+		if (mDirection == CPUtoGPU)
+		{
+			// Copy from system memory to GPU texture
+			dvpMapBufferWaitDVP(mDvpCaptureTextureHandle);
+			status = dvpMemcpyLined(	mDvpSysMemHandle, mExtSync->mDvpSync, mExtSync->mAcquireValue, DVP_TIMEOUT_IGNORED,
+										mDvpCaptureTextureHandle, mGpuSync->mDvpSync, mGpuSync->mReleaseValue, 0, mHeight);
+			dvpMapBufferEndDVP(mDvpCaptureTextureHandle);
+		}
+		else
+		{
+			// Copy from GPU texture to system memory
+			dvpMapBufferWaitDVP(mDvpPlaybackTextureHandle);
+			status = dvpMemcpyLined(	mDvpPlaybackTextureHandle, mExtSync->mDvpSync, mExtSync->mReleaseValue, DVP_TIMEOUT_IGNORED,
+										mDvpSysMemHandle, mGpuSync->mDvpSync, mGpuSync->mReleaseValue, 0, mHeight);
+			dvpMapBufferEndDVP(mDvpPlaybackTextureHandle);
+		}
+		dvpEnd();
+
+		return (status == DVP_STATUS_OK);
+	}
+	else
+	{
+		// AMD pinned memory transfers
+		if (mDirection == CPUtoGPU)
+		{
+			glEnable(GL_TEXTURE_2D);
+
+			// Use a pinned buffer for the GL_PIXEL_UNPACK_BUFFER target
+			glBindBuffer(GL_PIXEL_UNPACK_BUFFER, mBufferHandle);
+			glBindTexture(GL_TEXTURE_2D, mCaptureTexture);
+
+			// NULL for last arg indicates use current GL_PIXEL_UNPACK_BUFFER target as texture data
+			glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, mWidth/2, mHeight, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, NULL);
+
+			// Ensure pinned texture has been transferred to GPU before we draw with it
+			GLsync fence = glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
+			glClientWaitSync(fence, GL_SYNC_FLUSH_COMMANDS_BIT, 40 * 1000 * 1000);	// timeout in nanosec
+			glDeleteSync(fence);
+
+			glBindTexture(GL_TEXTURE_2D, 0);
+			glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
+			glDisable(GL_TEXTURE_2D);
+		}
+		else
+		{
+			// Use a PIXEL PACK BUFFER to read back pixels
+			glBindBuffer(GL_PIXEL_PACK_BUFFER, mBufferHandle);
+			glReadPixels(0, 0, mWidth, mHeight, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, NULL);
+
+			// Ensure GPU has processed all commands in the pipeline up to this point, before memory is read by the CPU
+			GLsync fence = glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
+			glClientWaitSync(fence, GL_SYNC_FLUSH_COMMANDS_BIT, 40 * 1000 * 1000);	// timeout in nanosec
+			glDeleteSync(fence);
+		}
+
+		return (glGetError() == GL_NO_ERROR);
+	}
+}
+
+void VideoFrameTransfer::waitForTransferComplete()
+{
+	if (!mUseDvp)
+		return;
+
+	// Block until buffer has completely transferred between GPU and CPU buffer
+	dvpBegin();
+	dvpSyncObjClientWaitComplete(mGpuSync->mDvpSync, DVP_TIMEOUT_IGNORED);
+	dvpEnd();
+}
+
+void VideoFrameTransfer::beginTextureInUse(Direction direction)
+{
+	if (!mUseDvp)
+		return;
+
+	if (direction == CPUtoGPU)
+		dvpMapBufferWaitAPI(mDvpCaptureTextureHandle);
+	else
+		dvpMapBufferWaitAPI(mDvpPlaybackTextureHandle);
+}
+
+void VideoFrameTransfer::endTextureInUse(Direction direction)
+{
+	if (!mUseDvp)
+		return;
+
+	if (direction == CPUtoGPU)
+		dvpMapBufferEndAPI(mDvpCaptureTextureHandle);
+	else
+		dvpMapBufferEndAPI(mDvpPlaybackTextureHandle);
+}

apps/LoopThroughWithOpenGLCompositing/gl/VideoFrameTransfer.h

@@ -0,0 +1,109 @@
+/* -LICENSE-START-
+ ** Copyright (c) 2012 Blackmagic Design
+ **  
+ ** Permission is hereby granted, free of charge, to any person or organization 
+ ** obtaining a copy of the software and accompanying documentation (the 
+ ** "Software") to use, reproduce, display, distribute, sub-license, execute, 
+ ** and transmit the Software, and to prepare derivative works of the Software, 
+ ** and to permit third-parties to whom the Software is furnished to do so, in 
+ ** accordance with:
+ ** 
+ ** (1) if the Software is obtained from Blackmagic Design, the End User License 
+ ** Agreement for the Software Development Kit ("EULA") available at 
+ ** https://www.blackmagicdesign.com/EULA/DeckLinkSDK; or
+ ** 
+ ** (2) if the Software is obtained from any third party, such licensing terms 
+ ** as notified by that third party,
+ ** 
+ ** and all subject to the following:
+ ** 
+ ** (3) the copyright notices in the Software and this entire statement, 
+ ** including the above license grant, this restriction and the following 
+ ** disclaimer, must be included in all copies of the Software, in whole or in 
+ ** part, and all derivative works of the Software, unless such copies or 
+ ** derivative works are solely in the form of machine-executable object code 
+ ** generated by a source language processor.
+ ** 
+ ** (4) THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 
+ ** OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+ ** FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT 
+ ** SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE 
+ ** FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, 
+ ** ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 
+ ** DEALINGS IN THE SOFTWARE.
+ ** 
+ ** A copy of the Software is available free of charge at 
+ ** https://www.blackmagicdesign.com/desktopvideo_sdk under the EULA.
+ ** 
+ ** -LICENSE-END-
+ */
+#ifndef __VIDEO_FRAME_TRANSFER_H__
+#define __VIDEO_FRAME_TRANSFER_H__
+
+#include "GLExtensions.h"
+#include <stdexcept>
+#include <map>
+
+// NVIDIA GPU Direct For Video with OpenGL requires the following two headers.
+// See the NVIDIA website to check if your graphics card is supported.
+#include <DVPAPI.h>
+#include <dvpapi_gl.h>
+
+struct SyncInfo;
+
+
+// Class for performing efficient frame memory transfers between the CPU and GPU,
+// using NVIDIA and AMD extensions.
+class VideoFrameTransfer
+{
+public:
+	enum Direction
+	{
+		CPUtoGPU,
+		GPUtoCPU
+	};
+
+	VideoFrameTransfer(unsigned long memSize, void* address, Direction direction);
+	~VideoFrameTransfer();
+
+	static bool checkFastMemoryTransferAvailable();
+	static bool initialize(unsigned width, unsigned height, GLuint captureTexture, GLuint playbackTexture);
+	static void beginTextureInUse(Direction direction);
+	static void endTextureInUse(Direction direction);
+	
+	bool performFrameTransfer();
+	void waitForTransferComplete();
+
+private:
+	static bool isNvidiaDvpAvailable();
+	static bool isAMDPinnedMemoryAvailable();
+	static bool initializeMemoryLocking(unsigned memSize);
+
+	void*						mBuffer;
+	unsigned long				mMemSize;
+	Direction					mDirection;
+	static bool					mInitialized;
+	static bool					mUseDvp;
+	static unsigned				mWidth;
+	static unsigned				mHeight;
+	static GLuint				mCaptureTexture;
+
+	// NVIDIA GPU Direct for Video support
+	SyncInfo*					mExtSync;
+	SyncInfo*					mGpuSync;
+	DVPBufferHandle				mDvpSysMemHandle;
+
+	static DVPBufferHandle		mDvpCaptureTextureHandle;
+	static DVPBufferHandle		mDvpPlaybackTextureHandle;
+	static uint32_t				mBufferAddrAlignment;
+	static uint32_t				mBufferGpuStrideAlignment;
+	static uint32_t				mSemaphoreAddrAlignment;
+	static uint32_t				mSemaphoreAllocSize;
+	static uint32_t				mSemaphorePayloadOffset;
+	static uint32_t				mSemaphorePayloadSize;
+
+	// GPU buffer bound to the target GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD for pinned memory
+	GLuint						mBufferHandle;
+};
+
+#endif