Support for HDR in linear color space

Author: schellingb

Install/UnityCaptureFilter32bit.dll

@@ -106,13 +106,15 @@ class CCaptureStream : CSourceStream, IKsPropertySet, IAMStreamConfig, IAMStream
 		m_pReceiver = new SharedImageMemory();
 		m_iUnscaledBufSize = 0;
 		m_pUnscaledBuf = NULL;
+		m_RGBA16Table = NULL;
 		GetMediaType(0, &m_mt);
 	}
 
 	virtual ~CCaptureStream()
 	{
 		delete m_pReceiver;
-		if (m_pUnscaledBuf) delete[] m_pUnscaledBuf;
+		if (m_pUnscaledBuf) free(m_pUnscaledBuf);
+		if (m_RGBA16Table) free(m_RGBA16Table);
 	}
 
 private:
@@ -165,6 +167,7 @@ class CCaptureStream : CSourceStream, IKsPropertySet, IAMStreamConfig, IAMStream
 		enum EType { JOB_NONE, JOB_RGBA8toRGB8, JOB_RGBA16toRGB8, JOB_RESIZE_LINEAR, JOB_MIRROR_HORIZONTAL } Type;
 		const void *BufIn; void *BufOut;
 		size_t Width, RowStart, RowEnd, RGBAInStride, ResizeToHeight, ResizeFromWidth, ResizeFromHeight;
+		const uint8_t* RGBA16Table;
 
 		inline void Execute()
 		{
@@ -214,9 +217,8 @@ class CCaptureStream : CSourceStream, IKsPropertySet, IAMStreamConfig, IAMStream
 		void RGBA16toRGB8()
 		{
 			//16 bit color downscaling (HDR (16 bit floats) to BGR)
-			float tmpf; uint16_t *tmpp, tmpr, tmpg, tmpb;
-			#define F16toU8(s) ((s) & 0x8000 ? 0 : (*(uint32_t*)&tmpf = ((s) << 13) + 0x38000000, tmpf < 1.0f ? (int)(tmpf * 255.99f) : 255))
-			#define RGBAF16toBGRU8(psrc) (tmpp = (uint16_t*)(psrc), tmpr = tmpp[0], tmpg = tmpp[1], tmpb = tmpp[2], (F16toU8(tmpr)<<16) | (F16toU8(tmpg)<<8) | F16toU8(tmpb))
+			const uint8_t* ttbl = RGBA16Table;
+			#define RGBAF16toBGRU8(psrc) ((ttbl[((uint16_t*)(psrc))[0]]<<16) | (ttbl[((uint16_t*)(psrc))[1]]<<8) | ttbl[((uint16_t*)(psrc))[2]])
 			const uint64_t *src = (const uint64_t*)BufIn + (RowStart * RGBAInStride);
 			uint8_t *dst = (uint8_t*)BufOut + (RowStart * Width * 3), *dstEnd = (uint8_t*)BufOut + (RowEnd * Width * 3);
 			if (RGBAInStride != Width)
@@ -250,7 +252,6 @@ class CCaptureStream : CSourceStream, IKsPropertySet, IAMStreamConfig, IAMStream
 			//For the final pixel we can't use 4 byte uint32_t copy so we call memcpy
 			uint32_t FinalPixel = RGBAF16toBGRU8(src);
 			memcpy(dst, &FinalPixel, 3);
-			#undef F16toU8
 			#undef RGBAF16toBGRU8
 		}
 
@@ -349,7 +350,7 @@ class CCaptureStream : CSourceStream, IKsPropertySet, IAMStreamConfig, IAMStream
 		CCaptureStream* Owner;
 	};
 
