file
namespace    UE::DerivedData

ILegacyCacheStore* CreateHttpCacheStore(const TCHAR* Name, const TCHAR* Config, ICacheStoreOwner* Owner);
void CreateMemoryCacheStore(IMemoryCacheStore*& OutCache, const TCHAR* Name, const TCHAR* Config, ICacheStoreOwner* Owner);
IPakFileCacheStore* CreatePakFileCacheStore(const TCHAR* Name, const TCHAR* Filename, bool bWriting, bool bCompressed, ICacheStoreOwner* Owner);
ILegacyCacheStore* CreateS3CacheStore(const TCHAR* Name, const TCHAR* Config, ICacheStoreOwner& Owner);
ILegacyCacheStore* CreateZenCacheStore(const TCHAR* Name, const TCHAR* Config, ICacheStoreOwner* Owner);
ILegacyCacheStore* TryCreateCacheStoreReplay(ILegacyCacheStore* InnerCache);

/**
 * This class is used to create a singleton that represents the derived data cache hierarchy and all of the wrappers necessary

file
namespace    UE::DerivedData
class        class FDerivedDataBackendGraph final : public FDerivedDataBackend, ICacheStoreOwner, ICacheStoreGraph
function     bool ParsePak

		FString PakFilename;
		FParse::Value( Entry, TEXT("Filename="), PakFilename );
		bool bCompressed = GetParsedBool(Entry, TEXT("Compressed="));

		if (PakFilename.IsEmpty())
		{
			UE_LOG(LogDerivedDataCache, Log, TEXT("FDerivedDataBackendGraph: %s pak cache Filename not found in *engine.ini, will not use a pak cache."), NodeName);
			return false;
		}

file
namespace    UE::DerivedData
class        class FDerivedDataBackendGraph final : public FDerivedDataBackend, ICacheStoreOwner, ICacheStoreGraph
function     bool ParsePak

			ReadPakFilename = PakFilename;
			WritePakFilename = PakFilename + TEXT(".") + Temp.ToString();
			WritePakCache = CreatePakFileCacheStore(NodeName, *WritePakFilename, /*bWriting*/ true, bCompressed, this);
			PakNode = WritePakCache;
			InParsedNodes.Add(NodeName, WritePakCache);
			return true;
		}
		else
		{

file
namespace    UE::DerivedData
class        class FDerivedDataBackendGraph final : public FDerivedDataBackend, ICacheStoreOwner, ICacheStoreGraph
function     bool ParsePak

			}

			IPakFileCacheStore* ReadPak = CreatePakFileCacheStore(NodeName, *PakFilename, /*bWriting*/ false, bCompressed, this);
			ReadPakFilename = PakFilename;
			PakNode = ReadPak;
			ReadPakCache.Add(ReadPak);
			InParsedNodes.Add(NodeName, ReadPak);
			return true;
		}

file
namespace    UE::DerivedData
function     IPakFileCacheStore* CreatePakFileCacheStore

}

IPakFileCacheStore* CreatePakFileCacheStore(const TCHAR* Name, const TCHAR* CachePath, bool bWriting, bool bCompressed, ICacheStoreOwner* Owner)
{
	return bCompressed ? new FCompressedPakFileCacheStore(Name, CachePath, bWriting, Owner) : new FPakFileCacheStore(Name, CachePath, bWriting, Owner);
}

} // UE::DerivedData

file
class        class UProjectPackagingSettings : public UObject

	 */
	UPROPERTY(config, EditAnywhere, Category=Packaging, AdvancedDisplay, meta=(DisplayName="Create compressed cooked packages"))
	bool bCompressed;
	
	/**
	 * A comma separated list of formats to use for .pak file and IoStore compression. If more than one is specified, the list is in order of priority, with fallbacks to other formats
	 * in case of errors or unavailability of the format (plugin not enabled, etc).
	 * Commonly PackageCompressionFormat=Oodle or PackageCompressionFormat=None
	 */

