// Copyright Epic Games, Inc. All Rights Reserved.

#include "OutputChannel.h"

#include "GPUTextureTransfer.h"
#include "RenderingThread.h"
#include "SSE2MemCpy.h"
#include <stdlib.h>

DECLARE_FLOAT_COUNTER_STAT(TEXT("AJA Audio Delay (s)"), STAT_AjaMediaCapture_Audio_Delay, STATGROUP_Media);

#include "Misc/ScopeLock.h"

static TAutoConsoleVariable<int32> CVarAjaPreRollMethod(
	TEXT("Aja.PrerollMethod"), 0,
	TEXT("Preroll method 0: Legacy method where we preroll 3 empty frames. Preroll method 1: We preroll engine frames as they come in."),
	ECVF_RenderThreadSafe);

static TAutoConsoleVariable<int32> CVarAjaPingPongVersion(
	TEXT("Aja.PingPongVersion"), 0,
	TEXT("Version 0: Legacy, Version 1: Experimental with reduced waiting."),
	ECVF_RenderThreadSafe);

static TAutoConsoleVariable<bool> CVarAjaShowDebugMarkers(
	TEXT("Aja.EnableDebugMarkers"), false,
	TEXT("Enable to let Aja Output Channel trace more information when doing a media capture, such as bookmarks for Vertical Interrupts etc."),
	ECVF_RenderThreadSafe);

namespace AJA
{
	namespace Private
	{
		/* OutputChannel implementation
		*****************************************************************************/
		bool OutputChannel::Initialize(const AJADeviceOptions& InDeviceOption, const AJAInputOutputChannelOptions& InOptions)
		{
			TPromise<void> CompletionPromise;
			Uninitialize(MoveTemp(CompletionPromise));

			ChannelThread.reset(new OutputChannelThread(InDeviceOption, InOptions));

			bool bResult = ChannelThread->CanInitialize();
			if (bResult)
			{
				Device = DeviceCache::GetDevice(InDeviceOption);
				std::shared_ptr<IOChannelInitialize_DeviceCommand> SharedCommand(new IOChannelInitialize_DeviceCommand(Device, ChannelThread));
				InitializeCommand = SharedCommand;
				Device->AddCommand(std::static_pointer_cast<DeviceCommand>(SharedCommand));
			}

			return bResult;
		}

		void OutputChannel::Uninitialize(TPromise<void> CompletionPromise)
		{
			if (ChannelThread)
			{
				if (Device)
				{
					// We have to make sure the format is cleared upon uninitialization in case an initialization call happens soon after.
					Device->ClearFormat();
				}

				std::shared_ptr<IOChannelInitialize_DeviceCommand> SharedCommand = InitializeCommand.lock();
				if (SharedCommand && Device)
				{
					Device->RemoveCommand(std::static_pointer_cast<DeviceCommand>(SharedCommand));
				}

				ChannelThread->Uninitialize(); // delete is done in IOChannelUninitialize_DeviceCommand completed

				if (Device)
				{
					std::shared_ptr<IOChannelUninitialize_DeviceCommand> UninitializeCommand;
					UninitializeCommand.reset(new IOChannelUninitialize_DeviceCommand(Device, ChannelThread, MoveTemp(CompletionPromise)));
					Device->AddCommand(std::static_pointer_cast<DeviceCommand>(UninitializeCommand));
				}
				else
				{
					// No need to wait in this case.
					CompletionPromise.SetValue();
				}
			}
			else
			{
				CompletionPromise.SetValue();
			}

			InitializeCommand.reset();
			ChannelThread.reset();
			Device.reset();
		}

		bool OutputChannel::SetAncillaryFrameData(const AJAOutputFrameBufferData& InFrameData, uint8_t* InAncillaryBuffer, uint32_t InAncillaryBufferSize)
		{
			if (ChannelThread)
			{
				return ChannelThread->SetAncillaryFrameData(InFrameData, InAncillaryBuffer, InAncillaryBufferSize);
			}
			return false;
		}

		bool OutputChannel::SetAudioFrameData(const AJAOutputFrameBufferData& InFrameData, uint8_t* InAudioBuffer, uint32_t InAudioBufferSize)
		{
			if (ChannelThread)
			{
				return ChannelThread->SetAudioFrameData(InFrameData, InAudioBuffer, InAudioBufferSize);
			}
			return false;
		}

		bool OutputChannel::SetVideoFrameData(const AJAOutputFrameBufferData& InFrameData, uint8_t* InVideoBuffer, uint32_t InVideoBufferSize)
		{
			if (ChannelThread)
			{
				return ChannelThread->SetVideoFrameData(InFrameData, InVideoBuffer, InVideoBufferSize);
			}
			return false;
		}

		bool OutputChannel::DMAWriteAudio(const uint8_t* InAudioBufer, int32_t InAudioBufferSize)
		{
			if (ChannelThread)
			{
				return ChannelThread->DMAWriteAudio(InAudioBufer, InAudioBufferSize);
			}
			return false;
		}

		bool OutputChannel::SetVideoFrameData(const AJAOutputFrameBufferData& InFrameData, FRHITexture* RHITexture)
		{
			if (ChannelThread)
			{
				return ChannelThread->SetVideoFrameData(InFrameData, RHITexture);
			}
			return false;
		}

		bool OutputChannel::ShouldCaptureThisFrame(::FTimecode Timeocode, uint32 SourceFrameNumber)
		{
			if (ChannelThread)
			{
				return ChannelThread->ShouldCaptureThisFrame(Timeocode, SourceFrameNumber);
			}
			return false;
		}

		bool OutputChannel::GetOutputDimension(uint32_t& OutWidth, uint32_t& OutHeight) const
		{
			NTV2FormatDescriptor FormatDescriptor = ChannelThread->FormatDescriptor;
			bool bResult = FormatDescriptor.IsValid();
			if (bResult)
			{
				OutWidth = ChannelThread->FormatDescriptor.GetRasterWidth();
				OutHeight = ChannelThread->FormatDescriptor.GetRasterHeight();
			}
			return bResult;
		}

		int32_t OutputChannel::GetNumAudioSamplesPerFrame(const AJAOutputFrameBufferData& InFrameData) const
		{
			if (ChannelThread && Device && Device->GetCard())
			{
				NTV2FrameRate FrameRate = NTV2_FRAMERATE_INVALID;
				AJA_CHECK(Device->GetCard()->GetFrameRate(FrameRate, ChannelThread->Channel));

				// @todo: Check if 1080p60, 1080p5994 or 1080p50 and pass SMTPE 372M flag
				return ::GetAudioSamplesPerFrame(FrameRate, NTV2_AUDIO_48K, InFrameData.FrameIdentifier);
			}

			return 0;
		}

		/* Frame implementation
		*****************************************************************************/
		OutputChannelThread::Frame::Frame()
			: AncBuffer(nullptr)
			, AncF2Buffer(nullptr)
			, AudioBuffer(nullptr)
			, VideoBuffer(nullptr)
		{
			Clear();
		}

		OutputChannelThread::Frame::~Frame()
		{
			if (AncBuffer)
			{
				AJAMemory::FreeAligned(AncBuffer);
			}
			if (AncF2Buffer)
			{
				AJAMemory::FreeAligned(AncF2Buffer);
			}
			if (AudioBuffer)
			{
				AJAMemory::FreeAligned(AudioBuffer);
			}
			if (VideoBuffer)
			{
				AJAMemory::FreeAligned(VideoBuffer);
			}
		}

		void OutputChannelThread::Frame::Clear()
		{
			CopiedAncBufferSize = 0;
			CopiedAncF2BufferSize = 0;
			CopiedAudioBufferSize = 0;
			CopiedVideoBufferSize = 0;
			FrameIdentifier = AJAOutputFrameBufferData::InvalidFrameIdentifier;
			FrameIdentifierF2 = AJAOutputFrameBufferData::InvalidFrameIdentifier;
			bAncLineFilled = false;
			bAncF2LineFilled = false;
			bAudioLineFilled = false;
			bVideoLineFilled = false;
			bVideoF2LineFilled = false;
		}

		/* OutputChannelThread implementation
		*****************************************************************************/
		OutputChannelThread::OutputChannelThread(const AJADeviceOptions& InDevice, const AJAInputOutputChannelOptions& InOptions)
			: Super(InDevice, InOptions)
			, PingPongDropCount(0)
			, LostFrameCounter(0)
			, bIsSSE2Available(IsSSE2Available())
			, bIsFieldAEven(true)
			, bIsFirstFetch(true)
			, bInterlacedTest_ExpectFirstLineToBeWhite(false)
			, InterlacedTest_FrameCounter(0)
		{
			if (FGPUTextureTransferModule::Get().IsEnabled() && FGPUTextureTransferModule::Get().IsInitialized())
			{
				TextureTransfer = FGPUTextureTransferModule::Get().GetTextureTransfer();
			}

			if (InOptions.OutputNumberOfBuffers > 0)
			{
				AllFrames.reserve(InOptions.OutputNumberOfBuffers);
				for (uint32_t Index = 0; Index < InOptions.OutputNumberOfBuffers; ++Index)
				{
					Frame* NewFrame = new Frame();
					AllFrames.push_back(NewFrame);
					FrameReadyToWrite.push_back(NewFrame);
				}
			}

			FrameAvailableEvent = FPlatformProcess::GetSynchEventFromPool();
			bOutputWithReduceWaiting = CVarAjaPingPongVersion.GetValueOnAnyThread() == 1;
			bTraceDebugMarkers = CVarAjaShowDebugMarkers.GetValueOnAnyThread();
		}

		OutputChannelThread::~OutputChannelThread()
		{
			FPlatformProcess::ReturnSynchEventToPool(FrameAvailableEvent);
		}

		bool OutputChannelThread::CanInitialize() const
		{
			return Super::CanInitialize() && AllFrames.size() >= 1;
		}