-	static void ProcessImage(int InWidth, int InHeight, int InStride, int InRGBABits, SharedImageMemory::EResizeMode ResizeMode, SharedImageMemory::EMirrorMode MirrorMode, uint8_t* InBuf, ProcessState* State)
+	static void ProcessImage(int InWidth, int InHeight, int InStride, SharedImageMemory::EFormat Format, SharedImageMemory::EResizeMode ResizeMode, SharedImageMemory::EMirrorMode MirrorMode, uint8_t* InBuf, ProcessState* State)
 	{
 		const bool NeedResize = (InWidth != State->BufWidth || InHeight != State->BufHeight);
 		if (NeedResize && ResizeMode == SharedImageMemory::RESIZEMODE_DISABLED)
@@ -372,18 +373,34 @@ class CCaptureStream : CSourceStream, IKsPropertySet, IAMStreamConfig, IAMStream
 			DWORD UnscaledBufSize = (InWidth * InHeight * 3);
 			if (State->Owner->m_iUnscaledBufSize != UnscaledBufSize)
 			{
-				if (State->Owner->m_pUnscaledBuf) delete[] State->Owner->m_pUnscaledBuf;
-				State->Owner->m_pUnscaledBuf = new uint8_t[UnscaledBufSize];
+				if (State->Owner->m_pUnscaledBuf) free(State->Owner->m_pUnscaledBuf);
+				State->Owner->m_pUnscaledBuf = (uint8_t*)malloc(UnscaledBufSize);
 				State->Owner->m_iUnscaledBufSize = UnscaledBufSize;
 			}
 		}
 
+		if (Format != SharedImageMemory::FORMAT_UINT8 && (!State->Owner->m_RGBA16Table || State->Owner->m_RGBA16TableFormat != Format))
+		{
+			//Build a 64k table that maps 16 bit float values (either linear SRGB or gamma RGB) to 8 bit color values
+			const bool SRGB = (Format == SharedImageMemory::FORMAT_FP16_LINEAR);
+			uint8_t* RGBA16Table = State->Owner->m_RGBA16Table;
+			if (!RGBA16Table) RGBA16Table = State->Owner->m_RGBA16Table = (uint8_t*)malloc(0xFFFF+1);
+			for(int i = 0; i <= 0xFFFF; i++)
+			{
+				float f;
+				(i & 0x8000 ? f = 0 : (*(uint32_t*)&f = (i << 13) + 0x38000000));
+				if (SRGB) f = (f <= 0.0031308f ? (f * 12.92f) : (powf(f, 1.0f / 2.4f) * 1.055f - 0.055f));
+				RGBA16Table[i] = (f < 1.0f ? (uint8_t)(f * 255.9999f) : 255);
+			}
+			State->Owner->m_RGBA16TableFormat = Format;
+		}
+
 		//Multi-threaded conversion of RGBA source to 8-bit BGR format while also eliminating possible row gaps (when stride != width)
-		UCASSERT(InRGBABits == 8 || InRGBABits == 16);
 		ProcessJob Job;
-		Job.Type = (InRGBABits == 8 ? ProcessJob::JOB_RGBA8toRGB8 : ProcessJob::JOB_RGBA16toRGB8);
+		Job.Type = (Format == SharedImageMemory::FORMAT_UINT8 ? ProcessJob::JOB_RGBA8toRGB8 : ProcessJob::JOB_RGBA16toRGB8);
 		Job.BufIn = InBuf, Job.BufOut = (NeedResize ? State->Owner->m_pUnscaledBuf : State->Buf);
 		Job.Width = InWidth, Job.RowStart = 0, Job.RowEnd = InHeight, Job.RGBAInStride = InStride;
+		Job.RGBA16Table = State->Owner->m_RGBA16Table;
 		State->Owner->m_ProcessWorkers.StartNewJob(Job);
 
 		if (NeedResize)
@@ -666,7 +683,7 @@ class CCaptureStream : CSourceStream, IKsPropertySet, IAMStreamConfig, IAMStream
 		pMediaType->SetTemporalCompression(FALSE);
 		return S_OK;
 	}