file
function     static bool ConvertToIoStoreShaderLibrary
lambda-function

			CompressedShaderGroupMemory = reinterpret_cast<uint8*>(FMemory::Malloc(CompressedGroupSize));
			bool bCompressed = ShaderCodeArchive::CompressShaderWithOodle(CompressedShaderGroupMemory, CompressedGroupSize, UncompressedGroupMemory, Group.UncompressedSize, InShaderOodleCompressor, InShaderOodleLevel);
			checkf(bCompressed, TEXT("We could not compress the shader group after providing an estimated memory."));

			TTuple<FIoChunkId, FIoBuffer, uint32>& OutCodeIoChunk = OutCodeIoChunks[GroupIndex];
			OutCodeIoChunk.Get<0>() = IoStoreLibraryHeader.ShaderGroupIoHashes[GroupIndex];
			// This value is the load order factor for the group (the smaller, the more likely), that IoStore will use to sort the chunks.
			// We calculate it as the smallest shader index in the group, which shouldn't be bad. Arguably a better way would be to get the lowest-numbered shadermap that references _any_ shader in the group, 
			// but it's much, much slower to calculate and the resulting order would be likely the same/similar most of the time

file
namespace    DescribeUtils

		TArray<FPackageDesc*> LocalizedPackages;
		TArray<FPackageRedirect> PackageRedirects;
		bool bCompressed;
		bool bSigned;
		bool bEncrypted;
		bool bIndexed;
	};

	struct FPackageLocation

file
namespace    DescribeUtils
function     TOptional<FContainerPackageInfo> TryGetContainerPackageInfo
lambda-function

			ContainerDesc->EncryptionKeyGuid = Job.Reader->GetEncryptionKeyGuid();
			EIoContainerFlags Flags = Job.Reader->GetContainerFlags();
			ContainerDesc->bCompressed = bool(Flags & EIoContainerFlags::Compressed);
			ContainerDesc->bEncrypted = bool(Flags & EIoContainerFlags::Encrypted);
			ContainerDesc->bSigned = bool(Flags & EIoContainerFlags::Signed);
			ContainerDesc->bIndexed = bool(Flags & EIoContainerFlags::Indexed);
			Job.ContainerDesc = ContainerDesc;

			TIoStatusOr<FIoBuffer> IoBuffer = Job.Reader->Read(CreateIoChunkId(Job.Reader->GetContainerId().Value(), 0, EIoChunkType::ContainerHeader), FIoReadOptions());

file
function     int32 Describe

			OutputOverride->Logf(ELogVerbosity::Display, TEXT("\t\t      ContainerId: 0x%llX"), ContainerDesc->Id.Value());
			OutputOverride->Logf(ELogVerbosity::Display, TEXT("\t\t       Compressed: %s"), ContainerDesc->bCompressed ? TEXT("Yes") : TEXT("No"));
			OutputOverride->Logf(ELogVerbosity::Display, TEXT("\t\t           Signed: %s"), ContainerDesc->bSigned ? TEXT("Yes") : TEXT("No"));
			OutputOverride->Logf(ELogVerbosity::Display, TEXT("\t\t          Indexed: %s"), ContainerDesc->bIndexed ? TEXT("Yes") : TEXT("No"));
			if (ContainerDesc->bEncrypted)
			{
				OutputOverride->Logf(ELogVerbosity::Display, TEXT("\t\tEncryptionKeyGuid: %s"), *ContainerDesc->EncryptionKeyGuid.ToString());
			}

file
class        class FTurnkeySupportCallbacks
function     static void CookOrPackage

				}

				if (PackagingSettings->bCompressed)
				{
					BuildCookRunParams += TEXT(" -compressed");
				}
			}

			if (PackagingSettings->IncludePrerequisites)