		void OutputChannelThread::Uninitialize()
		{
			ChannelThreadBase::Uninitialize();

			if (InterruptEventHandle.IsValid())
			{
				Device->ClearOnInterruptEvent(Channel, InterruptEventHandle);
			}

			if (TextureTransfer && GetOptions().bUseGPUDMA)
			{
				std::vector<uint8_t*> BuffersToClear;
				BuffersToClear.reserve(AllFrames.size());
				std::transform(AllFrames.cbegin(), AllFrames.cend(), std::back_inserter(BuffersToClear), [](Frame* InFrame) { return InFrame->VideoBuffer; });

				// Make sure to unregister those buffers on the render thread to avoid a crash in the GPUDirect SDK.
				ENQUEUE_RENDER_COMMAND(ClearGPUDirectBuffers)(
				[BuffersToClear = std::move(BuffersToClear), TextureTransferPtr = TextureTransfer](FRHICommandListImmediate& RHICmdList)
				{
					if (TextureTransferPtr)
					{
						for (uint8* BufferAddress : BuffersToClear)
						{
							TextureTransferPtr->UnregisterBuffer(BufferAddress);
						}
					}
				});
			}
		}

		void OutputChannelThread::DeviceThread_Destroy(DeviceConnection::CommandList& InCommandList)
		{
			for (Frame* IttFrame : AllFrames)
			{
				delete IttFrame;
			}
			AllFrames.clear();
			Super::DeviceThread_Destroy(InCommandList);
		}

		// For Progressive and PSF. Find the frame that have the same identifier. (the image may have been given but the anc and audio is incoming)
		// For Interlaced, there is 2 options. Use Timecode to identify which is the odd and even field.
		OutputChannelThread::Frame* OutputChannelThread::FetchAvailableWritingFrame(const AJAOutputFrameBufferData& InFrameData)
		{
			const bool bIsProgressive = ::IsProgressivePicture(VideoFormat) || Options.bOutputInterlaceAsProgressive;

			Frame* AvailableWritingFrame = nullptr;
			{
				AJAAutoLock AutoLock(&FrameLock);

				bool bInitFrameIdentifier = false;
				{
					// Find a matching frame identifier
					for (auto Begin = FrameReadyToWrite.begin(); Begin != FrameReadyToWrite.end(); ++Begin)
					{
						Frame* FrameItt = *Begin;
						if (bIsProgressive && FrameItt->FrameIdentifier == InFrameData.FrameIdentifier)
						{
							AvailableWritingFrame = FrameItt;
							break;
						}
						if (!bIsProgressive && FrameItt->FrameIdentifierF2 == InFrameData.FrameIdentifier)
						{
							AvailableWritingFrame = FrameItt;
							break;
						}
					}
				}

				if (AvailableWritingFrame == nullptr && !bIsProgressive)
				{
					// Find a frame where the even frame is filled but not the odd frame and have the same timecode (only in interlaced)
					for (auto Begin = FrameReadyToWrite.begin(); Begin != FrameReadyToWrite.end(); ++Begin)
					{
						Frame* FrameItt = *Begin;
						if (FrameItt->FrameIdentifier != AJAOutputFrameBufferData::InvalidFrameIdentifier && FrameItt->FrameIdentifierF2 == AJAOutputFrameBufferData::InvalidFrameIdentifier)
						{
							if (FrameItt->FrameIdentifier + 1 == InFrameData.FrameIdentifier)
							{
								if (GetOptions().bOutputInterlacedFieldsTimecodeNeedToMatch)
								{
									if (FrameItt->Timecode == InFrameData.Timecode)
									{
										AvailableWritingFrame = FrameItt;
										bInitFrameIdentifier = true;
										break;
									}
								}
								else
								{
									AvailableWritingFrame = FrameItt;
									bInitFrameIdentifier = true;
									break;
								}
							}
						}
					}
				}

				// Find a new empty frames

				if (AvailableWritingFrame == nullptr && !bIsProgressive && !GetOptions().bOutputInterlacedFieldsTimecodeNeedToMatch)
				{
					if (!GetOptions().bOutputInterlaceOnEvenFrames)
					{
						if (!InFrameData.bEvenFrame)
						{
							// If the incoming frame is interlaced and we didn't find the correspondent even field
							// do not create a new field. Drop it.
							++LostFrameCounter;
							return nullptr;
						}
					}
				}

				if (AvailableWritingFrame == nullptr)
				{
					// Find an empty frame
					for (auto Begin = FrameReadyToWrite.begin(); Begin != FrameReadyToWrite.end(); ++Begin)
					{
						Frame* FrameItt = *Begin;
						if (FrameItt->FrameIdentifier == AJAOutputFrameBufferData::InvalidFrameIdentifier)
						{
							AJA_CHECK(FrameItt->FrameIdentifierF2 == AJAOutputFrameBufferData::InvalidFrameIdentifier);
							AvailableWritingFrame = FrameItt;
							bInitFrameIdentifier = true;

							break;
						}
					}
				}

				if (AvailableWritingFrame == nullptr)
				{
					// Take the oldest frame not yet written
					if (FrameReadyToWrite.size() > 0)
					{
						AvailableWritingFrame = FrameReadyToWrite[0];
						uint32_t OldestNumber = AvailableWritingFrame->FrameIdentifier;

						auto Begin = FrameReadyToWrite.begin();
						++Begin;
						for (; Begin != FrameReadyToWrite.end(); ++Begin)
						{
							Frame* FrameItt = *Begin;
							if (FrameItt->FrameIdentifier > OldestNumber)
							{
								AvailableWritingFrame = FrameItt;
								OldestNumber = FrameItt->FrameIdentifier;
							}
						}

						// This is not thread-safe with but FetchAvailableWritingFrame & IsFrameReadyToBeRead are both in inside a lock.
						//So even if we are currently writing in a buffer, it will be cleared and will not be available to be added to the read list.
						AvailableWritingFrame->Clear();
						bInitFrameIdentifier = true;

						++LostFrameCounter;
					}
				}

				//if (AvailableWritingFrame == nullptr)
				//{
				//	// Take the newest frame that is ready
				//	if (FrameReadyToRead.size() > 0)
				//	{
				//		AvailableWritingFrame = FrameReadyToRead[0];
				//		uint32_t NewestNumber = AvailableWritingFrame->FrameIdentifier;
				//		auto NewestItt = std::begin(FrameReadyToRead);

				//		auto Begin = NewestItt;
				//		++Begin;
				//		auto End = std::end(FrameReadyToRead);
				//		for (; Begin != End; ++Begin)
				//		{
				//			Frame* FrameItt = *Begin;
				//			if (FrameItt->FrameIdentifier < NewestNumber)
				//			{
				//				AvailableWritingFrame = FrameItt;
				//				NewestNumber = FrameItt->FrameIdentifier;
				//				NewestItt = Begin;
				//			}
				//		}

				//		// This is not thread-safe (see above)
				//		AvailableWritingFrame->Clear();
				//		bInitFrameIdentifier = true;

				//		FrameReadyToWrite.push_back(AvailableWritingFrame);
				//		FrameReadyToRead.erase(NewestItt);
				//		++LostFrameCounter;
				//	}
				//}

				if (AvailableWritingFrame && bInitFrameIdentifier)
				{
					if (AvailableWritingFrame->FrameIdentifier == AJAOutputFrameBufferData::InvalidFrameIdentifier)
					{
						AvailableWritingFrame->FrameIdentifier = InFrameData.FrameIdentifier;
						AvailableWritingFrame->Timecode = InFrameData.Timecode;
						if (bIsProgressive)
						{
							AvailableWritingFrame->FrameIdentifierF2 = InFrameData.FrameIdentifier;
						}
					}
					else
					{
						AvailableWritingFrame->FrameIdentifierF2 = InFrameData.FrameIdentifier;
						AvailableWritingFrame->Timecode2 = InFrameData.Timecode;
					}
				}
			}

			return AvailableWritingFrame;
		}

		OutputChannelThread::Frame* OutputChannelThread::Thread_FetchAvailableReadingFrame()
		{
			Frame* AvailableReadingFrame = nullptr;

			AJAAutoLock AutoLock(&FrameLock);
			if (!FrameReadyToRead.empty())
			{
				// Take the oldest frame
				AvailableReadingFrame = FrameReadyToRead[0];
				uint32_t OldestNumber = AvailableReadingFrame->FrameIdentifier;
				auto OldestItt = std::begin(FrameReadyToRead);

				auto Begin = OldestItt;
				++Begin;
				auto End = std::end(FrameReadyToRead);
				for (; Begin != End; ++Begin)
				{
					Frame* FrameItt = *Begin;
					if (FrameItt->FrameIdentifier < OldestNumber)
					{
						AvailableReadingFrame = FrameItt;
						OldestNumber = FrameItt->FrameIdentifier;
						OldestItt = Begin;
					}
				}

				FrameReadyToRead.erase(OldestItt);
			}

			return AvailableReadingFrame;
		}

		bool OutputChannelThread::IsFrameReadyToBeRead(Frame* InFrame)
		{
			if (InFrame->FrameIdentifier == AJAOutputFrameBufferData::InvalidFrameIdentifier)
			{
				InFrame->Clear();
				return false;
			}
			if (UseAncillary() && (!InFrame->bAncLineFilled || InFrame->CopiedAncBufferSize == 0))
			{
				return false;
			}
			if (UseAncillaryField2() && (!InFrame->bAncF2LineFilled || InFrame->CopiedAncF2BufferSize == 0))
			{
				return false;
			}
			// When writing audio directly, no need to check if the audio line is filled since we don't use it.
			if (UseAudio() && !InFrame->bAudioLineFilled && !GetOptions().bDirectlyWriteAudio)
			{
				return false;
			}
			if (UseVideo() && (!InFrame->bVideoF2LineFilled || !InFrame->bVideoLineFilled || InFrame->CopiedVideoBufferSize == 0))
			{
				return false;
			}
			return true;
		}

