using System;

using System.Collections.Generic;

using System.Diagnostics;

using System.IO;

using BCnEncoder.Encoder.Bc7;

using BCnEncoder.Shared;

namespace BCnEncoder.Encoder

{

public class EncoderInputOptions

{

/// <summary>

/// If true, when encoding to a format that only includes a red channel,

/// use the pixel luminance instead of just the red channel. Default is false.

/// </summary>

public bool luminanceAsRed = false;

}

public class EncoderOutputOptions

{

/// <summary>

/// The compression format to use. Default is BC1.

/// </summary>

public CompressionFormat format = CompressionFormat.BC1;

/// <summary>

/// The quality of the compression. Use either fast or balanced for testing.

/// Fast can be used for near real-time encoding for most algorithms.

/// Use bestQuality when needed. Default is balanced.

/// </summary>

public CompressionQuality quality = CompressionQuality.Balanced;

/// <summary>

/// The output file format of the data. Either Ktx or Dds.

/// Default is Ktx.

/// </summary>

public OutputFileFormat fileFormat = OutputFileFormat.Ktx;

/// <summary>

/// The DDS file format doesn't seem to have a standard for indicating whether a BC1 texture

/// includes 1bit of alpha. This option will write DDPF_ALPHAPIXELS flag to the header

/// to indicate the presence of an alpha channel. Some programs read and write this flag,

/// but some programs don't like it and get confused. Your mileage may vary.

/// Default is false.

/// </summary>

public bool ddsBc1WriteAlphaFlag = false;

}

public class EncoderOptions {

/// <summary>

/// Whether the blocks should be encoded in parallel. This can be much faster than single-threaded encoding,

/// but is slow if multiple textures are being processed at the same time.

/// When a debugger is attached, the encoder defaults to single-threaded operation to ease debugging.

/// Default is true.

/// </summary>

public bool multiThreaded = true;

}

/// <summary>

/// Handles all encoding of images into compressed or uncompressed formats. For decoding, <see cref="Decoder.BcDecoder"/>

/// </summary>

public class BcEncoder

{

public EncoderInputOptions InputOptions { get; set; } = new EncoderInputOptions();

public EncoderOutputOptions OutputOptions { get; set; } = new EncoderOutputOptions();

public EncoderOptions Options { get; set; } = new EncoderOptions();

public BcEncoder() { }

public BcEncoder(CompressionFormat format)

{

OutputOptions.format = format;

}

private IBcBlockEncoder GetEncoder(CompressionFormat format)

{

switch (format)

{

case CompressionFormat.BC1:

return new Bc1BlockEncoder();

case CompressionFormat.BC1WithAlpha:

return new Bc1AlphaBlockEncoder();

case CompressionFormat.BC2:

return new Bc2BlockEncoder();

case CompressionFormat.BC3:

return new Bc3BlockEncoder();

case CompressionFormat.BC4:

return new Bc4BlockEncoder(InputOptions.luminanceAsRed);

case CompressionFormat.BC5:

return new Bc5BlockEncoder();

case CompressionFormat.BC7:

return new Bc7Encoder();

default:

return null;

}

}

/// <summary>

/// Encodes all mipmap levels into a ktx or a dds file and writes it to the output stream.

/// </summary>

public void Encode(byte[] inputImageRgba, int inputImageWidth, int inputImageHeight, Stream outputStream)

{

if (OutputOptions.fileFormat == OutputFileFormat.Ktx)

{

KtxFile output = EncodeToKtx(inputImageRgba, inputImageWidth, inputImageHeight);

output.Write(outputStream);

}

else if (OutputOptions.fileFormat == OutputFileFormat.Dds)

{

DdsFile output = EncodeToDds(inputImageRgba, inputImageWidth, inputImageHeight);

output.Write(outputStream);

}

}

/// <summary>

/// Encodes all mipmap levels into a Ktx file.

/// </summary>

public KtxFile EncodeToKtx(byte[] inputImageRgba, int inputImageWidth, int inputImageHeight)

{

KtxFile output;

IBcBlockEncoder compressedEncoder = null;

compressedEncoder = GetEncoder(OutputOptions.format);

if (compressedEncoder == null)

{

throw new NotSupportedException($"This format is not supported: {OutputOptions.format}");

}

output = new KtxFile(

KtxHeader.InitializeCompressed(inputImageWidth, inputImageHeight,

compressedEncoder.GetInternalFormat(),

compressedEncoder.GetBaseInternalFormat()));

uint numMipMaps = 1;

byte[] encoded = null;

if (OutputOptions.format.IsCompressedFormat())

{

var blocks = ImageToBlocks.ImageTo4X4(inputImageRgba, inputImageWidth, inputImageHeight, out int blocksWidth, out int blocksHeight);

encoded = compressedEncoder.Encode(blocks, blocksWidth, blocksHeight, OutputOptions.quality,

!Debugger.IsAttached && Options.multiThreaded);

}

output.MipMaps.Add(new KtxMipmap((uint)encoded.Length,

(uint)inputImageWidth,

(uint)inputImageHeight, 1));

output.MipMaps[0].Faces[0] = new KtxMipFace(encoded,

(uint)inputImageWidth,

(uint)inputImageHeight);

output.Header.NumberOfFaces = 1;

output.Header.NumberOfMipmapLevels = numMipMaps;

return output;

}

/// <summary>

/// Encodes Rgba image into a Dds file.

/// </summary>

public DdsFile EncodeToDds(byte[] inputImageRgba, int inputImageWidth, int inputImageHeight)

{

DdsFile output;

IBcBlockEncoder compressedEncoder = null;

compressedEncoder = GetEncoder(OutputOptions.format);

if (compressedEncoder == null)

{

throw new NotSupportedException($"This format is not supported: {OutputOptions.format}");

}

DdsHeaderDxt10 dxt10Header;

var ddsHeader = DdsHeader.InitializeCompressed(inputImageWidth, inputImageHeight,

compressedEncoder.GetDxgiFormat(), out dxt10Header);

output = new DdsFile(ddsHeader, dxt10Header);

if (OutputOptions.ddsBc1WriteAlphaFlag &&

OutputOptions.format == CompressionFormat.BC1WithAlpha)

{

output.Header.ddsPixelFormat.dwFlags |= PixelFormatFlags.DDPF_ALPHAPIXELS;

}

uint numMipMaps = 1;

var blocks = ImageToBlocks.ImageTo4X4(inputImageRgba, inputImageWidth, inputImageHeight, out int blocksWidth, out int blocksHeight);

var encoded = compressedEncoder.Encode(blocks, blocksWidth, blocksHeight, OutputOptions.quality,

!Debugger.IsAttached && Options.multiThreaded);

output.Faces.Add(new DdsFace((uint)inputImageWidth, (uint)inputImageHeight,

(uint)encoded.Length, (int)numMipMaps));

output.Faces[0].MipMaps[0] = new DdsMipMap(encoded,

(uint)inputImageWidth,

(uint)inputImageHeight);

output.Header.dwMipMapCount = numMipMaps;

if (numMipMaps > 1)

{

output.Header.dwCaps |= HeaderCaps.DDSCAPS_COMPLEX | HeaderCaps.DDSCAPS_MIPMAP;

}

return output;

}

/// <summary>

/// Encodes an RGBA byte buffer to raw compressed bytes

/// </summary>

public byte[] EncodeToRawBytes(byte[] inputImageRgba, int inputImageWidth, int inputImageHeight, out int outputImageWidth, out int outputImageHeight)

{

IBcBlockEncoder compressedEncoder = GetEncoder(OutputOptions.format);

if (compressedEncoder == null)

{

throw new NotSupportedException($"This format is not supported: {OutputOptions.format}");

}

var blocks = ImageToBlocks.ImageTo4X4(inputImageRgba, inputImageWidth, inputImageHeight, out int blocksWidth, out int blocksHeight);

var encoded = compressedEncoder.Encode(blocks, blocksWidth, blocksHeight, OutputOptions.quality,

!Debugger.IsAttached && Options.multiThreaded);

outputImageWidth = blocksWidth * 4;

outputImageHeight = blocksHeight * 4;

return encoded;

}

/// <summary>

/// Encodes a single mip level of the input image to a byte buffer.

/// </summary>

//public byte[] EncodeToRawBytes(Image<Rgba32> inputImage, int mipLevel, out int mipWidth, out int mipHeight)

//{

// if (mipLevel < 0)

// {

// throw new ArgumentException($"{nameof(mipLevel)} cannot be less than zero.");

// }

// IBcBlockEncoder compressedEncoder = null;

// IRawEncoder uncompressedEncoder = null;

// if (OutputOptions.format.IsCompressedFormat())

// {

// compressedEncoder = GetEncoder(OutputOptions.format);

// if (compressedEncoder == null)

// {

// throw new NotSupportedException($"This format is not supported: {OutputOptions.format}");

// }

// }

// else

// {

// uncompressedEncoder = GetRawEncoder(OutputOptions.format);

// }

// uint numMipMaps = (uint)OutputOptions.maxMipMapLevel;

// if (!OutputOptions.generateMipMaps)

// {

// numMipMaps = 1;

// }

// var mipChain = MipMapper.GenerateMipChain(inputImage, ref numMipMaps);

// if (mipLevel > numMipMaps - 1)

// {

// foreach (var image in mipChain)

// {

// image.Dispose();

// }

// throw new ArgumentException($"{nameof(mipLevel)} cannot be more than number of mipmaps");

// }

// byte[] encoded = null;

// if (OutputOptions.format.IsCompressedFormat())

// {

// var blocks = ImageToBlocks.ImageTo4X4(mipChain[mipLevel].Frames[0], out int blocksWidth, out int blocksHeight);

// encoded = compressedEncoder.Encode(blocks, blocksWidth, blocksHeight, OutputOptions.quality,

// !Debugger.IsAttached && Options.multiThreaded);

// }

// else

// {

// if (!mipChain[mipLevel].TryGetSinglePixelSpan(out var mipPixels)) {

// throw new Exception("Cannot get pixel span.");

// }

// encoded = uncompressedEncoder.Encode(mipPixels);

// }

// mipWidth = mipChain[mipLevel].Width;

// mipHeight = mipChain[mipLevel].Height;

// foreach (var image in mipChain)

// {

// image.Dispose();

// }

// return encoded;

//}

/// <summary>

/// Encodes all cubemap faces and mipmap levels into Ktx file and writes it to the output stream.

/// Order is +X, -X, +Y, -Y, +Z, -Z

/// </summary>

//public void EncodeCubeMap(Image<Rgba32> right, Image<Rgba32> left, Image<Rgba32> top, Image<Rgba32> down,

// Image<Rgba32> back, Image<Rgba32> front, Stream outputStream)

//{

// if (OutputOptions.fileFormat == OutputFileFormat.Ktx)

// {

// KtxFile output = EncodeCubeMapToKtx(right, left, top, down, back, front);

// output.Write(outputStream);

// }

// else if (OutputOptions.fileFormat == OutputFileFormat.Dds)

// {

// DdsFile output = EncodeCubeMapToDds(right, left, top, down, back, front);

// output.Write(outputStream);

// }

//}

/// <summary>

/// Encodes all cubemap faces and mipmap levels into a Ktx file.

/// Order is +X, -X, +Y, -Y, +Z, -Z. Back maps to positive Z and front to negative Z.

/// </summary>

//public KtxFile EncodeCubeMapToKtx(Image<Rgba32> right, Image<Rgba32> left, Image<Rgba32> top, Image<Rgba32> down,

// Image<Rgba32> back, Image<Rgba32> front)

//{

// KtxFile output;

// IBcBlockEncoder compressedEncoder = null;

// IRawEncoder uncompressedEncoder = null;

// if (right.Width != left.Width || right.Width != top.Width || right.Width != down.Width

// || right.Width != back.Width || right.Width != front.Width ||

// right.Height != left.Height || right.Height != top.Height || right.Height != down.Height

// || right.Height != back.Height || right.Height != front.Height)

// {

// throw new ArgumentException("All input images of a cubemap should be the same size.");

// }

// Image<Rgba32>[] faces = new[] { right, left, top, down, back, front };

// if (OutputOptions.format.IsCompressedFormat())

// {

// compressedEncoder = GetEncoder(OutputOptions.format);

// if (compressedEncoder == null)

// {

// throw new NotSupportedException($"This format is not supported: {OutputOptions.format}");

// }

// output = new KtxFile(

// KtxHeader.InitializeCompressed(right.Width, right.Height,

// compressedEncoder.GetInternalFormat(),

// compressedEncoder.GetBaseInternalFormat()));

// }

// else

// {

// uncompressedEncoder = GetRawEncoder(OutputOptions.format);

// output = new KtxFile(

// KtxHeader.InitializeUncompressed(right.Width, right.Height,

// uncompressedEncoder.GetGlType(),

// uncompressedEncoder.GetGlFormat(),

// uncompressedEncoder.GetGlTypeSize(),

// uncompressedEncoder.GetInternalFormat(),

// uncompressedEncoder.GetBaseInternalFormat()));

// }

// uint numMipMaps = (uint)OutputOptions.maxMipMapLevel;

// if (!OutputOptions.generateMipMaps)

// {

// numMipMaps = 1;

// }

// uint mipLength = MipMapper.CalculateMipChainLength(right.Width, right.Height, numMipMaps);

// for (uint i = 0; i < mipLength; i++)

// {

// output.MipMaps.Add(new KtxMipmap(0, 0, 0, (uint)faces.Length));

// }

// for (int f = 0; f < faces.Length; f++)

// {

// var mipChain = MipMapper.GenerateMipChain(faces[f], ref numMipMaps);

// for (int i = 0; i < numMipMaps; i++)

// {

// byte[] encoded = null;

// if (OutputOptions.format.IsCompressedFormat())

// {

// var blocks = ImageToBlocks.ImageTo4X4(mipChain[i].Frames[0], out int blocksWidth, out int blocksHeight);

// encoded = compressedEncoder.Encode(blocks, blocksWidth, blocksHeight, OutputOptions.quality,

// !Debugger.IsAttached && Options.multiThreaded);

// }

// else

// {

// if (!mipChain[i].TryGetSinglePixelSpan(out var mipPixels)) {

// throw new Exception("Cannot get pixel span.");

// }

// encoded = uncompressedEncoder.Encode(mipPixels);

// }

// if (f == 0)

// {

// output.MipMaps[i] = new KtxMipmap((uint)encoded.Length,

// (uint)mipChain[i].Width,

// (uint)mipChain[i].Height, (uint)faces.Length);

// }

// output.MipMaps[i].Faces[f] = new KtxMipFace(encoded,

// (uint)mipChain[i].Width,

// (uint)mipChain[i].Height);

// }

// foreach (var image in mipChain)

// {

// image.Dispose();

// }

// }

// output.Header.NumberOfFaces = (uint)faces.Length;

// output.Header.NumberOfMipmapLevels = mipLength;

// return output;

//}

/// <summary>

/// Encodes all cubemap faces and mipmap levels into a Dds file.

/// Order is +X, -X, +Y, -Y, +Z, -Z. Back maps to positive Z and front to negative Z.

/// </summary>

//public DdsFile EncodeCubeMapToDds(Image<Rgba32> right, Image<Rgba32> left, Image<Rgba32> top, Image<Rgba32> down,

// Image<Rgba32> back, Image<Rgba32> front)

//{

// DdsFile output;

// IBcBlockEncoder compressedEncoder = null;

// IRawEncoder uncompressedEncoder = null;

// if (right.Width != left.Width || right.Width != top.Width || right.Width != down.Width

// || right.Width != back.Width || right.Width != front.Width ||

// right.Height != left.Height || right.Height != top.Height || right.Height != down.Height

// || right.Height != back.Height || right.Height != front.Height)

// {

// throw new ArgumentException("All input images of a cubemap should be the same size.");

// }

// Image<Rgba32>[] faces = new[] { right, left, top, down, back, front };

// if (OutputOptions.format.IsCompressedFormat())

// {

// compressedEncoder = GetEncoder(OutputOptions.format);

// if (compressedEncoder == null)

// {

// throw new NotSupportedException($"This format is not supported: {OutputOptions.format}");

// }

// var (ddsHeader, dxt10Header) = DdsHeader.InitializeCompressed(right.Width, right.Height,

// compressedEncoder.GetDxgiFormat());

// output = new DdsFile(ddsHeader, dxt10Header);

// if (OutputOptions.ddsBc1WriteAlphaFlag &&

// OutputOptions.format == CompressionFormat.BC1WithAlpha)

// {

// output.Header.ddsPixelFormat.dwFlags |= PixelFormatFlags.DDPF_ALPHAPIXELS;

// }

// }

// else

// {

// uncompressedEncoder = GetRawEncoder(OutputOptions.format);

// var ddsHeader = DdsHeader.InitializeUncompressed(right.Width, right.Height,

// uncompressedEncoder.GetDxgiFormat());

// output = new DdsFile(ddsHeader);

// }

// uint numMipMaps = (uint)OutputOptions.maxMipMapLevel;

// if (!OutputOptions.generateMipMaps)

// {

// numMipMaps = 1;

// }

// for (int f = 0; f < faces.Length; f++)

// {

// var mipChain = MipMapper.GenerateMipChain(faces[f], ref numMipMaps);

// for (int mip = 0; mip < numMipMaps; mip++)

// {

// byte[] encoded = null;

// if (OutputOptions.format.IsCompressedFormat())

// {

// var blocks = ImageToBlocks.ImageTo4X4(mipChain[mip].Frames[0], out int blocksWidth, out int blocksHeight);

// encoded = compressedEncoder.Encode(blocks, blocksWidth, blocksHeight, OutputOptions.quality,

// !Debugger.IsAttached && Options.multiThreaded);

// }

// else

// {

// if (!mipChain[mip].TryGetSinglePixelSpan(out var mipPixels)) {

// throw new Exception("Cannot get pixel span.");

// }

// encoded = uncompressedEncoder.Encode(mipPixels);

// }

// if (mip == 0)

// {

// output.Faces.Add(new DdsFace((uint)mipChain[mip].Width, (uint)mipChain[mip].Height,

// (uint)encoded.Length, mipChain.Count));

// }

// output.Faces[f].MipMaps[mip] = new DdsMipMap(encoded,

// (uint)mipChain[mip].Width,

// (uint)mipChain[mip].Height);

// }

// foreach (var image in mipChain)

// {

// image.Dispose();

// }

// }

// output.Header.dwCaps |= HeaderCaps.DDSCAPS_COMPLEX;

// output.Header.dwMipMapCount = numMipMaps;

// if (numMipMaps > 1)

// {

// output.Header.dwCaps |= HeaderCaps.DDSCAPS_MIPMAP;

// }

// output.Header.dwCaps2 |= HeaderCaps2.DDSCAPS2_CUBEMAP |

// HeaderCaps2.DDSCAPS2_CUBEMAP_POSITIVEX |

// HeaderCaps2.DDSCAPS2_CUBEMAP_NEGATIVEX |

// HeaderCaps2.DDSCAPS2_CUBEMAP_POSITIVEY |

// HeaderCaps2.DDSCAPS2_CUBEMAP_NEGATIVEY |

// HeaderCaps2.DDSCAPS2_CUBEMAP_POSITIVEZ |

// HeaderCaps2.DDSCAPS2_CUBEMAP_NEGATIVEZ;

// return output;

//}

}

}