file
function     bool SaveStablePipelineCacheDeprecated

	}

	const bool bCompressed = OutputFilename.EndsWith(STABLE_CSV_COMPRESSED_EXT);

	FString CompressedFilename;
	FString UncompressedFilename;
	if (bCompressed)
	{
		CompressedFilename = OutputFilename;
		UncompressedFilename = CompressedFilename.LeftChop(STABLE_COMPRESSED_EXT_LEN); // remove the ".compressed"
	}
	else
	{

file
function     int32 DiffStable

	{
		const FString& Filename = Tokens[TokenIndex];
		bool bCompressed = Filename.EndsWith(STABLE_CSV_COMPRESSED_EXT);
		if (!bCompressed && !Filename.EndsWith(STABLE_CSV_EXT))
		{
			check(0);
			continue;
		}
			   
		UE_LOG(LogShaderPipelineCacheTools, Display, TEXT("Loading %s...."), *Filename);

file
function     void FLightmassProcessor::ApplyPrecomputedVisibility

						FCompressedVisibilityChunk& NewChunk = OutputBucket.CellDataChunks.Last();
						NewChunk.UncompressedSize = UncompressedVisibilityData.Num();
						NewChunk.bCompressed = true;
						NewChunk.Data.Empty(CompressedSize);
						NewChunk.Data.AddUninitialized(CompressedSize);
						FMemory::Memcpy(NewChunk.Data.GetData(), TempCompressionOutput.GetData(), CompressedSize);
						ChunkIndex++;
						TotalCompressedSize += CompressedSize;
						UncompressedVisibilityData.Reset();

file
function     void FLightmassProcessor::ApplyPrecomputedVisibility

						FCompressedVisibilityChunk& NewChunk = OutputBucket.CellDataChunks.Last();
						NewChunk.UncompressedSize = UncompressedVisibilityData.Num();
						NewChunk.bCompressed = false;
						NewChunk.Data = UncompressedVisibilityData;
						ChunkIndex++;
						TotalCompressedSize += UncompressedVisibilityData.Num();
						UncompressedVisibilityData.Reset();
					}
				}