-		
+
 	HRESULT OnThreadStartPlay() override
 	{
 		DebugLog("[OnThreadStartPlay] OnThreadStartPlay\n");
@@ -681,7 +698,8 @@ class CCaptureStream : CSourceStream, IKsPropertySet, IAMStreamConfig, IAMStream
 	SharedImageMemory* m_pReceiver;
 	ProcessWorkers m_ProcessWorkers;
 	DWORD m_iUnscaledBufSize;
-	BYTE* m_pUnscaledBuf;
+	uint8_t *m_pUnscaledBuf, *m_RGBA16Table;
+	SharedImageMemory::EFormat m_RGBA16TableFormat;
 
 	//IAMStreamControl
 	HRESULT STDMETHODCALLTYPE StartAt(const REFERENCE_TIME *ptStart, DWORD dwCookie) override { return NOERROR; }

Install/UnityCaptureFilter64bit.dll

@@ -71,7 +71,7 @@ extern "C" __declspec(dllexport) void CaptureDeleteInstance(UnityCaptureInstance
 	delete c;
 }
 
-extern "C" __declspec(dllexport) int CaptureSendTexture(UnityCaptureInstance* c, void* TextureNativePtr, bool UseDoubleBuffering, SharedImageMemory::EResizeMode ResizeMode, SharedImageMemory::EMirrorMode MirrorMode)
+extern "C" __declspec(dllexport) int CaptureSendTexture(UnityCaptureInstance* c, void* TextureNativePtr, bool UseDoubleBuffering, SharedImageMemory::EResizeMode ResizeMode, SharedImageMemory::EMirrorMode MirrorMode, bool IsLinearColorSpace)
 {
 	if (!c || !TextureNativePtr) return RET_ERROR_PARAMETER;
 	if (g_GraphicsDeviceType != kUnityGfxRendererD3D11) return RET_ERROR_UNSUPPORTEDGRAPHICSDEVICE;
@@ -120,18 +120,18 @@ extern "C" __declspec(dllexport) int CaptureSendTexture(UnityCaptureInstance* c,
 	ID3D11Texture2D* ReadTexture  = c->Textures[c->UseDoubleBuffering && !c->AlternativeBuffer ? 1 : 0];
 
 	//Check texture format
-	int RGBABits = 0;
-	if (desc.Format == DXGI_FORMAT_R8G8B8A8_UNORM || desc.Format == DXGI_FORMAT_R8G8B8A8_UNORM_SRGB || desc.Format == DXGI_FORMAT_R8G8B8A8_UINT || desc.Format == DXGI_FORMAT_R8G8B8A8_TYPELESS) RGBABits = 8;
-	if (desc.Format == DXGI_FORMAT_R16G16B16A16_FLOAT || desc.Format == DXGI_FORMAT_R16G16B16A16_TYPELESS) RGBABits = 16;
-	if (!RGBABits) return RET_ERROR_TEXTUREFORMAT;
+	SharedImageMemory::EFormat Format;
+	if      (desc.Format == DXGI_FORMAT_R8G8B8A8_UNORM || desc.Format == DXGI_FORMAT_R8G8B8A8_UNORM_SRGB || desc.Format == DXGI_FORMAT_R8G8B8A8_UINT || desc.Format == DXGI_FORMAT_R8G8B8A8_TYPELESS) Format = SharedImageMemory::FORMAT_UINT8;
+	else if (desc.Format == DXGI_FORMAT_R16G16B16A16_FLOAT || desc.Format == DXGI_FORMAT_R16G16B16A16_TYPELESS) Format = (IsLinearColorSpace ? SharedImageMemory::FORMAT_FP16_LINEAR : SharedImageMemory::FORMAT_FP16_GAMMA);
+	else return RET_ERROR_TEXTUREFORMAT;
 
 	//Copy render texture to texture with CPU access and map the image data to RAM
 	ctx->CopyResource(WriteTexture, d3dtex);
 	D3D11_MAPPED_SUBRESOURCE mapResource;
 	if (FAILED(ctx->Map(ReadTexture, 0, D3D11_MAP_READ, NULL, &mapResource))) return RET_ERROR_READTEXTURE;
 
 	//Push the captured data to the direct show filter
-	SharedImageMemory::ESendResult res = c->Sender->Send(desc.Width, desc.Height, mapResource.RowPitch / (RGBABits / 2), RGBABits, ResizeMode, MirrorMode, (const unsigned char*)mapResource.pData);
+	SharedImageMemory::ESendResult res = c->Sender->Send(desc.Width, desc.Height, mapResource.RowPitch / (Format == SharedImageMemory::FORMAT_UINT8 ? 4 : 8), mapResource.RowPitch * desc.Height, Format, ResizeMode, MirrorMode, (const unsigned char*)mapResource.pData);
 
 	ctx->Unmap(ReadTexture, 0);
 

Source/UnityCaptureFilter.cpp

@@ -41,11 +41,12 @@ struct SharedImageMemory
 		if (m_hSharedFile) CloseHandle(m_hSharedFile);
 	}
 
+	enum EFormat { FORMAT_UINT8, FORMAT_FP16_GAMMA, FORMAT_FP16_LINEAR };
 	enum EResizeMode { RESIZEMODE_DISABLED = 0, RESIZEMODE_LINEAR = 1 };
 	enum EMirrorMode { MIRRORMODE_DISABLED = 0, MIRRORMODE_HORIZONTALLY = 1 };
 	enum EReceiveResult { RECEIVERES_CAPTUREINACTIVE, RECEIVERES_NEWFRAME, RECEIVERES_OLDFRAME };
 
-	typedef void (*ReceiveCallbackFunc)(int width, int height, int stride, int rgbabits, EResizeMode resizemode, EMirrorMode mirrormode, uint8_t* buffer, void* callback_data);
+	typedef void (*ReceiveCallbackFunc)(int width, int height, int stride, EFormat format, EResizeMode resizemode, EMirrorMode mirrormode, uint8_t* buffer, void* callback_data);
 
 	EReceiveResult Receive(ReceiveCallbackFunc callback, void* callback_data)
 	{
@@ -55,7 +56,7 @@ struct SharedImageMemory
 		bool IsNewFrame = (WaitForSingleObject(m_hSentFrameEvent, 200) == WAIT_OBJECT_0);
 
 		WaitForSingleObject(m_hMutex, INFINITE); //lock mutex
-		callback(m_pSharedBuf->width, m_pSharedBuf->height, m_pSharedBuf->stride, m_pSharedBuf->rgbabits, (EResizeMode)m_pSharedBuf->resizemode, (EMirrorMode)m_pSharedBuf->mirrormode, m_pSharedBuf->data, callback_data);
+		callback(m_pSharedBuf->width, m_pSharedBuf->height, m_pSharedBuf->stride, (EFormat)m_pSharedBuf->format, (EResizeMode)m_pSharedBuf->resizemode, (EMirrorMode)m_pSharedBuf->mirrormode, m_pSharedBuf->data, callback_data);
 		ReleaseMutex(m_hMutex); //unlock mutex
 
 		return (IsNewFrame ? RECEIVERES_NEWFRAME : RECEIVERES_OLDFRAME);
@@ -67,19 +68,17 @@ struct SharedImageMemory
 	}
 
 	enum ESendResult { SENDRES_TOOLARGE, SENDRES_WARN_FRAMESKIP, SENDRES_OK };
-	ESendResult Send(int width, int height, int stride, int rgbabits, EResizeMode resizemode, EMirrorMode mirrormode, const uint8_t* buffer)
+	ESendResult Send(int width, int height, int stride, DWORD DataSize, EFormat format, EResizeMode resizemode, EMirrorMode mirrormode, const uint8_t* buffer)
 	{
 		UCASSERT(buffer);
 		UCASSERT(m_pSharedBuf);
-
-		DWORD DataSize = (DWORD)stride * (DWORD)height * 4 * (rgbabits / 8);
 		if (m_pSharedBuf->maxSize < DataSize) return SENDRES_TOOLARGE;
 
 		WaitForSingleObject(m_hMutex, INFINITE); //lock mutex
 		m_pSharedBuf->width = width;
 		m_pSharedBuf->height = height;
 		m_pSharedBuf->stride = stride;
-		m_pSharedBuf->rgbabits = rgbabits;
+		m_pSharedBuf->format = format;
 		m_pSharedBuf->resizemode = resizemode;
 		m_pSharedBuf->mirrormode = mirrormode;
 		memcpy(m_pSharedBuf->data, buffer, DataSize);
@@ -142,7 +141,7 @@ private:
 		int width;
 		int height;
 		int stride;
-		int rgbabits;
+		int format;
 		int resizemode;
 		int mirrormode;
 		uint8_t data[1];

Source/UnityCapturePlugin.cpp

@@ -29,14 +29,14 @@ 3. This notice may not be removed or altered from any source distribution.
 public class UnityCapture : MonoBehaviour
 {
     enum ECaptureSendResult { SUCCESS = 0, WARNING_FRAMESKIP = 1, WARNING_CAPTUREINACTIVE = 2, ERROR_UNSUPPORTEDGRAPHICSDEVICE = 100, ERROR_PARAMETER = 101, ERROR_TOOLARGERESOLUTION = 102, ERROR_TEXTUREFORMAT = 103, ERROR_READTEXTURE = 104 };
-    enum EResizeMode { DisabledShowMessage = 0, LinearResize = 1 }
+    enum EResizeMode { Disabled = 0, LinearResize = 1 }
     enum EMirrorMode { Disabled = 0, MirrorHorizontally = 1 }
     [System.Runtime.InteropServices.DllImport("UnityCapturePlugin")] extern static System.IntPtr CaptureCreateInstance();
     [System.Runtime.InteropServices.DllImport("UnityCapturePlugin")] extern static void CaptureDeleteInstance(System.IntPtr instance);
-    [System.Runtime.InteropServices.DllImport("UnityCapturePlugin")] extern static ECaptureSendResult CaptureSendTexture(System.IntPtr instance, System.IntPtr nativetexture, bool UseDoubleBuffering, EResizeMode ResizeMode, EMirrorMode MirrorMode);
+    [System.Runtime.InteropServices.DllImport("UnityCapturePlugin")] extern static ECaptureSendResult CaptureSendTexture(System.IntPtr instance, System.IntPtr nativetexture, bool UseDoubleBuffering, EResizeMode ResizeMode, EMirrorMode MirrorMode, bool IsLinearColorSpace);
     System.IntPtr CaptureInstance;
 
-    [SerializeField] [Tooltip("Scale image if Unity and capture resolution don't match (can introduce frame dropping, not recommended)")] EResizeMode ResizeMode = EResizeMode.DisabledShowMessage;
+    [SerializeField] [Tooltip("Scale image if Unity and capture resolution don't match (can introduce frame dropping, not recommended)")] EResizeMode ResizeMode = EResizeMode.Disabled;
     [SerializeField] [Tooltip("Mirror captured output image")] EMirrorMode MirrorMode = EMirrorMode.Disabled;
     [SerializeField] [Tooltip("Introduce a frame of latency in favor of frame rate")] bool DoubleBuffering = false;
     [SerializeField] [Tooltip("Check to enable VSync during capturing")] bool EnableVSync = false;
@@ -68,15 +68,15 @@ void OnDestroy()
     void OnRenderImage(RenderTexture source, RenderTexture destination)
     {
         Graphics.Blit(source, destination);
-        switch (CaptureSendTexture(CaptureInstance, source.GetNativeTexturePtr(), DoubleBuffering, ResizeMode, MirrorMode))
+        switch (CaptureSendTexture(CaptureInstance, source.GetNativeTexturePtr(), DoubleBuffering, ResizeMode, MirrorMode, QualitySettings.activeColorSpace == ColorSpace.Linear))
         {
             case ECaptureSendResult.SUCCESS: break;
             case ECaptureSendResult.WARNING_FRAMESKIP:               if (!HideWarnings) Debug.LogWarning("[UnityCapture] Capture device did skip a frame read, capture frame rate will not match render frame rate."); break;
             case ECaptureSendResult.WARNING_CAPTUREINACTIVE:         if (!HideWarnings) Debug.LogWarning("[UnityCapture] Capture device is inactive"); break;
             case ECaptureSendResult.ERROR_UNSUPPORTEDGRAPHICSDEVICE: Debug.LogError("[UnityCapture] Unsupported graphics device (only D3D11 supported)"); break;
             case ECaptureSendResult.ERROR_PARAMETER:                 Debug.LogError("[UnityCapture] Input parameter error"); break;
             case ECaptureSendResult.ERROR_TOOLARGERESOLUTION:        Debug.LogError("[UnityCapture] Render resolution is too large to send to capture device"); break;
-            case ECaptureSendResult.ERROR_TEXTUREFORMAT:             Debug.LogError("[UnityCapture] Render texture format is unsupported (make sure the main camera has 'Allow HDR' set to off)"); break;
+            case ECaptureSendResult.ERROR_TEXTUREFORMAT:             Debug.LogError("[UnityCapture] Render texture format is unsupported (only basic non-HDR (ARGB32) and HDR (FP16/ARGB Half) formats are supported)"); break;
             case ECaptureSendResult.ERROR_READTEXTURE:               Debug.LogError("[UnityCapture] Error while reading texture image data"); break;
         }
     }