Пример #1
0
    static void Main(string[] args)
    {
        var ImageConverter    = new ImageConverter();
        var compressionFormat = new BC1CompressionFormat();

        Console.WriteLine("Welcome to Image Converter. Currently supporting DDS -> BMP and BMP -> DDS");
        Console.WriteLine("Image Converter support 24bit bmp files and DXT1 DDS files");
        Console.WriteLine("Type file name.");

        var fileName = Console.ReadLine();

        if (fileName.ToLower().EndsWith(".dds"))
        {
            ImageConverter.ConvertDDSToBMP(fileName, compressionFormat);
        }
        else if (fileName.ToLower().EndsWith(".bmp"))
        {
            ImageConverter.ConvertBMPToDDS(fileName, compressionFormat);
        }
        else
        {
            Console.WriteLine("File format not supported.");
        }

        Console.ReadKey();
    }
Пример #2
0
        /// <summary>
        /// reads a dds file and outputs a bmp file
        /// </summary>
        /// <param name="fileName"></param>
        /// <param name="compressionFormat"></param>
        public void ConvertDDSToBMP(string fileName, BC1CompressionFormat compressionFormat)
        {
            var ddsFile = ReadDDSFile(fileName);

            if (!Helpers.FileDimensionsValid((int)ddsFile.DDSHeader.Width, (int)ddsFile.DDSHeader.Height))
            {
                throw new ArgumentException("DDS Image dimensions not valid");
            }
            fileName = fileName.Remove(fileName.Length - 4) + ".bmp";

            WriteBMPFile(fileName, ddsFile, compressionFormat);

            Console.WriteLine("Conversion complete, file created " + fileName);
        }
Пример #3
0
        /// <summary>
        /// reads a bmp file and outputs a DDS file
        /// </summary>
        /// <param name="fileName"></param>
        /// <param name="compressionFormat"></param>
        public void ConvertBMPToDDS(string fileName, BC1CompressionFormat compressionFormat)
        {
            var bmpFile = ReadBMPFile(fileName);

            if (!Helpers.FileDimensionsValid((int)bmpFile.BMPFileInfoHeader.Width, (int)bmpFile.BMPFileInfoHeader.Height))
            {
                throw new ArgumentException("BMP Image dimensions not valid");
            }

            fileName = fileName.Remove(fileName.Length - 4) + ".dds";

            WriteDDSFile(fileName, bmpFile, compressionFormat);
            Console.WriteLine("Conversion complete, file created " + fileName);
        }
Пример #4
0
        public void WriteDDSFile(string fileName, BMPFile bmpFile, BC1CompressionFormat compressionFormat)
        {
            using (BinaryWriter writer = new BinaryWriter(File.Open(fileName, FileMode.Create)))
            {
                var ddsFile = new DDSFile();
                writer.Write(Constants.DDSMagicNumber);

                //create default header
                ddsFile.DDSHeader = CreateHeader((int)bmpFile.BMPFileInfoHeader.Width, (int)bmpFile.BMPFileInfoHeader.Height, Helpers.BC1Unorm());

                var headerSize   = Marshal.SizeOf(typeof(DDSHeader));
                var headerBuffer = new byte[headerSize];

                // Populate header data directly from the bytebuffer
                GCHandle handle = GCHandle.Alloc(headerBuffer, GCHandleType.Pinned);
                Marshal.StructureToPtr(ddsFile.DDSHeader, handle.AddrOfPinnedObject(), true);
                handle.Free();

                writer.Write(headerBuffer);

                ddsFile.Data = new byte[ddsFile.DDSHeader.PitchOrLinearSize];

                int numberOfPixels         = (int)ddsFile.DDSHeader.Width * (int)ddsFile.DDSHeader.Height;
                int numberOfRequiredBlocks = numberOfPixels / Constants.TexelCount;
                int bufferSize             = numberOfRequiredBlocks * Constants.BC1ByteSize;
                ddsFile.Data = new byte[bufferSize];

                int numberOfVerticalBlocks   = (int)bmpFile.BMPFileInfoHeader.Height / Constants.BlockDimension;
                int numberOfHorizontalBlocks = (int)bmpFile.BMPFileInfoHeader.Width / Constants.BlockDimension;
                int numberOfBlocks           = numberOfVerticalBlocks * numberOfHorizontalBlocks;

                for (int i = 0; i < numberOfBlocks; ++i)
                {
                    var blockIndex  = Helpers.ToColumnMajor(i, numberOfHorizontalBlocks);
                    var blockColors = bmpFile.GetBlockColors(blockIndex);
                    var blockData   = compressionFormat.Compress(blockColors);

                    ddsFile.SetBlockData(blockIndex, blockData);
                }

                writer.Write(ddsFile.Data);
            }
        }