		void OutputChannelThread::PushWhenFrameReady(Frame* InFrame)
		{
			AJAAutoLock AutoLock(&FrameLock);
			if (IsFrameReadyToBeRead(InFrame))
			{
				auto FoundItt = std::find(std::begin(FrameReadyToWrite), std::end(FrameReadyToWrite), InFrame);
				if (FoundItt != std::end(FrameReadyToWrite))
				{
					FrameReadyToWrite.erase(FoundItt);
					FrameReadyToRead.push_back(InFrame);
					FrameAvailableEvent->Trigger();
				}
			}
		}

		bool OutputChannelThread::SetAncillaryFrameData(const AJAOutputFrameBufferData& InFrameData, uint8_t* InAncillaryBuffer, uint32_t InAncillaryBufferSize)
		{
			const bool bIsProgressive = ::IsProgressivePicture(VideoFormat) || Options.bOutputInterlaceAsProgressive;

			if (!UseAncillary())
			{
				return false;
			}

			if (InAncillaryBuffer == nullptr || InAncillaryBufferSize > AncBufferSize || (!bIsProgressive && InAncillaryBufferSize > AncF2BufferSize))
			{
				UE_LOG(LogAjaCore, Error, TEXT("SetFrameData: Can't set the ancillary. The buffer is invalid or the buffer size is not the same as the AJA for output channel %d on device %S.\n"), uint32_t(Channel) + 1, GetDevice().GetDisplayName().c_str());
				return false;
			}

			Frame* AvailableWritingFrame = FetchAvailableWritingFrame(InFrameData);
			if (!AvailableWritingFrame)
			{
				return false;
			}

#if AJA_TEST_MEMORY_BUFFER
			AJA_CHECK(AvailableWritingFrame->AncBuffer[AncBufferSize] == AJA_TEST_MEMORY_END_TAG);
			AJA_CHECK(AncF2BufferSize == 0 || AvailableWritingFrame->AncF2Buffer[AncF2BufferSize] == AJA_TEST_MEMORY_END_TAG);
#endif

			if (bIsProgressive)
			{
				memcpy(AvailableWritingFrame->AncBuffer, InAncillaryBuffer, InAncillaryBufferSize);
				AvailableWritingFrame->bAncLineFilled = true;
				AvailableWritingFrame->bAncF2LineFilled = true;
				AvailableWritingFrame->CopiedAncBufferSize = InAncillaryBufferSize;
			}
			else
			{
				bool bField1 = AvailableWritingFrame->FrameIdentifier == InFrameData.FrameIdentifier;
				if (bField1)
				{
					memcpy(AvailableWritingFrame->AncBuffer, InAncillaryBuffer, InAncillaryBufferSize);
					AvailableWritingFrame->bAncLineFilled = true;
					AvailableWritingFrame->CopiedAncBufferSize = InAncillaryBufferSize;
				}
				else
				{
					memcpy(AvailableWritingFrame->AncF2Buffer, InAncillaryBuffer, InAncillaryBufferSize);
					AvailableWritingFrame->bAncF2LineFilled = true;
					AvailableWritingFrame->CopiedAncF2BufferSize = InAncillaryBufferSize;
				}
			}

#if AJA_TEST_MEMORY_BUFFER
			AJA_CHECK(AvailableWritingFrame->AncBuffer[AncBufferSize] == AJA_TEST_MEMORY_END_TAG);
			AJA_CHECK(AncF2BufferSize == 0 || AvailableWritingFrame->AncF2Buffer[AncF2BufferSize] == AJA_TEST_MEMORY_END_TAG);
#endif

			PushWhenFrameReady(AvailableWritingFrame);

			return true;
		}

		bool OutputChannelThread::SetAudioFrameData(const AJAOutputFrameBufferData& InFrameData, uint8_t* InAudioBuffer, uint32_t InAudioBufferSize)
		{
			if (!UseAudio())
			{
				return false;
			}
			
			if (InAudioBufferSize > AudioBufferSize)
			{
				UE_LOG(LogAjaCore, Error, TEXT("SetAudioFrameData: Can't set the audio. The buffer size is not the same as the AJA Audio Format for output channel %d on device %S.\n"), uint32_t(Channel) + 1, GetDevice().GetDisplayName().c_str());
				return false;
			}

			Frame* AvailableWritingFrame = FetchAvailableWritingFrame(InFrameData);
			if (!AvailableWritingFrame)
			{
				return false;
			}

#if AJA_TEST_MEMORY_BUFFER
			AJA_CHECK(AvailableWritingFrame->Audio[AudioBufferSize] == AJA_TEST_MEMORY_END_TAG);
#endif

			if (InAudioBuffer && InAudioBufferSize != 0 && ensure(AvailableWritingFrame->AudioBuffer))
			{
				memcpy(AvailableWritingFrame->AudioBuffer, InAudioBuffer, InAudioBufferSize);
			}

			AvailableWritingFrame->bAudioLineFilled = true;
			AvailableWritingFrame->CopiedAudioBufferSize = InAudioBufferSize;
			PushWhenFrameReady(AvailableWritingFrame);

			return true;
		}

		bool OutputChannelThread::SetVideoFrameData(const AJAOutputFrameBufferData& InFrameData, uint8_t* InVideoBuffer, uint32_t InVideoBufferSize)
		{
			const bool bIsProgressive = ::IsProgressivePicture(VideoFormat) || Options.bOutputInterlaceAsProgressive;

			if (!UseVideo())
			{
				return false;
			}

			if (InVideoBuffer == nullptr || InVideoBufferSize > VideoBufferSize)
			{
				UE_LOG(LogAjaCore, Error, TEXT("SetVideoFrameData: Can't set the video. The buffer is invalid or the buffer size is not the same as the AJA Video Format for output channel %d on device %S.\n"), uint32_t(Channel) + 1, GetDevice().GetDisplayName().c_str());
				return false;
			}

			Frame* AvailableWritingFrame = FetchAvailableWritingFrame(InFrameData);
			if (!AvailableWritingFrame)
			{
				if (bTraceDebugMarkers)
				{
					TRACE_BOOKMARK(TEXT("Aja: Dropped frame %d"), InFrameData.FrameIdentifier);
				}
				return false;
			}

			ULWord Height = FormatDescriptor.GetRasterHeight();
			ULWord Stride = FormatDescriptor.GetBytesPerRow();
			AJA_CHECK(InVideoBufferSize <= Stride*Height);

#if AJA_TEST_MEMORY_BUFFER
			AJA_CHECK(AvailableWritingFrame->VideoBuffer[VideoBufferSize] == AJA_TEST_MEMORY_END_TAG);
#endif

			if (bIsProgressive)
			{
				// Make sure SSE2 is supported and everything is correctly aligned otherwise fall back on regular memcpy
				if (bIsSSE2Available && IsCorrectlyAlignedForSSE2MemCpy(AvailableWritingFrame->VideoBuffer, InVideoBuffer, InVideoBufferSize))
				{
					SSE2MemCpy(AvailableWritingFrame->VideoBuffer, InVideoBuffer, InVideoBufferSize);
				}
				else
				{
					memcpy(AvailableWritingFrame->VideoBuffer, InVideoBuffer, InVideoBufferSize);
				}
				AvailableWritingFrame->bVideoLineFilled = true;
				AvailableWritingFrame->bVideoF2LineFilled = true;
			}
			else
			{
				// only write the even or odd frame
				bool bField1 = AvailableWritingFrame->FrameIdentifier == InFrameData.FrameIdentifier;
				for (ULWord IndexY = bField1 ? 0 : 1; IndexY < Height; IndexY += 2)
				{
					memcpy(AvailableWritingFrame->VideoBuffer + (Stride*IndexY), InVideoBuffer + (Stride*IndexY), Stride);
				}
				if (bField1)
				{
					AvailableWritingFrame->bVideoLineFilled = true;
				}
				else
				{
					AvailableWritingFrame->bVideoF2LineFilled = true;
				}
			}

#if AJA_TEST_MEMORY_BUFFER
			AJA_CHECK(AvailableWritingFrame->VideoBuffer[VideoBufferSize] == AJA_TEST_MEMORY_END_TAG);
#endif

			AvailableWritingFrame->CopiedVideoBufferSize = InVideoBufferSize;

			PushWhenFrameReady(AvailableWritingFrame);

			if (bTraceDebugMarkers)
			{
				TRACE_BOOKMARK(TEXT("Aja: Pushed [%d] (Frame %d)"), InFrameData.FrameIdentifier, InFrameData.Timecode.Frames);
			}

			return true;
		}

