file
namespace    DatasmithRuntime
function     bool GetTextureDataFromFile

		}

		//FinalImage format
		FREE_IMAGE_FORMAT FileType = FIF_UNKNOWN;

		//check the file signature and deduce its format
		FileType = FreeImage_GetFileType(TCHAR_TO_FICHAR(Filename), 0);

		//if still unknown, try to guess the file format from the file extension

file
namespace    DatasmithRuntime
function     bool GetTextureDataFromFile

		}

		//pointer to the FinalImage, once loaded
		FIBITMAP* Bitmap = FreeImage_Load(FileType, TCHAR_TO_FICHAR(Filename), 0);

		//if the FinalImage failed to load, return failure
		if (!Bitmap)
		{
			return false;
		}

		return GetTextureDataInternal(Bitmap, FileType, Mode, MaxSize, bGenerateNormalMap, TextureData);

file
namespace    DatasmithRuntime
function     bool GetTextureDataFromBuffer

		}

		// FinalImage format
		FREE_IMAGE_FORMAT FileType = Format == EDatasmithTextureFormat::JPEG ? FIF_JPEG : FIF_PNG;

		// check that the plugin has reading capabilities and load the file
		if (!FreeImage_FIFSupportsReading(FileType))
		{
			return false;

file
namespace    DatasmithRuntime
function     bool GetTextureDataFromBuffer

		ensure(FreeImage_GetFileTypeFromMemory(MemoryBuffer, 0) == FileType);

		// pointer to the FinalImage, once loaded
		FIBITMAP *Bitmap = FreeImage_LoadFromMemory(FileType, MemoryBuffer, 0);

		// Close the memory stream
		FreeImage_CloseMemory(MemoryBuffer);

		// Safe to free array now

file
namespace    DatasmithRuntime
function     bool GetTextureDataInternal

		TRACE_CPUPROFILER_EVENT_SCOPE(DatasmithRuntime::GetTextureData);

		//if the FinalImage failed to load, return failure
		if (!Bitmap)
		{
			return false;
		}

		//get the FinalImage Width and Height
		const uint32 OriginalWidth = FreeImage_GetWidth(Bitmap);
		const uint32 OriginalHeight = FreeImage_GetHeight(Bitmap);

		{
			//retrieve the FinalImage data
			BYTE* Bits = FreeImage_GetBits(Bitmap);

			//if this somehow one of these failed (they shouldn't), return failure
			if ((Bits == 0) || (OriginalWidth == 0) || (OriginalHeight == 0))
			{
				return false;

file
namespace    DatasmithRuntime
function     bool GetTextureDataInternal

		}

		FIBITMAP* FinalImage = RescaledImage;

		if (bGenerateNormalMap == true)
		{
			FinalImage = FreeImage_ConvertTo32Bits(RescaledImage);
			check(FreeImage_GetImageType(FinalImage) == FIT_BITMAP);
		}

		bool bResult = true;
		TextureData.Width = NewWidth;
		TextureData.Height = NewHeight;
		TextureData.Pitch = FreeImage_GetPitch(FinalImage);
		const int32 BitsPerPixel = FreeImage_GetBPP(FinalImage);
		TextureData.BytesPerPixel = FMath::Max(1, BitsPerPixel / 8);

		check(TextureData.Width && TextureData.Height);

		switch(FreeImage_GetImageType(FinalImage))
		{
			case FIT_BITMAP:
			{
				CopyData<BYTE>(FinalImage, TextureData);
				break;
			}

			case FIT_UINT16:
			case FIT_INT16:
			{
				CopyData<uint16>(FinalImage, TextureData);
				break;
			}

			case FIT_UINT32:
			case FIT_INT32:
			{
				CopyData<uint32>(FinalImage, TextureData);
				break;
			}

			case FIT_FLOAT:
			case FIT_DOUBLE:
			{
				CopyData<float>(FinalImage, TextureData);
				break;
			}

			case FIT_RGB16:
			case FIT_RGBA16:
			{
				CopyData<FIRGB16>(FinalImage, TextureData);
				break;
			}

			case FIT_RGBAF:
			case FIT_RGBF:
			{
				CopyData<FIRGBF>(FinalImage, TextureData);
				break;
			}

			case FIT_COMPLEX:
			default:
			{

file
namespace    DatasmithRuntime
function     bool GetTextureDataInternal

		}

		if (FinalImage != RescaledImage)
		{
			FreeImage_Unload(FinalImage);
		}

		// Free rescaled FinalImage data if applicable
		if (RescaledImage != Bitmap)
		{
			FreeImage_Unload(RescaledImage);
		}

		//Free FreeImage's copy of the data

public:
	// The name of the pass such as "FinalImage" or "ObjectId", etc.
	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Movie Pipeline")
	FString Name;

	// The name of the camera that this pass is for. Stored here so we can differentiate between 
	// multiple cameras within a single pass.
	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Movie Pipeline")

	/** 
	* A mapping between render passes (such as 'FinalImage') and an array containing the files written for that shot.
	* Will be multiple files if using image sequences.
	*/
	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Movie Pipeline")
	TMap<FMoviePipelinePassIdentifier, FMoviePipelineRenderPassOutputData> RenderPassData;
};

namespace MoviePipeline
{
	struct FMoviePipelineOutputFutureData

file
namespace    UE::ImageWrapper::Private
function     void FTiffImageWrapper::UnpackIntoRawBuffer

				UE_LOG(LogImageWrapper, Warning, TEXT("Tiff MINISWHITE floating point?  This is probably wrong."));

				TArrayView64<DataTypeDest> FinalImage(static_cast<DataTypeDest*>(static_cast<void*>(RawData.GetData())), RawData.Num());
				ParallelFor(Width * Height, [&FinalImage](int32 Index)
					{
						DataTypeDest& FinalValue = FinalImage[Index];
						FinalValue = 1.f - FinalValue; // uses implicit operator float() on FFloat16
					},  IsInGameThread() ? EParallelForFlags::None : EParallelForFlags::BackgroundPriority);
			}
			else
			{
				TArrayView64<DataTypeDest> FinalImage(static_cast<DataTypeDest*>(static_cast<void*>(RawData.GetData())), RawData.Num());
				ParallelFor(Width * Height, [&FinalImage](int32 Index)
					{
						DataTypeDest& FinalValue = FinalImage[Index];
						FinalValue = TNumericLimits<DataTypeDest>::Max() - FinalValue;
					},  IsInGameThread() ? EParallelForFlags::None : EParallelForFlags::BackgroundPriority);
			}
		}
	}