file
namespace    unsync
function     FBuildTargetResult BuildTarget
lambda-function

					// TODO: avoid this copy by storing IOBuffer in DownloadedBlock
					bool	  bCompressed	 = Block.IsCompressed();
					uint64	  DownloadedSize = bCompressed ? Block.CompressedSize : Block.DecompressedSize;
					FIOBuffer DownloadedData = FIOBuffer::Alloc(DownloadedSize, L"downloaded_data");
					memcpy(DownloadedData.GetData(), Block.Data, DownloadedSize);

					DecompressionSemaphore.Acquire();

					DecompressTasks.run(

file
namespace    unsync
function     FBuildTargetResult BuildTarget
lambda-function
lambda-function

						 DownloadedData	  = std::make_shared<FIOBuffer>(std::move(DownloadedData)),
						 DecompressedSize = Block.DecompressedSize,
						 bCompressed,
						 ParentThreadIndent,
						 StrongHasher,
						 &BlockScatterMap,
						 &DownloadedBlocksMutex,
						 &DownloadedBlocks,
						 &DecompressionSemaphore,

file
lambda-function
lambda-function

							if (DecompressedSize == Cmd.Size)
							{
								if (bCompressed)
								{
									DecompressedData = FIOBuffer::Alloc(Cmd.Size, L"decompressed_data");

									bOk = Decompress(DownloadedData->GetData(),
													 DownloadedData->GetSize(),
													 DecompressedData.GetData(),

file
function     bool FIoChunkEncoding::Encode
lambda-function

			int32 CompressedSize = int32(Block.Buffer.GetSize());
			const bool bCompressed = FCompression::CompressMemory(
				Params.CompressionFormat,
				Block.Buffer.GetData(),
				CompressedSize,
				RawBlock.GetData(),
				static_cast<int32>(RawBlock.GetSize()),
				COMPRESS_ForPackaging);

			if (bCompressed == false)
			{
				Block.Size = 0;
				return;
			}

			Block.Size = CompressedSize;

file
class        class FIoStoreWriter : public IIoStoreWriter
function     void CompressBlock

		check(Block->CompressionMethod != NAME_None);
		int32 CompressedBlockSize = int32(Block->IoBuffer->DataSize());
		bool bCompressed;
		{
			bCompressed = FCompression::CompressMemoryIfWorthDecompressing(
				Block->CompressionMethod,
				WriterContext->WriterSettings.CompressionMinBytesSaved,
				WriterContext->WriterSettings.CompressionMinPercentSaved,
				Block->IoBuffer->Data(),
				CompressedBlockSize,
				Block->UncompressedData,

file
class        class FIoStoreWriter : public IIoStoreWriter
function     void CompressBlock

				COMPRESS_ForPackaging);
		}
		if (!bCompressed)
		{
			Block->CompressionMethod = NAME_None;
			Block->CompressedSize = Block->UncompressedSize;
			FMemory::Memcpy(Block->IoBuffer->Data(), Block->UncompressedData, Block->UncompressedSize);
		}
		else

file
function     FMD5Hash FDatasmithPackedMeshes::Serialize

FMD5Hash FDatasmithPackedMeshes::Serialize(FArchive& Ar, bool bCompressed)
{
	using namespace DatasmithMeshSerializationImpl;

	// structure          from
	// | Guard           | v0 | constant string, prevents loading of invalid buffers
	// | SerialVersion   | v0 | this structure versioning

file
function     FMD5Hash FDatasmithPackedMeshes::Serialize

	enum EBufferType{ RawMeshDescription, CompressedMeshDescription };
	uint8 BufferType = bCompressed ? CompressedMeshDescription : RawMeshDescription;
	Ar << BufferType;

	FMD5Hash OutHash;
	if (Ar.IsLoading())
	{
		// versioning

file
class        class FCompressedVisibilityChunk

public:
	/** Whether the chunk is compressed. */
	bool bCompressed;

	/** Size of the uncompressed chunk. */
	int32 UncompressedSize;

	/** Compressed visibility data if bCompressed is true. */
	TArray<uint8> Data;

file
class        class FCompressedVisibilityChunk
function     FArchive& operator<<

	friend FArchive& operator<<( FArchive& Ar, FCompressedVisibilityChunk& D )
	{
		Ar << D.bCompressed << D.UncompressedSize << D.Data;
		return Ar;
	}
};

/** A bucket of visibility cells that have the same spatial hash. */
class FPrecomputedVisibilityBucket

	/** Whether the bulk data is compressed or not */
	UPROPERTY()
	bool bCompressed = false;

	FByteBulkData BulkData;

	void Serialize(FArchive& Ar, UObject* Owner, uint32 SaveOverrideFlags);
};

file
function     bool FLandscapeTextureDataInfo::UpdateTextureData

bool FLandscapeTextureDataInfo::UpdateTextureData()
{
	const bool bCompressed = !Texture->CompressionNone;

	bool bNeedToWaitForUpdate = false;
	int32 DataSize = sizeof(FColor);
	if (Texture->GetPixelFormat() == PF_G8)
	{
		DataSize = sizeof(uint8);

file
function     bool FLandscapeTextureDataInfo::UpdateTextureData

		if (MipInfo[i].MipData && MipInfo[i].MipUpdateRegions.Num() > 0)
		{
			if (bCompressed)
			{
				bNeedToWaitForUpdate = true;
				// Cannot update regions on compressed textures so we will update the whole texture below.
				break;
			}

file
function     void FLandscapeTexture2DMipMap::Serialize

	Ar << SizeX;
	Ar << SizeY;
	Ar << bCompressed;
	BulkData.SerializeWithFlags(Ar, Owner, SaveOverrideFlags);
}

template<typename T, typename F>
static bool SerializeArray(FArchive& Ar, TArray<T>& Array, F&& SerializeElementFn)
{

file
function     ULandscapeTextureStorageProviderFactory* ULandscapeTextureStorageProviderFactory::ApplyTo

		if ((MipWidth <= UncompressedMipSizeThreshold) || (MipHeight <= UncompressedMipSizeThreshold))
		{
			Mip->bCompressed = false;
			CopyMipToBulkData(MipIndex, MipWidth, MipHeight, MipData.GetData(), MipData.Num(), Mip->BulkData);
		}
		else
		{
			Mip->bCompressed = true;
			CompressMipToBulkData(MipIndex, MipWidth, MipHeight, MipData.GetData(), MipData.Num(), Mip->BulkData);
		}

		MipWidth >>= 1;
		MipHeight >>= 1;
	}

file
function     void ULandscapeTextureStorageProviderFactory::DecompressMip

	FLandscapeTexture2DMipMap& Mip = Mips[MipIndex];

	if (!Mip.bCompressed)
	{
		// mip is uncompressed, just copy it
		check(SourceDataBytes == DestDataBytes);
		memcpy(DestData, SourceData, DestDataBytes);
		return;
	}

	check(Mip.bCompressed);

	int32 TotalPixels = Mip.SizeX * Mip.SizeY;
	check(SourceDataBytes == (TotalPixels + (Mip.SizeX + Mip.SizeY) * 2 - 4) * 2);
	check(DestDataBytes == TotalPixels * 4);

	// Undo Delta Encode of Heights

file
function     UImageSequenceProtocol_EXR::UImageSequenceProtocol_EXR

{
	Format = EImageFormat::EXR;
	bCompressed = false;
	CaptureGamut = HCGM_Rec709;
}

bool UImageSequenceProtocol_EXR::SetupImpl()
{
	{

file
function     bool UImageSequenceProtocol_EXR::SetupImpl

	if ( FParse::Value( FCommandLine::Get(), TEXT( "-HDRCompressionQuality=" ), HDRCompressionQuality ) )
	{
		bCompressed = HDRCompressionQuality != (int32)EImageCompressionQuality::Uncompressed;
	}

	EDisplayOutputFormat DisplayOutputFormat = HDRGetDefaultDisplayOutputFormat();
	EDisplayColorGamut DisplayColorGamut = HDRGetDefaultDisplayColorGamut();
	bool bHDREnabled = IsHDREnabled() && GRHISupportsHDROutput;

file
function     void UImageSequenceProtocol_EXR::AddFormatMappingsImpl

void UImageSequenceProtocol_EXR::AddFormatMappingsImpl(TMap<FString, FStringFormatArg>& FormatMappings) const
{
	FormatMappings.Add(TEXT("quality"), bCompressed ? TEXT("Compressed") : TEXT("Uncompressed"));

	const TCHAR* GamutString = TEXT("");
	switch (CaptureGamut)
	{
		case HCGM_Rec709:  GamutString = TEXT("sRGB"); break;
		case HCGM_P3DCI:   GamutString = TEXT("P3D65"); break;

file
class        class UImageSequenceProtocol_EXR : public UImageSequenceProtocol

	/** Whether to write out compressed or uncompressed EXRs */
	UPROPERTY(config, EditAnywhere, Category=ImageSettings)
	bool bCompressed;

	/** The color gamut to use when storing HDR captured data. */
	UPROPERTY(config, EditAnywhere, Category=ImageSettings)
	TEnumAsByte<EHDRCaptureGamut> CaptureGamut;

	MOVIESCENECAPTURE_API UImageSequenceProtocol_EXR(const FObjectInitializer& ObjInit);

private:
	virtual int32 GetCompressionQuality() const override { return bCompressed ? (int32)EImageCompressionQuality::Default : (int32)EImageCompressionQuality::Uncompressed; }
	MOVIESCENECAPTURE_API virtual bool SetupImpl() override;
	MOVIESCENECAPTURE_API virtual void FinalizeImpl() override;
	MOVIESCENECAPTURE_API virtual void AddFormatMappingsImpl(TMap<FString, FStringFormatArg>& FormatMappings) const override;

	EDisplayColorGamut RestoreColorGamut;
	EDisplayOutputFormat RestoreOutputDevice;

file
function     bool FLocalFileNetworkReplayStreamer::ReadReplayInfo

				Archive << Compressed;

				Info.bCompressed = (Compressed != 0);
			}

			if (SerializationInfo.GetLocalFileReplayVersion() >= FLocalFileReplayCustomVersion::EncryptionSupport)
			{
				uint32 Encrypted;
				Archive << Encrypted;

file
function     bool FLocalFileNetworkReplayStreamer::ReadReplayInfo

						DataChunk.ReplayDataOffset = Archive.Tell();
	
						if (Info.bCompressed)
						{
							DataChunk.MemorySizeInBytes = GetDecompressedSizeBackCompat(Archive);
						}
						else
						{
							DataChunk.MemorySizeInBytes = DataChunk.SizeInBytes;

file
function     void FLocalFileNetworkReplayStreamer::GotoCheckpointIndex
lambda-function

							TArray<uint8> UncompressedData;

							if (TaskReplayInfo.bCompressed)
							{
								if (SupportsCompression())
								{
									SCOPE_CYCLE_COUNTER(STAT_LocalReplay_DecompressTime);

									if (!DecompressBuffer(PlaintextData, UncompressedData))

file
function     void FLocalFileNetworkReplayStreamer::GotoCheckpointIndex
lambda-function

					}

				if (TaskReplayInfo.bCompressed)
					{
						if (SupportsCompression())
						{
							SCOPE_CYCLE_COUNTER(STAT_LocalReplay_DecompressTime);

							TArray<uint8> UncompressedData;

file
function     void FLocalFileNetworkReplayStreamer::ConditionallyLoadNextChunk
lambda-function

					}

				if (TaskReplayInfo.bCompressed)
					{
						if (SupportsCompression())
						{
							SCOPE_CYCLE_COUNTER(STAT_LocalReplay_DecompressTime);

							TArray<uint8> UncompressedData;

file
function     FLocalFileReplayInfo

		bIsLive(false),
		bIsValid(false),
		bCompressed(false),
		bEncrypted(false),
		HeaderChunkIndex(INDEX_NONE)
	{}

	int32 LengthInMS;
	uint32 NetworkVersion;

	bool bIsLive;
	bool bIsValid;
	bool bCompressed;

	bool bEncrypted;
	TArray<uint8> EncryptionKey;

	int32 HeaderChunkIndex;

file
namespace    BuildPatchServices
function     FFileAttributes::FFileAttributes

	FFileAttributes::FFileAttributes()
		: bReadOnly(false)
		, bCompressed(false)
		, bUnixExecutable(false)
	{}

	class FFileAttributesParserImpl
		: public FFileAttributesParser
	{

file
namespace    BuildPatchServices
function     FFileAttributesParserImpl::FFileAttributesParserImpl
lambda-function

	{
		AttributeSetters.Add(TEXT("readonly"),   [](FFileAttributes& Attributes, FString Value){ Attributes.bReadOnly = true; });
		AttributeSetters.Add(TEXT("compressed"), [](FFileAttributes& Attributes, FString Value){ Attributes.bCompressed = true; });
		AttributeSetters.Add(TEXT("executable"), [](FFileAttributes& Attributes, FString Value){ Attributes.bUnixExecutable = true; });
		AttributeSetters.Add(TEXT("tag"),        [](FFileAttributes& Attributes, FString Value){ Attributes.InstallTags.Add(MoveTemp(Value)); });
	}

	FFileAttributesParserImpl::~FFileAttributesParserImpl()
	{

file
namespace    BuildPatchServices

	{
		bool bReadOnly;
		bool bCompressed;
		bool bUnixExecutable;
		TSet<FString> InstallTags;
		FFileAttributes();
	};

	class FFileAttributesParser

file
namespace    BuildPatchServices
function     bool FManifestBuilder::FinalizeData

				FileManifest.FileMetaFlags |= EFileMetaFlags::ReadOnly;
			}
			if (FileAttributes.bCompressed)
			{
				FileManifest.FileMetaFlags |= EFileMetaFlags::Compressed;
			}
			if (FileAttributes.bUnixExecutable || FileSpan.IsUnixExecutable)
			{
				FileManifest.FileMetaFlags |= EFileMetaFlags::UnixExecutable;

	GLenum Format = GL_NONE;
	GLenum Type = GL_NONE;
	bool bCompressed = false;
	// Reorder to B and R elements using texture swizzle
	bool bBGRA = false;

	FOpenGLTextureFormat() = default;

	FOpenGLTextureFormat(

file
function     FOpenGLTextureFormat

		Format = InFormat;
		Type = InType;
		bCompressed = bInCompressed;
		bBGRA = bInBGRA;
	}
};

extern FOpenGLTextureFormat OPENGLDRV_API GOpenGLTextureFormats[PF_MAX];

file
class        class FOpenGLProgramBinaryCache

		TArray<ANSICHAR> GlslCode;
		int32 UncompressedSize;
		bool bCompressed;
	};

private:
	static TAutoConsoleVariable<int32> CVarPBCEnable;
	static TAutoConsoleVariable<int32> CVarRestartAndroidAfterPrecompile;
	static FOpenGLProgramBinaryCache* CachePtr;

file
class        class FOpenGLCompiledShaderValue
function     void CompressShader

		GlslCode.SetNumUninitialized(CompressedSize);

		bool bCompressed = FCompression::CompressMemory(
			CompressionMethod,
			(void*)GlslCode.GetData(),
			CompressedSize,
			(void*)InGlslCode.GetData(),
			UncompressedSize,
			COMPRESS_BiasSpeed);

		if (bCompressed)
		{
			// shrink buffer
			GlslCode.SetNum(CompressedSize, EAllowShrinking::Yes);
		}
		else
		{

file
function     void FOpenGLDynamicRHI::InitializeGLTexture

		EPixelFormat PixelFormat = Texture->GetFormat();
		const FOpenGLTextureFormat& GLFormat = GOpenGLTextureFormats[PixelFormat];
		bool bIsCompressed = GLFormat.bCompressed;
		GTotalCompressedTexStorageSkipped += bIsCompressed ? 1 : 0;

		if (BulkDataPtr)
		{
			check(!GLFormat.bCompressed);
			const uint32 BlockSizeX = GPixelFormats[PixelFormat].BlockSizeX;
			const uint32 BlockSizeY = GPixelFormats[PixelFormat].BlockSizeY;

			uint8* Data = (uint8*)BulkDataPtr;
			uint32 MipOffset = 0;

file
lambda-function

								return false;

							if (GLFormat.bCompressed)
							{
								glCompressedTexSubImage2D(
									CurrentTarget,
									MipIndex,
									0, 0, // X/Y offset
									MipSizeX, MipSizeY,

file
lambda-function

								return false;

							if (GLFormat.bCompressed)
							{
								glCompressedTexSubImage3D(
									CurrentTarget,
									MipIndex,
									0, 0, ArraySlice, // X/Y/Z offset
									MipSizeX, MipSizeY, MipSizeZ,

file
function     void FOpenGLTexture::Resolve

		else
		{
			if (GLFormat.bCompressed)
			{
				FOpenGL::GetCompressedTexImage(
											   bCubemap ? GL_TEXTURE_CUBE_MAP_POSITIVE_X + ArrayIndex : Target,
											   MipIndex,
											   0);	// offset into PBO
			}

file
function     void FOpenGLTexture::Fill2DGLTextureImage

void FOpenGLTexture::Fill2DGLTextureImage(const FOpenGLTextureFormat& GLFormat, const bool bSRGB, uint32 MipIndex, const void* BufferOrPBOOffset, uint32 ImageSize, uint32 ArrayIndex)
{
	if (GLFormat.bCompressed)
	{
		if (GetAllocatedStorageForMip(MipIndex,ArrayIndex))
		{
			glCompressedTexSubImage2D(
				bCubemap ? GL_TEXTURE_CUBE_MAP_POSITIVE_X + ArrayIndex : Target,
				MipIndex,

file
function     void FOpenGLTexture::Unlock

		if (GetDesc().IsTextureArray() || GetDesc().IsTexture3D())
		{
			if (GLFormat.bCompressed)
			{
				FOpenGL::CompressedTexSubImage3D(
					Target,
					MipIndex,
					0,
					0,

file
function     void FOpenGLDynamicRHI::RHIUpdateTexture2D
lambda-function

		glPixelStorei(GL_UNPACK_ALIGNMENT, 1);

		if (GLFormat.bCompressed)
		{
			glCompressedTexSubImage2D(
				Texture->Target,
				MipIndex,
				UpdateRegion.DestX, UpdateRegion.DestY,
				UpdateRegion.Width, UpdateRegion.Height,

file
function     void FOpenGLDynamicRHI::RHIUpdateTexture3D
lambda-function

		const bool bSRGB = EnumHasAnyFlags(Texture->GetFlags(), TexCreate_SRGB);

		if (GLFormat.bCompressed)
		{
			FOpenGL::CompressedTexSubImage3D(
				Texture->Target,
				MipIndex,
				UpdateRegion.DestX, UpdateRegion.DestY, UpdateRegion.DestZ,
				UpdateRegion.Width, UpdateRegion.Height, UpdateRegion.Depth,

file
function     bool UE::PipelineCacheUtilities::SaveStablePipelineCacheFile

		int32 RealCompressedSize = CompressedSizeEstimate;
		const bool bCompressed = FCompression::CompressMemory(
			UE::PipelineCacheUtilities::Private::FStablePipelineCacheSerializedHeader::CompressionMethod,
			CompressedMemory.GetData(),
			RealCompressedSize,
			UncompressedMemory.GetData(),
			UncompressedMemory.Num());

		// if the compression results are worse, just store uncompressed data
		if (!bCompressed || RealCompressedSize >= UncompressedMemory.Num())
		{
			CompressedMemory = UncompressedMemory;
			Header.UncompressedSize = 0;
			Header.DataSize = UncompressedMemory.Num();
		}
		else

file
function     void FShaderCode::Compress

	// non-Oodle format names use the old API, for NAME_Oodle we replace the call with the custom invocation
	bool bCompressed = false;
	if (ShaderCompressionFormat != NAME_Oodle)
	{
		bCompressed = FCompression::CompressMemory(ShaderCompressionFormat, Compressed.GetData(), CompressedSize, ShaderCodeWithOptionalData.GetData(), ShaderCodeWithOptionalData.Num(), COMPRESS_BiasSize);
	}
	else
	{
		CompressedSize = FOodleDataCompression::Compress(Compressed.GetData(), CompressedSize, ShaderCodeWithOptionalData.GetData(), ShaderCodeWithOptionalData.Num(),
			InOodleCompressor, InOodleLevel);
		bCompressed = CompressedSize != 0;
	}

	// there is code that assumes that if CompressedSize == CodeSize, the shader isn't compressed. Because of that, do not accept equal compressed size (very unlikely anyway)
	if (bCompressed && CompressedSize < ShaderCodeWithOptionalData.Num())
	{
		// cache the ShaderCodeSize since it will no longer possible to get it as the reader will fail to parse the compressed data
		FShaderCodeReader Wrapper(ShaderCodeWithOptionalData);
		ShaderCodeSize = Wrapper.GetShaderCodeSize();
		checkf(ShaderCodeSize >= 0, TEXT("Unable to determine ShaderCodeSize from uncompressed code"), ShaderCodeSize);

	const FLumenSurfaceLayerConfig& Config = GetSurfaceLayerConfig(LayerId);
	ETextureCreateFlags TexFlags = TexCreate_ShaderResource | TexCreate_NoFastClear;
	const bool bCompressed = PhysicalAtlasCompression != ESurfaceCacheCompression::Disabled && Config.CompressedFormat != PF_Unknown;

	// Without compression we can write directly into this surface
	if (!bCompressed)
	{
		TexFlags |= TexCreate_RenderTargetable;
	}

	FRDGTextureDesc CreateInfo = FRDGTextureDesc::Create2D(
		PageAtlasSize,
		bCompressed ? Config.CompressedFormat : Config.UncompressedFormat,
		FClearValueBinding::None,
		TexFlags);

	// With UAV aliasing we can directly write into a BC target by overriding UAV format
	if (PhysicalAtlasCompression == ESurfaceCacheCompression::UAVAliasing && Config.CompressedFormat != PF_Unknown)
	{

file
function     const uint8* FSceneViewState::GetPrecomputedVisibilityData

					CachedVisibilityHandlerId = InScene->PrecomputedVisibilityHandler->GetId();

					if (CompressedChunk.bCompressed)
					{
						// Decompress the needed visibility data chunk
						DecompressedVisibilityChunk.Reset();
						DecompressedVisibilityChunk.AddUninitialized(CompressedChunk.UncompressedSize);
						verify(FCompression::UncompressMemory(
							NAME_Zlib, 

			// if ProjectPackagingSettings/bCompressed is true but you really don't want compression, use "-forceuncompressed"
			bool bCompressed_ProjectPackagingSettings = false;
			PlatformGameConfig.GetBool("/Script/UnrealEd.ProjectPackagingSettings", "bCompressed", out bCompressed_ProjectPackagingSettings);

			bool bForceUseProjectCompressionFormatIgnoreHardwareOverride = false;// do we want to override HW compression with project? if so, read it below
			PlatformGameConfig.GetBool("/Script/UnrealEd.ProjectPackagingSettings", "bForceUseProjectCompressionFormatIgnoreHardwareOverride", out bForceUseProjectCompressionFormatIgnoreHardwareOverride);

			string HardwareCompressionFormat = null;
			if ( ! bForceUseProjectCompressionFormatIgnoreHardwareOverride )