		bool OutputChannelThread::SetVideoFrameData(const AJAOutputFrameBufferData& InFrameData, FRHITexture* RHITexture)
		{
			const bool bIsProgressive = ::IsProgressivePicture(VideoFormat) || Options.bOutputInterlaceAsProgressive;

			if (!bIsProgressive)
			{
				UE_LOG(LogAjaCore, Error, TEXT("SetVideoFrameData: Can't set the video, GPUTextureTransfer is not supported with interlaced video for output channel %d on device %S.\n"), uint32_t(Channel) + 1, GetDevice().GetDisplayName().c_str());
				return false;
			}

			if (!UseVideo())
			{
				return false;
			}

			if (!RHITexture)
			{
				UE_LOG(LogAjaCore, Error, TEXT("SetVideoFrameData: Can't set the video. The RHI texture is invalid for output channel %d on device %S.\n"), uint32_t(Channel) + 1, GetDevice().GetDisplayName().c_str());
				return false;
			}

			if (!TextureTransfer || !GetOptions().bUseGPUDMA)
			{
				UE_LOG(LogAjaCore, Error, TEXT("SetVideoFrameData: Can't set the video. GPU DMA was not setup correctly for output channel %d on device %S.\n"), uint32_t(Channel) + 1, GetDevice().GetDisplayName().c_str());
				return false;
			}


			Frame* AvailableWritingFrame = FetchAvailableWritingFrame(InFrameData);
			if (!AvailableWritingFrame)
			{
				return false;
			}
			 
			// Todo jroy: Verify if Width needs to be fixed, by using the GPUTextureTransfer register struct directly, same for pixel format.
			const ULWord Stride = FormatDescriptor.GetBytesPerRow();
			ULWord Width = Stride / 4;

			if (GetOptions().PixelFormat == EPixelFormat::PF_10BIT_YCBCR)
			{
				// YUV210 has a different stride.
				Width /= 4;
			}

			const ULWord Height = FormatDescriptor.GetRasterHeight();

			if (!bDMABuffersRegistered)
			{
				for (Frame* IttFrame : AllFrames)
				{
					UE::GPUTextureTransfer::FRegisterDMABufferArgs Args;
					Args.Height = Height;
					Args.Width = Width;
					Args.Stride = Stride;
					Args.Buffer = IttFrame->VideoBuffer;

					if (GetOptions().PixelFormat == EPixelFormat::PF_8BIT_YCBCR || GetOptions().PixelFormat == EPixelFormat::PF_8BIT_ARGB
						|| GetOptions().PixelFormat == EPixelFormat::PF_10BIT_RGB) // 10 Bit RGB should be considered as 8 bit as far as GPUDirect is concerned.
					{

						Args.PixelFormat = UE::GPUTextureTransfer::EPixelFormat::PF_8Bit;
					}
					else
					{
						Args.PixelFormat = UE::GPUTextureTransfer::EPixelFormat::PF_10Bit;
					}

					TextureTransfer->RegisterBuffer(Args);
				}

				bDMABuffersRegistered = true;
			}

			AvailableWritingFrame->bVideoLineFilled = true;
			AvailableWritingFrame->bVideoF2LineFilled = true;

			const UE::GPUTextureTransfer::ETransferDirection Direction = UE::GPUTextureTransfer::ETransferDirection::GPU_TO_CPU;
			TextureTransfer->TransferTexture(AvailableWritingFrame->VideoBuffer, (FRHITexture*)RHITexture, Direction);

			AvailableWritingFrame->CopiedVideoBufferSize = VideoBufferSize;
			PushWhenFrameReady(AvailableWritingFrame);

			return true;
		}

		bool OutputChannelThread::ShouldCaptureThisFrame(::FTimecode Timecode, uint32 SourceFrameNumber)
		{
			const bool bInterlace = !::IsProgressivePicture(VideoFormat) && !Options.bOutputInterlaceAsProgressive;

			if (bInterlace && Timecode.Frames % 2 != 0 && GetOptions().bOutputInterlaceOnEvenFrames)
			{
				// Odd frame should always have a matching frame.
				// Find a frame where the even frame is filled but not the odd frame.
				for (Frame* Frame : FrameReadyToWrite)
				{
					if (Frame->FrameIdentifier != AJAOutputFrameBufferData::InvalidFrameIdentifier && Frame->FrameIdentifierF2 == AJAOutputFrameBufferData::InvalidFrameIdentifier)
					{
						if (Frame->FrameIdentifier + 1 == SourceFrameNumber)
						{
							return true;
						}
					}
				}

				if (!FrameReadyToWrite.size())
				{
					UE_LOG(LogAjaCore, Verbose, TEXT("Skipping output because no writable frame is available."));
				}
				else
				{
					for (Frame* Frame : FrameReadyToWrite)
					{
						UE_LOG(LogAjaCore, VeryVerbose, TEXT("\t F1: %d, F2: %d"), Frame->FrameIdentifier, Frame->FrameIdentifierF2);
					}
				}

				// Dont output an interlace frame starting with an odd frame.
				return false;
			}

			return true;
		}

		bool OutputChannelThread::DeviceThread_ConfigureAnc(DeviceConnection::CommandList& InCommandList)
		{
			bool bResult = Super::DeviceThread_ConfigureAnc(InCommandList);

			if (AncBufferSize > 0 || AncF2BufferSize > 0)
			{
				AJAAutoLock AutoLock(&FrameLock);
				for (Frame* IttFrame : AllFrames)
				{
					AJA_CHECK(IttFrame->AncBuffer == nullptr);
					AJA_CHECK(IttFrame->AncF2Buffer == nullptr);

					if (AncBufferSize > 0)
					{
						AJA_CHECK(UseAncillary());
#if AJA_TEST_MEMORY_BUFFER
						IttFrame->AncBuffer = (uint8_t*)AJAMemory::AllocateAligned(AncBufferSize + 1, AJA_PAGE_SIZE);
						IttFrame->AncBuffer[AncBufferSize] = AJA_TEST_MEMORY_END_TAG;
#else
						IttFrame->AncBuffer = (uint8_t*)AJAMemory::AllocateAligned(AncBufferSize, AJA_PAGE_SIZE);
#endif
					}

					if (AncF2BufferSize > 0)
					{
						AJA_CHECK(UseAncillaryField2());
#if AJA_TEST_MEMORY_BUFFER
						IttFrame->AncF2Buffer = (uint8_t*)AJAMemory::AllocateAligned(AncF2BufferSize + 1, AJA_PAGE_SIZE);
						IttFrame->AncF2Buffer[AncF2BufferSize] = AJA_TEST_MEMORY_END_TAG;
#else
						IttFrame->AncF2Buffer = (uint8_t*)AJAMemory::AllocateAligned(AncF2BufferSize, AJA_PAGE_SIZE);
#endif
					}
				}
			}
			return bResult;
		}

		bool OutputChannelThread::DeviceThread_ConfigureAudio(DeviceConnection::CommandList& InCommandList)
		{
			bool bResult = Super::DeviceThread_ConfigureAudio(InCommandList);
			if(bResult && UseAudio())
			{
				NTV2FrameRate CardFrameRate = NTV2_FRAMERATE_INVALID;
				AJA_CHECK(Device->GetCard()->GetFrameRate(CardFrameRate, Channel));
				NumSamplesPerFrame = ::GetAudioSamplesPerFrame(CardFrameRate, NTV2_AUDIO_48K);

				if (ensureMsgf(AudioBufferSize > 0, TEXT("Audio could not be initialized.")))
				{
					if (!GetOptions().bDirectlyWriteAudio)
					{
						AJAAutoLock AutoLock(&FrameLock);
						for (Frame* IttFrame : AllFrames)
						{
							AJA_CHECK(IttFrame->AudioBuffer == nullptr);
		#if AJA_TEST_MEMORY_BUFFER
							IttFrame->AudioBuffer = (uint8_t*)AJAMemory::AllocateAligned(AudioBufferSize + 1, AJA_PAGE_SIZE);
							IttFrame->AudioBuffer[AudioBufferSize] = AJA_TEST_MEMORY_END_TAG;
		#else
							IttFrame->AudioBuffer = (uint8_t*)AJAMemory::AllocateAligned(AudioBufferSize, AJA_PAGE_SIZE);
		#endif
							memset(IttFrame->AudioBuffer, 0, AudioBufferSize);
						}
					}

					if (GetOptions().bUseAutoCirculating)
					{
						bResult &= GetDevice().StartAudioOutput(AudioSystem);
						if (bResult == false)
						{
							UE_LOG(LogAjaCore, Error, TEXT("ConfigureAudio: Could not start audio output for audio system %d for channel %d on device %S."), uint32_t(AudioSystem), uint32_t(Channel) + 1, GetDevice().GetDisplayName().c_str());
						}
					}
				}
			}

			return bResult;
		}

		bool OutputChannelThread::DeviceThread_ConfigureVideo(DeviceConnection::CommandList& InCommandList)
		{
			bool bResult = Super::DeviceThread_ConfigureVideo(InCommandList);

			FrameRate = Helpers::ConvertToUnrealFramerate(DesiredVideoFormat);

			if (VideoBufferSize > 0)
			{
				AJAAutoLock AutoLock(&FrameLock);
				for (Frame* IttFrame : AllFrames)
				{
					AJA_CHECK(IttFrame->VideoBuffer == nullptr);
#if AJA_TEST_MEMORY_BUFFER
					IttFrame->VideoBuffer = (uint8_t*)AJAMemory::AllocateAligned(VideoBufferSize + 1, AJA_PAGE_SIZE);
					IttFrame->VideoBuffer[VideoBufferSize] = AJA_TEST_MEMORY_END_TAG;
#else
					IttFrame->VideoBuffer = (uint8_t*)AJAMemory::AllocateAligned(VideoBufferSize, AJA_PAGE_SIZE);
#endif
				}
			}

			return bResult;
		}

		void OutputChannelThread::Thread_PushAvailableReadingFrame(Frame* InCurrentReadingFrame)
		{
			// reset the buffer size for the next write
			AJAAutoLock AutoLock(&FrameLock);
			InCurrentReadingFrame->Clear();
			FrameReadyToWrite.push_back(InCurrentReadingFrame);
		}