Пример #5
0
        private void WriteBMPFile(string fileName, DDSFile ddsFile, BC1CompressionFormat compressionFormat)
        {
            using (BinaryWriter writer = new BinaryWriter(File.Open(fileName, FileMode.Create)))
            {
                byte[] BMPMagicNumber = { 0x42, 0x4D };

                int BMPFileHeaderSize     = 14;
                int BMPFileInfoHeaderSize = 40;

                int imageRawSize = (int)ddsFile.DDSHeader.Width * (int)ddsFile.DDSHeader.Height * 3;
                int fileSize     = imageRawSize + BMPFileHeaderSize + BMPFileInfoHeaderSize;

                var bmpFile = new BMPFile();
                bmpFile.BMPFileHeader                 = new BMPFileHeader();
                bmpFile.BMPFileHeader.MagicHeader     = BMPMagicNumber;
                bmpFile.BMPFileHeader.Reserved1       = 0;
                bmpFile.BMPFileHeader.Reserved2       = 0;
                bmpFile.BMPFileHeader.FileSize        = (uint)fileSize;
                bmpFile.BMPFileHeader.OffToPixelArray = (uint)BMPFileHeaderSize + (uint)BMPFileInfoHeaderSize;

                bmpFile.BMPFileInfoHeader                         = new BMPFileInfoHeader();
                bmpFile.BMPFileInfoHeader.HeaderSize              = (uint)BMPFileInfoHeaderSize;
                bmpFile.BMPFileInfoHeader.Width                   = ddsFile.DDSHeader.Width;
                bmpFile.BMPFileInfoHeader.Height                  = ddsFile.DDSHeader.Height;
                bmpFile.BMPFileInfoHeader.ColorPlanes             = 1;
                bmpFile.BMPFileInfoHeader.BitCount                = 24;
                bmpFile.BMPFileInfoHeader.CompressionType         = 0;
                bmpFile.BMPFileInfoHeader.RawDataSize             = (uint)imageRawSize;
                bmpFile.BMPFileInfoHeader.HorizontalPixelPerMeter = 2835;
                bmpFile.BMPFileInfoHeader.VerticalPixelPerMeter   = 2835;
                bmpFile.BMPFileInfoHeader.ColorsUsed              = 0;
                bmpFile.BMPFileInfoHeader.ImportantColors         = 0;

                writer.Write(bmpFile.BMPFileHeader.MagicHeader);
                writer.Write(bmpFile.BMPFileHeader.FileSize);
                writer.Write(bmpFile.BMPFileHeader.Reserved1);
                writer.Write(bmpFile.BMPFileHeader.Reserved2);
                writer.Write(bmpFile.BMPFileHeader.OffToPixelArray);


                writer.Write(bmpFile.BMPFileInfoHeader.HeaderSize);
                writer.Write(bmpFile.BMPFileInfoHeader.Width);
                writer.Write(bmpFile.BMPFileInfoHeader.Height);
                writer.Write(bmpFile.BMPFileInfoHeader.ColorPlanes);
                writer.Write(bmpFile.BMPFileInfoHeader.BitCount);
                writer.Write(bmpFile.BMPFileInfoHeader.CompressionType);
                writer.Write(bmpFile.BMPFileInfoHeader.RawDataSize);
                writer.Write(bmpFile.BMPFileInfoHeader.HorizontalPixelPerMeter);
                writer.Write(bmpFile.BMPFileInfoHeader.VerticalPixelPerMeter);
                writer.Write(bmpFile.BMPFileInfoHeader.ColorsUsed);
                writer.Write(bmpFile.BMPFileInfoHeader.ImportantColors);

                bmpFile.PixelData = new byte[imageRawSize];

                int numberOfVerticalBlocks   = (int)ddsFile.DDSHeader.Height / Constants.BlockDimension;
                int numberOfHorizontalBlocks = (int)ddsFile.DDSHeader.Width / Constants.BlockDimension;
                int numberOfBlocks           = numberOfVerticalBlocks * numberOfHorizontalBlocks;

                for (int i = 0; i < numberOfBlocks; ++i)
                {
                    var blockIndex  = Helpers.ToColumnMajor(i, numberOfHorizontalBlocks);
                    var blockData   = ddsFile.GetBlockData(blockIndex);
                    var blockColors = compressionFormat.Decompress(blockData);

                    bmpFile.SetBlockColors(blockIndex, blockColors);
                }

                writer.Write(bmpFile.PixelData.FlipArrayHorizontal((int)bmpFile.BMPFileInfoHeader.Height));
            }
        }