		bool OutputChannelThread::DeviceThread_ConfigureAutoCirculate(DeviceConnection::CommandList& InCommandList)
		{
			const int32_t NumberOfLinkChannel = Helpers::GetNumberOfLinkChannel(GetOptions().TransportType);
			for (int32_t ChannelIndex = 0; ChannelIndex < NumberOfLinkChannel; ++ChannelIndex)
			{
				const NTV2Channel ChannelItt = NTV2Channel(int32_t(Channel) + ChannelIndex);
				AJA_CHECK(GetDevice().AutoCirculateStop(ChannelItt));
			}

			{
				// NB. We are already lock
				ULWord OptionFlags = (UseTimecode() ? AUTOCIRCULATE_WITH_RP188 : 0);
				OptionFlags |= (UseAncillary() || UseAncillaryField2() ? AUTOCIRCULATE_WITH_ANC : 0);
				UByte FrameCount = 0;
				UByte FirstFrame = BaseFrameIndex;
				UByte EndFrame = FirstFrame + DeviceConnection::NumberOfFrameForAutoCirculate - 1;

				AJA_CHECK(GetDevice().AutoCirculateInitForOutput(Channel, FrameCount, AudioSystem, OptionFlags, 1, FirstFrame, EndFrame));
			}
			AJA_CHECK(GetDevice().AutoCirculateStart(Channel));

			AJA_CHECK(Device->WaitForInputOrOutputInterrupt(Channel));

			return true;
		}

		void OutputChannelThread::Thread_AutoCirculateLoop()
		{
			const bool bIsProgressive = ::IsProgressivePicture(VideoFormat) || Options.bOutputInterlaceAsProgressive;
			bool bRunning = true;
			bool bSleep = true;

			AUTOCIRCULATE_TRANSFER Transfer;
			while (bRunning && !bStopRequested)
			{
				bool bIsValidWaitForOutput = true;
				if (bSleep)
				{
					// I would expect to sync here, but it seems that causes an extra frame
					// of latency, so sleep, until the next frame is ready instead.
					::Sleep(0);
				}
				else
				{
					if (bIsProgressive)
					{
						bRunning = Device->WaitForInputOrOutputInterrupt(Channel);
					}
					else
					{
						// In Interlaced, wait for Field0 to continue but warn the user when field is 1 (in case he wants to be v-sync)
						NTV2FieldID FieldId = NTV2_FIELD_INVALID;
						bRunning = Device->WaitForInputOrOutputInputField(Channel, 1, FieldId);
						bIsValidWaitForOutput = (bRunning && FieldId == NTV2_FIELD0);
					}
				}

				if (!bRunning)
				{
					UE_LOG(LogAjaCore, Error, TEXT("AutoCirculate: Can't wait for the output field for channel %d on device %S.\n"), uint32_t(Channel) + 1, GetDevice().GetDisplayName().c_str());
					if (GetOptions().bStopOnTimeout)
					{
						break;
					}
					else
					{
						bRunning = true;
					}
				}

				AUTOCIRCULATE_STATUS ChannelStatus;
				bRunning = GetDevice().AutoCirculateGetStatus(Channel, ChannelStatus);
				if (!bRunning)
				{
					UE_LOG(LogAjaCore, Error, TEXT("AutoCirculate: Can't get the status for output channel %d on device %S.\n"), uint32_t(Channel) + 1, GetDevice().GetDisplayName().c_str());
					break;
				}

				if (bStopRequested)
				{
					// After the WaitForInputOrOutputInterrupt, it's possible that bStopRequested has been modified.
					bRunning = false;
					break;
				}

				if (!bIsValidWaitForOutput)
				{
					AJAAutoLock AutoLock(&Lock);
					if (GetOptions().CallbackInterface)
					{
						GetOptions().CallbackInterface->OnOutputFrameStarted();
					}
					continue;
				}

				bSleep = true;
				if (ChannelStatus.CanAcceptMoreOutputFrames())
				{
					bSleep = false;
					{
						AJAAutoLock AutoLock(&Lock);
						if (GetOptions().CallbackInterface)
						{
							GetOptions().CallbackInterface->OnOutputFrameStarted();
						}
					}

					Frame* AvailableReadingFrame = Thread_FetchAvailableReadingFrame();
					if (AvailableReadingFrame)
					{
						Thread_TestInterlacedOutput(AvailableReadingFrame);


						AJAOutputFrameData FrameData;
						FrameData.FramesDropped = ChannelStatus.acFramesDropped;
						FrameData.FramesLost = LostFrameCounter;

						bSleep = false; 

						if ((UseAncillary() && AvailableReadingFrame->CopiedAncBufferSize) || (UseAncillaryField2() && AvailableReadingFrame->CopiedAncF2BufferSize))
						{
							ULWord* Ancillary = UseAncillary() ? reinterpret_cast<ULWord*>(AvailableReadingFrame->AncBuffer) : nullptr;
							ULWord AncillarySize = UseAncillary() ? AvailableReadingFrame->CopiedAncBufferSize : 0;
							ULWord* AncillaryF2 = UseAncillaryField2() ? reinterpret_cast<ULWord*>(AvailableReadingFrame->AncF2Buffer) : nullptr;
							ULWord AncillaryF2Size = UseAncillaryField2() ? AvailableReadingFrame->CopiedAncF2BufferSize : 0;
							Transfer.SetAncBuffers(Ancillary, AncBufferSize, AncillaryF2, AncF2BufferSize);
						}

						if (UseAudio() && AvailableReadingFrame->CopiedAudioBufferSize)
						{
							Transfer.SetAudioBuffer(reinterpret_cast<ULWord*>(AvailableReadingFrame->AudioBuffer), AvailableReadingFrame->CopiedAudioBufferSize);
						}

						if (UseVideo() && AvailableReadingFrame->CopiedVideoBufferSize && TextureTransfer && GetOptions().bUseGPUDMA)
						{
							const UE::GPUTextureTransfer::ETransferDirection Direction = UE::GPUTextureTransfer::ETransferDirection::GPU_TO_CPU;
							TextureTransfer->BeginSync(AvailableReadingFrame->VideoBuffer, Direction);
						}

						if (UseVideo() && AvailableReadingFrame->CopiedVideoBufferSize)
						{
							if (bIsProgressive)
							{
								BurnTimecode(AvailableReadingFrame->Timecode, AvailableReadingFrame->VideoBuffer);
							}
							else
							{
								BurnTimecode(AvailableReadingFrame->Timecode, AvailableReadingFrame->Timecode2, AvailableReadingFrame->VideoBuffer);
							}
							Transfer.SetVideoBuffer(reinterpret_cast<ULWord*>(AvailableReadingFrame->VideoBuffer), AvailableReadingFrame->CopiedVideoBufferSize);
						}

						if (UseTimecode())
						{
							FrameData.Timecode = AvailableReadingFrame->Timecode;
							const FTimecode ConvertedTimecode = Helpers::AdjustTimecodeFromUE(VideoFormat, AvailableReadingFrame->Timecode);
							NTV2_RP188 Timecode = Helpers::ConvertTimecodeToRP188(ConvertedTimecode);
							Transfer.SetOutputTimeCode(Timecode, NTV2ChannelToTimecodeIndex(Channel)); //Set timecode on LTC and VITC. Do not use SetAllOutputtimecode. It trashes timecodes of other pins
						}

						AJA_CHECK(GetDevice().AutoCirculateTransfer(Channel, Transfer));
						if (UseVideo() && AvailableReadingFrame->CopiedVideoBufferSize && TextureTransfer && GetOptions().bUseGPUDMA)
						{
							TextureTransfer->EndSync(AvailableReadingFrame->VideoBuffer);
						}

						Thread_PushAvailableReadingFrame(AvailableReadingFrame);

						{
							AJAAutoLock AutoLock(&Lock);
							if (GetOptions().CallbackInterface)
							{
								bRunning = GetOptions().CallbackInterface->OnOutputFrameCopied(FrameData);
							}
						}

						if (!bRunning)
						{
							break;
						}
					}
				}
			}

			AJA_CHECK(GetDevice().AutoCirculateStop(Channel));

			//	Write the requested test pattern into host buffer...
			{
				NTV2TestPatternGen testPatternGen;
				NTV2Buffer testPatternBuffer;

				testPatternGen.DrawTestPattern(NTV2TestPatternSelect::NTV2_TestPatt_ColorBars100,
					FormatDescriptor,
					testPatternBuffer);

				for (UByte FrameIndex = BaseFrameIndex; FrameIndex < BaseFrameIndex + DeviceConnection::NumberOfFrameForAutoCirculate; ++FrameIndex)
				{
					GetDevice().DMAWriteFrame(FrameIndex, reinterpret_cast <uint32_t *> (testPatternBuffer.GetHostPointer()), uint32_t(testPatternBuffer.GetByteCount()));
				}
			}

			if (!bStopRequested)
			{
				AJAAutoLock AutoLock(&Lock);
				if (GetOptions().CallbackInterface)
				{
					GetOptions().CallbackInterface->OnCompletion(bRunning);
				}
			}
		}

		bool OutputChannelThread::DeviceThread_ConfigurePingPong(DeviceConnection::CommandList& InCommandList)
		{
			Frame* CurrentFrame = nullptr;
			{
				AJAAutoLock AutoLock(&FrameLock);
				if (AllFrames.size() == 0)
				{
					return false;
				}
				CurrentFrame = AllFrames.front();
			}

			ThreadLock_PingPongOutputLoop_Memset0(CurrentFrame);
		
			Device->WaitForInputOrOutputInterrupt(Channel);

			if (bTraceDebugMarkers)
			{
				InterruptEventHandle = Device->SetOnInterruptEvent(Channel, DeviceConnection::FOnVerticalInterrupt::FDelegate::CreateRaw(this, &OutputChannelThread::OnVerticalInterrupt));
			}

			if (CVarAjaPreRollMethod.GetValueOnAnyThread() == 0)
			{
				// Clear the current Buffer and initialize the ping-pong
				const int32_t NumOutputFrameIndex = 2;
				for (int32_t Index = 0; Index < NumOutputFrameIndex; ++Index)
				{
					AJA_CHECK(GetDevice().SetOutputFrame(Channel, BaseFrameIndex + Index));

					//@TODO fix ancillary for pingpong. AJA told us they would help
					if (UseAncillary())
					{
						NTV2_POINTER AncBufferPointer(CurrentFrame->AncBuffer, CurrentFrame->CopiedAncBufferSize);
						GetDevice().DMAWriteAnc(Index, AncBufferPointer);
					}
					if (UseAncillaryField2())
					{
						NTV2_POINTER AncF2BufferPointer(CurrentFrame->AncF2Buffer, CurrentFrame->CopiedAncF2BufferSize);
						GetDevice().DMAWriteAnc(Index, AncF2BufferPointer);
					}
					if (UseAudio())
					{
						GetDevice().DMAWriteAudio(AudioSystem, reinterpret_cast<ULWord*>(CurrentFrame->AudioBuffer), 0, CurrentFrame->CopiedAudioBufferSize);
						CurrentAudioWriteOffset += CurrentFrame->CopiedAudioBufferSize;
					}
					if (UseVideo())
					{
						AJA_CHECK(GetDevice().DMAWriteFrame(BaseFrameIndex + Index, reinterpret_cast<ULWord*>(CurrentFrame->VideoBuffer), CurrentFrame->CopiedVideoBufferSize, Channel));

						if (TextureTransfer && GetOptions().bUseGPUDMA)
						{
							TextureTransfer->EndSync(CurrentFrame->VideoBuffer);
						}
					}
					Device->WaitForInputOrOutputInterrupt(Channel);
				}

				ULWord VBICount = 0;
				AJA_CHECK(GetDevice().GetOutputVerticalInterruptCount(VBICount, Channel));

				// SetOutputFrame will tell the card that a frame should be transferred starting on the next VBI, so it will be transferring starting at CurrentVBI + 1, and be done transferring at CurrentVBI + 2
				BufferFreeIndex[0] = VBICount + 2;
				BufferFreeIndex[1] = BufferFreeIndex[0] + 1;

				//	Before the main loop starts, ping-pong the buffers so the hardware will use
				//	different buffers than the ones it was using while idling...
				uint32_t CurrentOutFrame = 0;
				CurrentOutFrame ^= 1;
				AJA_CHECK(GetDevice().SetOutputFrame(Channel, BaseFrameIndex + CurrentOutFrame));
			}

			return true;
		}

		void OutputChannelThread::ThreadLock_PingPongOutputLoop_Memset0(Frame* InCurrentReadingFrame)
		{
			if (InCurrentReadingFrame->AncBuffer)
			{
				AJA_CHECK(UseAncillary());
				memset(InCurrentReadingFrame->AncBuffer, 0, AncBufferSize);
			}
			if (InCurrentReadingFrame->AncF2Buffer)
			{
				AJA_CHECK(UseAncillaryField2());
				memset(InCurrentReadingFrame->AncF2Buffer, 0, AncF2BufferSize);
			}
			if (InCurrentReadingFrame->AudioBuffer)
			{
				AJA_CHECK(UseAudio());
				memset(InCurrentReadingFrame->AudioBuffer, 0, AudioBufferSize);
			}
			if (InCurrentReadingFrame->VideoBuffer)
			{
				AJA_CHECK(UseVideo());
				memset(InCurrentReadingFrame->VideoBuffer, 0, VideoBufferSize);
			}
		}

		// As reference: this code was inspired by NTV2LLBurn::ProcessFrames(void)
		void OutputChannelThread::Thread_PingPongLoop()
		{
			bool bHaveOutputOnce = false;
			const bool bIsProgressive = ::IsProgressivePicture(VideoFormat) || Options.bOutputInterlaceAsProgressive;

			uint32_t CurrentOutFrame = 0;
			// If prerolling normally, then we're targetting the free buffer.
			CurrentOutFrame ^= 1;

			if (TextureTransfer)
			{
				TextureTransfer->ThreadPrep();
			}

			uint32_t LastFrameDropCount = 0;
			auto LogDropFrames = [&LastFrameDropCount, this]()
			{
				UE_LOG(LogAjaCore, Warning, TEXT("PingPong: Dropped %d frames while outputting on channel %d on device %S.\n"), LastFrameDropCount, uint32_t(Channel) + 1, GetDevice().GetDisplayName().c_str());
			};

			bool bRunning = true;
			while (bRunning && !bStopRequested)
			{
				if (bOutputWithReduceWaiting)
				{
					const double MaxWaitTime = FrameRate.AsInterval();
					{
						TRACE_CPUPROFILER_EVENT_SCOPE(AjaOutputChannelThread::WaitingForAvailableFrame);
						if (!FrameAvailableEvent->Wait(MaxWaitTime * 1000))
						{
							LastFrameDropCount++;
							continue;
						}
					}
				}

				//	Wait until the input has completed capturing a frame...
				bool bIsValidWaitForOutput = true;
				if (bIsProgressive)
				{
					if (bOutputWithReduceWaiting)
					{
						ULWord VBICount = 0;
						AJA_CHECK(GetDevice().GetOutputVerticalInterruptCount(VBICount, Channel));

						// If we're still using the card buffer, wait until next VBI, otherwise go ahead.
						const uint32 OffScreenBuffer = CurrentOutFrame ^ 1;

						if (VBICount + 2 == BufferFreeIndex[CurrentOutFrame])
						{
							TRACE_CPUPROFILER_EVENT_SCOPE(AjaOutputChannelThread::DroppedFrame);
							// We have already scheduled an output in the same VBI period, this usually occurs after a hitch, so we should drop one of our frames 
							if (Frame* AvailableReadingFrame = Thread_FetchAvailableReadingFrame())
							{
								Thread_PushAvailableReadingFrame(AvailableReadingFrame);
							}

							continue;
						}
						else if (VBICount < BufferFreeIndex[OffScreenBuffer])
						{
							// Off screen buffer is not available, so wait until a VBI occurs so we know it's free.
							TRACE_CPUPROFILER_EVENT_SCOPE(AjaOutputChannelThread::WaitForInputOrOutputInterrupt);
							bRunning = Device->WaitForInputOrOutputInterrupt(Channel);
						}
					}
					else
					{
						bRunning = Device->WaitForInputOrOutputInterrupt(Channel);
					}
				}
				else
				{
					// In Interlaced, wait for Field0 to continue but warn the user when field is 1 (in case he wants to be v-sync)
					NTV2FieldID FieldId = NTV2_FIELD_INVALID;
					bRunning = Device->WaitForInputOrOutputInputField(Channel, 1, FieldId);
					bIsValidWaitForOutput = (bRunning && FieldId == NTV2_FIELD0);
				}

				FScopeLock DeviceLock(&DeviceCriticalSection);

				if (!bRunning)
				{
					UE_LOG(LogAjaCore, Error, TEXT("PingPong: Can't wait for the output field for channel %d on device %S.\n"), uint32_t(Channel) + 1, GetDevice().GetDisplayName().c_str());
					if (GetOptions().bStopOnTimeout)
					{
						break;
					}
					else
					{
						bRunning = true;
					}
				}

				if (bStopRequested)
				{
					// After the WaitForInputOrOutputInterrupt, it's possible that bStopRequested has been modified.
					bRunning = false;
					break;
				}

				{
					AJAAutoLock AutoLock(&Lock);
					if (GetOptions().CallbackInterface)
					{
						GetOptions().CallbackInterface->OnOutputFrameStarted();
					}
				}

				if (!bIsValidWaitForOutput)
				{
					continue;
				}

				Frame* AvailableReadingFrame = Thread_FetchAvailableReadingFrame();
				if (AvailableReadingFrame)
				{
					if (LastFrameDropCount != 0)
					{
						LogDropFrames();
						LastFrameDropCount = 0;
					}

					Thread_TestInterlacedOutput(AvailableReadingFrame);

					//	Flip sense of the buffers again to refer to the buffers that the hardware isn't using (i.e. the off-screen buffers)...
					CurrentOutFrame ^= 1;

					//	Check for dropped frames by ensuring the hardware has not started to process
					//	the buffers that were just filled....
					uint32_t ReadBackIn;
					AJA_CHECK(GetDevice().GetOutputFrame(Channel, ReadBackIn));
					if (ReadBackIn == BaseFrameIndex + CurrentOutFrame && bHaveOutputOnce)
					{
						++PingPongDropCount;
					}

					AJAOutputFrameData FrameData;
					FrameData.FramesDropped = PingPongDropCount;
					FrameData.FramesLost = LostFrameCounter;

					if (AvailableReadingFrame->CopiedAncBufferSize > 0)
					{
						NTV2_POINTER AncBufferPointer(AvailableReadingFrame->AncBuffer, AvailableReadingFrame->CopiedAncBufferSize);
						bRunning = bRunning && GetDevice().DMAWriteAnc(CurrentOutFrame, AncBufferPointer);
					}

					if (AvailableReadingFrame->CopiedAncF2BufferSize > 0)
					{
						NTV2_POINTER AncF2BufferPointer(AvailableReadingFrame->AncF2Buffer, AvailableReadingFrame->CopiedAncF2BufferSize);
						bRunning = bRunning && GetDevice().DMAWriteAnc(CurrentOutFrame, AncF2BufferPointer);
					}

					ULWord VBICount = 0;
					AJA_CHECK(GetDevice().GetOutputVerticalInterruptCount(VBICount, Channel));


					if (AvailableReadingFrame->CopiedVideoBufferSize > 0)
					{
						if (bIsProgressive)
						{
							BurnTimecode(AvailableReadingFrame->Timecode, AvailableReadingFrame->VideoBuffer);
						}
						else
						{
							BurnTimecode(AvailableReadingFrame->Timecode, AvailableReadingFrame->Timecode2, AvailableReadingFrame->VideoBuffer);
						}

						if (TextureTransfer && GetOptions().bUseGPUDMA)
						{
							const UE::GPUTextureTransfer::ETransferDirection Direction = UE::GPUTextureTransfer::ETransferDirection::GPU_TO_CPU;
							TextureTransfer->BeginSync(AvailableReadingFrame->VideoBuffer, Direction);
						}

						{
							TRACE_CPUPROFILER_EVENT_SCOPE(AjaOutputChannelThread::DMAWriteFrame);
							bRunning = bRunning && GetDevice().DMAWriteFrame(BaseFrameIndex + CurrentOutFrame, reinterpret_cast<ULWord*>(AvailableReadingFrame->VideoBuffer), AvailableReadingFrame->CopiedVideoBufferSize, Channel);
						}

						if (TextureTransfer && GetOptions().bUseGPUDMA)
						{
							TextureTransfer->EndSync(AvailableReadingFrame->VideoBuffer);
						}
					}

					if (UseAudio() && AvailableReadingFrame->CopiedAudioBufferSize && !GetOptions().bDirectlyWriteAudio)
					{
						bRunning &= Thread_HandleAudio(TEXT("PingPong"), AvailableReadingFrame);
					}

					if (!bRunning)
					{
						UE_LOG(LogAjaCore, Error, TEXT("PingPong: Can't do the DMA frame transfer for channel %d on device %S.\n"), uint32_t(Channel) + 1, GetDevice().GetDisplayName().c_str());
						break;
					}

					//	Determine the for the DMA timecode value
					if (UseTimecode())
					{
						FrameData.Timecode = AvailableReadingFrame->Timecode;
						// As reference: this code was inspirered by NTV2LLBurn::InputSignalHasTimecode
						{
							const FTimecode ConvertedTimecode = Helpers::AdjustTimecodeFromUE(VideoFormat, AvailableReadingFrame->Timecode);
							NTV2_RP188 Timecode = Helpers::ConvertTimecodeToRP188(ConvertedTimecode);

							const int32_t NumberOfLinkChannel = Helpers::GetNumberOfLinkChannel(GetOptions().TransportType);
							{
								for (int32_t ChannelIndex = 0; ChannelIndex < NumberOfLinkChannel; ++ChannelIndex)
								{
									const NTV2Channel ChannelItt = NTV2Channel(int32_t(Channel) + ChannelIndex);
									AJA_CHECK(GetDevice().SetRP188Data(ChannelItt, Timecode));
								}
							}
						}
					}

					//	Tell the hardware which buffers to start using at the beginning of the next frame...
					if (bTraceDebugMarkers)
					{
						TRACE_BOOKMARK(TEXT("Aja: SetOutputFrame [%d] (Buffer %d)"), AvailableReadingFrame->FrameIdentifier, CurrentOutFrame);
					}

					AJA_CHECK(GetDevice().SetOutputFrame(Channel, BaseFrameIndex + CurrentOutFrame));

					if (!bRunning)
					{
						UE_LOG(LogAjaCore, Error, TEXT("PingPong: Can't do the DMA frame transfer for channel %d on device %S.\n"), uint32_t(Channel) + 1, GetDevice().GetDisplayName().c_str());
						Thread_PushAvailableReadingFrame(AvailableReadingFrame);
						break;
					}

					// SetOutputFrame will tell the card that a frame should be transferred starting on the next VBI, so it will be transferring starting at CurrentVBI + 1, and be done transferring at CurrentVBI + 2
					uint32 FrameAvailableVBICount = VBICount + 2;
					BufferFreeIndex[CurrentOutFrame] = FrameAvailableVBICount;
					BufferFrameIdMapping[CurrentOutFrame] = AvailableReadingFrame->FrameIdentifier;

					Thread_PushAvailableReadingFrame(AvailableReadingFrame);
					bHaveOutputOnce = true;

					{
						AJAAutoLock AutoLock(&Lock);
						if (GetOptions().CallbackInterface)
						{
							bRunning = GetOptions().CallbackInterface->OnOutputFrameCopied(FrameData);
						}
					}
				}
				else if (GetOptions().bDisplayWarningIfDropFrames)
				{
					TRACE_CPUPROFILER_EVENT_SCOPE(OutputChannel::NoFramesAvailable);

					if (UseAudio() && !GetOptions().bDirectlyWriteAudio)
					{
						Thread_HandleLostFrameAudio();
					}

					static constexpr uint32 NumMaxFrameBeforeWarning = 50;

					LastFrameDropCount++;
					if (LastFrameDropCount > NumMaxFrameBeforeWarning)
					{
						LogDropFrames();
						LastFrameDropCount = 0;
					}
				}
			}

			//	Write the requested test pattern into host buffer...
			{
				NTV2TestPatternGen testPatternGen;
				NTV2Buffer testPatternBuffer;

				testPatternGen.DrawTestPattern(NTV2TestPatternSelect::NTV2_TestPatt_ColorBars100,
					FormatDescriptor,
					testPatternBuffer);

				CurrentOutFrame ^= 1;
				GetDevice().DMAWriteFrame(BaseFrameIndex + CurrentOutFrame, reinterpret_cast <uint32_t*> (testPatternBuffer.GetHostPointer()), uint32_t(testPatternBuffer.GetByteCount()));
				CurrentOutFrame ^= 1;
				GetDevice().DMAWriteFrame(BaseFrameIndex + CurrentOutFrame, reinterpret_cast <uint32_t*> (testPatternBuffer.GetHostPointer()), uint32_t(testPatternBuffer.GetByteCount()));
			}

			if (!bStopRequested)
			{
				AJAAutoLock AutoLock(&Lock);
				if (GetOptions().CallbackInterface)
				{
					GetOptions().CallbackInterface->OnCompletion(bRunning);
				}
			}

			if (TextureTransfer)
			{
				TextureTransfer->ThreadCleanup();
			}
		}

		void OutputChannelThread::Thread_TestInterlacedOutput(Frame* InFrame)
		{
			if (!GetOptions().bTEST_OutputInterlaced)
			{
				return;
			}

			struct FUYV422Format
			{
				uint8_t V;
				uint8_t Y1;
				uint8_t U;
				uint8_t Y0;
			};
			auto IsLineWhite = [](const FUYV422Format* pLine) -> bool { return pLine->Y0 >= 0x0 && pLine->Y0 < 0x20 && pLine->Y1 >= 0x0 && pLine->Y1 < 0x20; };
			const FUYV422Format* pFirstLine = reinterpret_cast<const FUYV422Format*>(InFrame->VideoBuffer);
			const FUYV422Format* pSecondLine = pFirstLine + FormatDescriptor.GetBytesPerRow()/sizeof(FUYV422Format);

			if (InterlacedTest_FrameCounter == 0)
			{
				bInterlacedTest_ExpectFirstLineToBeWhite = IsLineWhite(pFirstLine);
			}

			bool bIsFirstLineWhite = IsLineWhite(pFirstLine);
			bool pIsSecondLineWhite = IsLineWhite(pSecondLine);
			if (bIsFirstLineWhite == pIsSecondLineWhite)
			{
				UE_LOG(LogAjaCore, Error, TEXT("INTERLACED TEST - The 2 lines are the same color. %d\n"), InterlacedTest_FrameCounter);
			}
			if (bIsFirstLineWhite != bInterlacedTest_ExpectFirstLineToBeWhite)
			{
				bInterlacedTest_ExpectFirstLineToBeWhite = !bInterlacedTest_ExpectFirstLineToBeWhite;
				UE_LOG(LogAjaCore, Error, TEXT("INTERLACED TEST - The lines has swap color. %d\n"), InterlacedTest_FrameCounter);
			}
			++InterlacedTest_FrameCounter;
		}

		bool OutputChannelThread::Thread_GetAudioOffset(int32& OutAudioOffset)
		{
			bool bSuccess = true;
			ULWord AudioWrapOffset = 0;
			ULWord PlayHeadPosition = 0;

			bSuccess &= GetDevice().GetAudioWrapAddress(AudioWrapOffset);
			bSuccess &= GetDevice().ReadAudioLastOut(PlayHeadPosition);

			// Calculate audio offset
			if (CurrentAudioWriteOffset > PlayHeadPosition)
			{
				OutAudioOffset = CurrentAudioWriteOffset - PlayHeadPosition;
			}
			else
			{
				OutAudioOffset = (AudioWrapOffset - PlayHeadPosition) + CurrentAudioWriteOffset;
			}

			return bSuccess;
		}


		bool OutputChannelThread::Thread_GetAudioOffsetInSeconds(double& OutAudioOffset)
		{
			int32 OffsetInBytes = 0;
			if (Thread_GetAudioOffset(OffsetInBytes))
			{
				OutAudioOffset = (OffsetInBytes / sizeof(int32)) / 48000.f / Options.NumberOfAudioChannel;
				return true;
			}

			return false;
		}

		bool OutputChannelThread::Thread_GetAudioOffsetInSamples(int32& OutAudioOffset)
		{
			int32 OffsetInBytes = 0;
			if (Thread_GetAudioOffset(OffsetInBytes))
			{
				OutAudioOffset = FMath::RoundToInt32((float)OffsetInBytes / Options.NumberOfAudioChannel / sizeof(int32));
				return true;
			}

			return false;
		}


		bool OutputChannelThread::Thread_TransferAudioBuffer(const uint8* InBuffer, int32 InBufferSize)
		{
			bool bSuccess = true;

			ULWord AudioWrapOffset = 0;

			bSuccess &= GetDevice().GetAudioWrapAddress(AudioWrapOffset);

			if (CurrentAudioWriteOffset + InBufferSize < AudioWrapOffset)
			{
				// Simplest case, just write the whole data to the SDRAM.
				bSuccess &= GetDevice().DMAWriteAudio(AudioSystem, reinterpret_cast<const ULWord*>(InBuffer), CurrentAudioWriteOffset, InBufferSize);
				CurrentAudioWriteOffset += InBufferSize;
			}
			else
			{
				// Audio data will wrap, so write in two parts.
				ULWord BytesUntilBufferEnd = AudioWrapOffset - CurrentAudioWriteOffset;
				LWord RemainingBytes = InBufferSize - BytesUntilBufferEnd;
				// We might technically have space remaining, but we can't write there since it's too close to the wrap address.
				if (RemainingBytes < 0)
				{
					RemainingBytes = 0;
				}

				bSuccess &= GetDevice().DMAWriteAudio(AudioSystem, reinterpret_cast<const ULWord*>(InBuffer), CurrentAudioWriteOffset, BytesUntilBufferEnd);
				if (RemainingBytes > 0)
				{
					bSuccess &= GetDevice().DMAWriteAudio(AudioSystem, reinterpret_cast<const ULWord*>(InBuffer + BytesUntilBufferEnd), 0, RemainingBytes);
				}

				CurrentAudioWriteOffset = RemainingBytes;
			}

			return bSuccess;
		}

		bool OutputChannelThread::Thread_HandleAudio(const FString& OutputMethod, Frame* AvailableReadingFrame)
		{
			bool bAudioTransferWasSuccessful = true;

			bool bAudioSuccess = true;

			bool bAudioOutputRunning = false;
			bAudioSuccess &= GetDevice().IsAudioOutputRunning(AudioSystem, bAudioOutputRunning);

			bool bIsPaused = false;
			bAudioSuccess &= GetDevice().GetAudioOutputPause(AudioSystem, bIsPaused);

			if (bIsPaused && bAudioOutputRunning && !Thread_ShouldPauseAudioOutput())
			{
				UE_LOG(LogAjaCore, Verbose, TEXT("%s: Resuming audio output."), *OutputMethod);
				bool bPausePlayback = false;
				bAudioSuccess &= GetDevice().SetAudioOutputPause(AudioSystem, bPausePlayback);
				bIsPaused = true;
			}
			else if (!bAudioOutputRunning)
			{
				// Only offset the start ptr if this is1 the first time we're starting the audio output.

				ULWord WrapOffset = 0;
				bAudioSuccess &= GetDevice().GetAudioWrapAddress(WrapOffset);

				int32 NumOffsetFrames = 1;
				int32 InitialOffset = Options.NumberOfAudioChannel * NumSamplesPerFrame * NumOffsetFrames * sizeof(int32);

				CurrentAudioWriteOffset = InitialOffset;

				UE_LOG(LogAjaCore, Verbose, TEXT("%s: Starting audio output."), *OutputMethod);
				bAudioSuccess &= GetDevice().StartAudioOutput(AudioSystem); // This resets the playhead to 0, we have to override that to something closer to the write head in order to reduce audio delay
			}

			if (bAudioSuccess)
			{
				double OffsetInSeconds = 0;
				bAudioSuccess &= Thread_GetAudioOffsetInSeconds(OffsetInSeconds);
				ULWord PlayHeadPosition = 0;
				bAudioSuccess &= GetDevice().ReadAudioLastOut(PlayHeadPosition, AudioSystem);
				AudioPlayheadLastPosition = PlayHeadPosition;
				
				SET_FLOAT_STAT(STAT_AjaMediaCapture_Audio_Delay, OffsetInSeconds);
				UE_LOG(LogAjaCore, Verbose, TEXT("%s: Play head: %d, Write Head: %d, Offset: %f"), *OutputMethod, AudioPlayheadLastPosition.load(), CurrentAudioWriteOffset.load(), OffsetInSeconds);

				bAudioTransferWasSuccessful &= Thread_TransferAudioBuffer(AvailableReadingFrame->AudioBuffer, AvailableReadingFrame->CopiedAudioBufferSize);

				int32 OffsetInSamples = 0;
				bAudioSuccess &= Thread_GetAudioOffsetInSamples(OffsetInSamples);

				if (bAudioSuccess && Thread_ShouldPauseAudioOutput())
				{
					UE_LOG(LogAjaCore, Warning, TEXT("%s: Audio play head is catching up to write head for channel %d on device %S.\n"), *OutputMethod, uint32_t(Channel) + 1, GetDevice().GetDisplayName().c_str());

					bool bPausePlayout = true;
					GetDevice().SetAudioOutputPause(AudioSystem, bPausePlayout);

					UE_LOG(LogAjaCore, Verbose, TEXT("%s Pausing audio output because the play head is catching up to the write head. Last playhead position: %d"), *OutputMethod, AudioPlayheadLastPosition.load());
				}
			}
			else
			{
				UE_LOG(LogAjaCore, Verbose, TEXT("%s Audio output failed."), *OutputMethod);
			}

			return bAudioTransferWasSuccessful;
		}

		bool OutputChannelThread::DMAWriteAudio(const uint8_t* InAudioBuffer, int32_t BufferSize)
		{
			if (!Device || !Device->GetCard())
			{
				return false;
			}

			TRACE_CPUPROFILER_EVENT_SCOPE(OutputChannelThread::DMAWriteAudio);
			FScopeLock DeviceLock(&DeviceCriticalSection);

			bool bAudioSuccess = true;

			bool bAudioOutputRunning = false;
			bAudioSuccess &= GetDevice().IsAudioOutputRunning(AudioSystem, bAudioOutputRunning);

			UE_CLOG(!bAudioSuccess, LogAjaCore, Verbose, TEXT("IsAudioOutputRunning returned false."));

			bool bIsPaused = false;
			bAudioSuccess &= GetDevice().GetAudioOutputPause(AudioSystem, bIsPaused);

			UE_CLOG(!bAudioSuccess, LogAjaCore, Verbose, TEXT("GetAudioOutputPause returned false."));

			// Start audio output as late as possible to reduce delay.
			if (!bAudioOutputRunning)
			{
				// Only offset the start ptr if this is the first time we're starting the audio output.
				ULWord WrapOffset = 0;
				bAudioSuccess &= GetDevice().GetAudioWrapAddress(WrapOffset);

				constexpr int32 NumOffsetFrames = 4;
				const int32 InitialOffset = Options.NumberOfAudioChannel * NumSamplesPerFrame * NumOffsetFrames * sizeof(int32);

				CurrentAudioWriteOffset = InitialOffset;

				UE_LOG(LogAjaCore, Verbose, TEXT("PingPong: Starting audio output."));
				bAudioSuccess &= GetDevice().StartAudioOutput(AudioSystem); // This resets the playhead to 0, we have to override that to something closer to the write head in order to reduce audio delay
			}

			double OffsetInSeconds = 0;
			bAudioSuccess &= Thread_GetAudioOffsetInSeconds(OffsetInSeconds);
			UE_CLOG(!bAudioSuccess, LogAjaCore, Verbose, TEXT("Thread_GetAudioOffsetInSeconds returned false."));
			ULWord PlayHeadPosition = 0;
			bAudioSuccess &= GetDevice().ReadAudioLastOut(PlayHeadPosition, AudioSystem);
			UE_CLOG(!bAudioSuccess, LogAjaCore, Verbose, TEXT("ReadAudioLastOut returned false."));
			
			AudioPlayheadLastPosition = PlayHeadPosition;
			SET_FLOAT_STAT(STAT_AjaMediaCapture_Audio_Delay, OffsetInSeconds);
			UE_LOG(LogAjaCore, Verbose, TEXT("%s: Play head: %d, Write Head: %d, Offset: %f"), TEXT("PingPong"), AudioPlayheadLastPosition.load(), CurrentAudioWriteOffset.load(), OffsetInSeconds);

			bAudioSuccess &= Thread_TransferAudioBuffer(InAudioBuffer, BufferSize);
			
			return bAudioSuccess;
		}
		

		bool OutputChannelThread::Thread_HandleLostFrameAudio()
		{
			bool bAudioSuccess = true;
			bool bAudioOutputRunning = false;
			bAudioSuccess &= GetDevice().IsAudioOutputRunning(AudioSystem, bAudioOutputRunning);

			if (bAudioOutputRunning)
			{
				// When dropping frames, we have to keep writing audio data or else the play head will catch up to the write head which will induce a delay
				int32 OffsetInSeconds = 0;
				bAudioSuccess &= Thread_GetAudioOffsetInSamples(OffsetInSeconds);

				if (bAudioSuccess && Thread_ShouldPauseAudioOutput())
				{
					constexpr bool bPausePlayout = true;
					bAudioSuccess &= GetDevice().SetAudioOutputPause(AudioSystem, bPausePlayout);
					UE_LOG(LogAjaCore, Warning, TEXT("Pausing audio output. Last playhead position: %d"), AudioPlayheadLastPosition.load());
				}
			}

			return bAudioSuccess;
		}

		bool OutputChannelThread::Thread_ShouldPauseAudioOutput()
		{
			constexpr int32 AudioBufferZoneInFrames = 1;
			int32 OffsetInSamples = 0;
			Thread_GetAudioOffsetInSamples(OffsetInSamples);

			if (OffsetInSamples <= (int32) NumSamplesPerFrame * AudioBufferZoneInFrames)
			{
				return true;
			}
			return false;
		}

		void OutputChannelThread::OnVerticalInterrupt(uint32 SyncCount) const
		{
			uint32 FrameId = 0;
			uint8 BufferId = 0;

			if (BufferFreeIndex[0] == SyncCount)
			{
				FrameId = BufferFrameIdMapping[0];
				BufferId = 0;
			}
			else if (BufferFreeIndex[1] == SyncCount)
			{
				FrameId = BufferFrameIdMapping[1];
				BufferId = 1;
			}

			if (FrameId != 0)
			{
				TRACE_BOOKMARK(TEXT("Aja: Finish SDI transfer frame [%d] (Buffer: %d)"), FrameId, BufferId);
			}
			else if (BufferFrameIdMapping[0] != 0 && BufferFrameIdMapping[1] != 0) // Don't log drop frames when starting the output
			{
				TRACE_BOOKMARK(TEXT("Aja VBI [%d] (Dropped frame)"), SyncCount);
			}
		}
	}
}