added Vampyre Imaging Library; now textures can be in various formats, including...

[d2df-sdl.git] / src / lib / vampimg / ImagingDds.pas

{
  $Id: ImagingDds.pas 129 2008-08-06 20:01:30Z galfar $
  Vampyre Imaging Library
  by Marek Mauder
  http://imaginglib.sourceforge.net

  The contents of this file are used with permission, subject to the Mozilla
  Public License Version 1.1 (the "License"); you may not use this file except
  in compliance with the License. You may obtain a copy of the License at
  http://www.mozilla.org/MPL/MPL-1.1.html

  Software distributed under the License is distributed on an "AS IS" basis,
  WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for
  the specific language governing rights and limitations under the License.

  Alternatively, the contents of this file may be used under the terms of the
  GNU Lesser General Public License (the  "LGPL License"), in which case the
  provisions of the LGPL License are applicable instead of those above.
  If you wish to allow use of your version of this file only under the terms
  of the LGPL License and not to allow others to use your version of this file
  under the MPL, indicate your decision by deleting  the provisions above and
  replace  them with the notice and other provisions required by the LGPL
  License.  If you do not delete the provisions above, a recipient may use
  your version of this file under either the MPL or the LGPL License.

  For more information about the LGPL: http://www.gnu.org/copyleft/lesser.html
}

{ This unit contains image format loader/saver for DirectDraw Surface images.}
unit ImagingDds;

{$I ImagingOptions.inc}

interface

uses
  ImagingTypes, Imaging, ImagingUtility, ImagingFormats;

type
  { Class for loading and saving Microsoft DirectDraw surfaces.
    It can load/save all D3D formats which have coresponding
    TImageFormat. It supports plain textures, cube textures and
    volume textures, all of these can have mipmaps. It can also
    load some formats which have no exact TImageFormat, but can be easily
    converted to one (bump map formats).
    You can get some information about last loaded DDS file by calling
    GetOption with ImagingDDSLoadedXXX options and you can set some
    saving options by calling SetOption with ImagingDDSSaveXXX or you can
    simply use properties of this class.
    Note that when saving cube maps and volumes input image array must contain
    at least number of images to build cube/volume based on current
    Depth and MipMapCount settings.}
  TDDSFileFormat = class(TImageFileFormat)
  protected
    FLoadedCubeMap: LongBool;
    FLoadedVolume: LongBool;
    FLoadedMipMapCount: LongInt;
    FLoadedDepth: LongInt;
    FSaveCubeMap: LongBool;
    FSaveVolume: LongBool;
    FSaveMipMapCount: LongInt;
    FSaveDepth: LongInt;
    procedure ComputeSubDimensions(Idx, Width, Height, MipMaps, Depth: LongInt;
      IsCubeMap, IsVolume: Boolean; var CurWidth, CurHeight: LongInt);
    function LoadData(Handle: TImagingHandle; var Images: TDynImageDataArray;
      OnlyFirstLevel: Boolean): Boolean; override;
    function SaveData(Handle: TImagingHandle; const Images: TDynImageDataArray;
      Index: LongInt): Boolean; override;
    procedure ConvertToSupported(var Image: TImageData;
      const Info: TImageFormatInfo); override;
  public
    constructor Create; override;
    function TestFormat(Handle: TImagingHandle): Boolean; override;
    procedure CheckOptionsValidity; override;
  published
    { True if last loaded DDS file was cube map.}
    property LoadedCubeMap: LongBool read FLoadedCubeMap write FLoadedCubeMap;
    { True if last loaded DDS file was volume texture.}
    property LoadedVolume: LongBool read FLoadedVolume write FLoadedVolume;
    { Number of mipmap levels of last loaded DDS image.}
    property LoadedMipMapCount: LongInt read FLoadedMipMapCount write FLoadedMipMapCount;
    { Depth (slices of volume texture or faces of cube map) of last loaded DDS image.}
    property LoadedDepth: LongInt read FLoadedDepth write FLoadedDepth;
    { True if next DDS file to be saved should be stored as cube map.}
    property SaveCubeMap: LongBool read FSaveCubeMap write FSaveCubeMap;
    { True if next DDS file to be saved should be stored as volume texture.}
    property SaveVolume: LongBool read FSaveVolume write FSaveVolume;
    { Sets the number of mipmaps which should be stored in the next saved DDS file.
      Only applies to cube maps and volumes, ordinary 2D textures save all
      levels present in input.}
    property SaveMipMapCount: LongInt read FSaveMipMapCount write FSaveMipMapCount;
    { Sets the depth (slices of volume texture or faces of cube map)
      of the next saved DDS file.}
    property SaveDepth: LongInt read FSaveDepth write FSaveDepth;
  end;

implementation

const
  SDDSFormatName = 'DirectDraw Surface';
  SDDSMasks      = '*.dds';
  DDSSupportedFormats: TImageFormats = [ifR8G8B8, ifA8R8G8B8, ifX8R8G8B8,
    ifA1R5G5B5, ifA4R4G4B4, ifX1R5G5B5, ifX4R4G4B4, ifR5G6B5, ifA16B16G16R16,
    ifR32F, ifA32B32G32R32F, ifR16F, ifA16B16G16R16F, ifR3G3B2, ifGray8, ifA8Gray8,
    ifGray16, ifDXT1, ifDXT3, ifDXT5, ifATI1N, ifATI2N];

const
  { Four character codes.}
  DDSMagic    = LongWord(Byte('D') or (Byte('D') shl 8) or (Byte('S') shl 16) or
    (Byte(' ') shl 24));
  FOURCC_DXT1 = LongWord(Byte('D') or (Byte('X') shl 8) or (Byte('T') shl 16) or
    (Byte('1') shl 24));
  FOURCC_DXT3 = LongWord(Byte('D') or (Byte('X') shl 8) or (Byte('T') shl 16) or
    (Byte('3') shl 24));
  FOURCC_DXT5 = LongWord(Byte('D') or (Byte('X') shl 8) or (Byte('T') shl 16) or
    (Byte('5') shl 24));
  FOURCC_ATI1 = LongWord(Byte('A') or (Byte('T') shl 8) or (Byte('I') shl 16) or
    (Byte('1') shl 24));
  FOURCC_ATI2 = LongWord(Byte('A') or (Byte('T') shl 8) or (Byte('I') shl 16) or
    (Byte('2') shl 24));

  { Some D3DFORMAT values used in DDS files as FourCC value.}
  D3DFMT_A16B16G16R16  = 36;
  D3DFMT_R32F          = 114;
  D3DFMT_A32B32G32R32F = 116;
  D3DFMT_R16F          = 111;
  D3DFMT_A16B16G16R16F = 113;

  { Constans used by TDDSurfaceDesc2.Flags.}
  DDSD_CAPS            = $00000001;
  DDSD_HEIGHT          = $00000002;
  DDSD_WIDTH           = $00000004;
  DDSD_PITCH           = $00000008;
  DDSD_PIXELFORMAT     = $00001000;
  DDSD_MIPMAPCOUNT     = $00020000;
  DDSD_LINEARSIZE      = $00080000;
  DDSD_DEPTH           = $00800000;

  { Constans used by TDDSPixelFormat.Flags.}
  DDPF_ALPHAPIXELS     = $00000001;    // used by formats which contain alpha
  DDPF_FOURCC          = $00000004;    // used by DXT and large ARGB formats
  DDPF_RGB             = $00000040;    // used by RGB formats
  DDPF_LUMINANCE       = $00020000;    // used by formats like D3DFMT_L16
  DDPF_BUMPLUMINANCE   = $00040000;    // used by mixed signed-unsigned formats
  DDPF_BUMPDUDV        = $00080000;    // used by signed formats

  { Constans used by TDDSCaps.Caps1.}
  DDSCAPS_COMPLEX      = $00000008;
  DDSCAPS_TEXTURE      = $00001000;
  DDSCAPS_MIPMAP       = $00400000;

  { Constans used by TDDSCaps.Caps2.}
  DDSCAPS2_CUBEMAP     = $00000200;
  DDSCAPS2_POSITIVEX   = $00000400;
  DDSCAPS2_NEGATIVEX   = $00000800;
  DDSCAPS2_POSITIVEY   = $00001000;
  DDSCAPS2_NEGATIVEY   = $00002000;
  DDSCAPS2_POSITIVEZ   = $00004000;
  DDSCAPS2_NEGATIVEZ   = $00008000;
  DDSCAPS2_VOLUME      = $00200000;

  { Flags for TDDSurfaceDesc2.Flags used when saving DDS file.}
  DDS_SAVE_FLAGS = DDSD_CAPS or DDSD_PIXELFORMAT or DDSD_WIDTH or
    DDSD_HEIGHT or DDSD_LINEARSIZE;

type
  { Stores the pixel format information.}
  TDDPixelFormat = packed record
    Size: LongWord;       // Size of the structure = 32 bytes
    Flags: LongWord;      // Flags to indicate valid fields
    FourCC: LongWord;     // Four-char code for compressed textures (DXT)
    BitCount: LongWord;   // Bits per pixel if uncomp. usually 16,24 or 32
    RedMask: LongWord;    // Bit mask for the Red component
    GreenMask: LongWord;  // Bit mask for the Green component
    BlueMask: LongWord;   // Bit mask for the Blue component
    AlphaMask: LongWord;  // Bit mask for the Alpha component
  end;

  { Specifies capabilities of surface.}
  TDDSCaps = packed record
    Caps1: LongWord;      // Should always include DDSCAPS_TEXTURE
    Caps2: LongWord;      // For cubic environment maps
    Reserved: array[0..1] of LongWord; // Reserved
  end;

  { Record describing DDS file contents.}
  TDDSurfaceDesc2 = packed record
    Size: LongWord;       // Size of the structure = 124 Bytes
    Flags: LongWord;      // Flags to indicate valid fields
    Height: LongWord;     // Height of the main image in pixels
    Width: LongWord;      // Width of the main image in pixels
    PitchOrLinearSize: LongWord; // For uncomp formats number of bytes per
                          // scanline. For comp it is the size in
                          // bytes of the main image
    Depth: LongWord;      // Only for volume text depth of the volume
    MipMaps: LongInt;     // Total number of levels in the mipmap chain
    Reserved1: array[0..10] of LongWord; // Reserved
    PixelFormat: TDDPixelFormat; // Format of the pixel data
    Caps: TDDSCaps;       // Capabilities
    Reserved2: LongWord;  // Reserved
  end;

  { DDS file header.}
  TDDSFileHeader = packed record
    Magic: LongWord;       // File format magic
    Desc: TDDSurfaceDesc2; // Surface description
  end;


{ TDDSFileFormat class implementation }

constructor TDDSFileFormat.Create;
begin
  inherited Create;
  FName := SDDSFormatName;
  FCanLoad := True;
  FCanSave := True;
  FIsMultiImageFormat := True;
  FSupportedFormats := DDSSupportedFormats;

  FSaveCubeMap := False;
  FSaveVolume := False;
  FSaveMipMapCount := 1;
  FSaveDepth := 1;

  AddMasks(SDDSMasks);

  RegisterOption(ImagingDDSLoadedCubeMap, @FLoadedCubeMap);
  RegisterOption(ImagingDDSLoadedVolume, @FLoadedVolume);
  RegisterOption(ImagingDDSLoadedMipMapCount, @FLoadedMipMapCount);
  RegisterOption(ImagingDDSLoadedDepth, @FLoadedDepth);
  RegisterOption(ImagingDDSSaveCubeMap, @FSaveCubeMap);
  RegisterOption(ImagingDDSSaveVolume, @FSaveVolume);
  RegisterOption(ImagingDDSSaveMipMapCount, @FSaveMipMapCount);
  RegisterOption(ImagingDDSSaveDepth, @FSaveDepth);
end;

procedure TDDSFileFormat.CheckOptionsValidity;
begin
  if FSaveCubeMap then
    FSaveVolume := False;
  if FSaveVolume then
    FSaveCubeMap := False;
  if FSaveDepth < 1 then
    FSaveDepth := 1;
  if FSaveMipMapCount < 1 then
    FSaveMipMapCount := 1;
end;

procedure TDDSFileFormat.ComputeSubDimensions(Idx, Width, Height, MipMaps, Depth: LongInt;
  IsCubeMap, IsVolume: Boolean; var CurWidth, CurHeight: LongInt);
var
  I, Last, Shift: LongInt;
begin
  CurWidth := Width;
  CurHeight := Height;
  if MipMaps > 1 then
  begin
    if not IsVolume then
    begin
      if IsCubeMap then
      begin
        // Cube maps are stored like this
        // Face 0 mimap 0
        // Face 0 mipmap 1
        // ...
        // Face 1 mipmap 0
        // Face 1 mipmap 1
        // ...

        // Modify index so later in for loop we iterate less times
        Idx := Idx - ((Idx div MipMaps) * MipMaps);
      end;
      for I := 0 to Idx - 1 do
      begin
        CurWidth := ClampInt(CurWidth shr 1, 1, CurWidth);
        CurHeight := ClampInt(CurHeight shr 1, 1, CurHeight);
      end;
    end
    else
    begin
      // Volume textures are stored in DDS files like this:
      // Slice 0 mipmap 0
      // Slice 1 mipmap 0
      // Slice 2 mipmap 0
      // Slice 3 mipmap 0
      // Slice 0 mipmap 1
      // Slice 1 mipmap 1
      // Slice 0 mipmap 2
      // Slice 0 mipmap 3 ...
      Shift := 0;
      Last := Depth;
      while Idx > Last - 1 do
      begin
        CurWidth := ClampInt(CurWidth shr 1, 1, CurWidth);
        CurHeight := ClampInt(CurHeight shr 1, 1, CurHeight);
        if (CurWidth = 1) and (CurHeight = 1) then
          Break;
        Inc(Shift);
        Inc(Last, ClampInt(Depth shr Shift, 1, Depth));
      end;
    end;
  end;
end;

function TDDSFileFormat.LoadData(Handle: TImagingHandle;
  var Images: TDynImageDataArray; OnlyFirstLevel: Boolean): Boolean;
var
  Hdr: TDDSFileHeader;
  SrcFormat: TImageFormat;
  FmtInfo: TImageFormatInfo;
  NeedsSwapChannels: Boolean;
  CurrentWidth, CurrentHeight, ImageCount, LoadSize, I, PitchOrLinear: LongInt;
  Data: PByte;
  UseAsPitch: Boolean;
  UseAsLinear: Boolean;

  function MasksEqual(const DDPF: TDDPixelFormat; PF: PPixelFormatInfo): Boolean;
  begin
    Result := (DDPF.AlphaMask = PF.ABitMask) and
      (DDPF.RedMask = PF.RBitMask) and (DDPF.GreenMask = PF.GBitMask) and
      (DDPF.BlueMask = PF.BBitMask);
  end;

begin
  Result := False;
  ImageCount := 1;
  FLoadedMipMapCount := 1;
  FLoadedDepth := 1;
  FLoadedVolume := False;
  FLoadedCubeMap := False;

  with GetIO, Hdr, Hdr.Desc.PixelFormat do
  begin
    Read(Handle, @Hdr, SizeOF(Hdr));
    {
    // Set position to the end of the header (for possible future versions
    // ith larger header)
    Seek(Handle, Hdr.Desc.Size + SizeOf(Hdr.Magic) - SizeOf(Hdr),
      smFromCurrent);
    }
    SrcFormat := ifUnknown;
    NeedsSwapChannels := False;
    // Get image data format
    if (Flags and DDPF_FOURCC) = DDPF_FOURCC then
    begin
      // Handle FourCC and large ARGB formats
      case FourCC of
        D3DFMT_A16B16G16R16: SrcFormat := ifA16B16G16R16;
        D3DFMT_R32F: SrcFormat := ifR32F;
        D3DFMT_A32B32G32R32F: SrcFormat := ifA32B32G32R32F;
        D3DFMT_R16F: SrcFormat := ifR16F;
        D3DFMT_A16B16G16R16F: SrcFormat := ifA16B16G16R16F;
        FOURCC_DXT1: SrcFormat := ifDXT1;
        FOURCC_DXT3: SrcFormat := ifDXT3;
        FOURCC_DXT5: SrcFormat := ifDXT5;
        FOURCC_ATI1: SrcFormat := ifATI1N;
        FOURCC_ATI2: SrcFormat := ifATI2N;
      end;
    end
    else if (Flags and DDPF_RGB) = DDPF_RGB then
    begin
      // Handle RGB formats
      if (Flags and DDPF_ALPHAPIXELS) = DDPF_ALPHAPIXELS then
      begin
        // Handle RGB with alpha formats
        case BitCount of
          16:
            begin
              if MasksEqual(Desc.PixelFormat,
                GetFormatInfo(ifA4R4G4B4).PixelFormat) then
                SrcFormat := ifA4R4G4B4;
              if MasksEqual(Desc.PixelFormat,
                GetFormatInfo(ifA1R5G5B5).PixelFormat) then
                SrcFormat := ifA1R5G5B5;
            end;
          32:
            begin
              SrcFormat := ifA8R8G8B8;
              if BlueMask = $00FF0000 then
                NeedsSwapChannels := True;
            end;
        end;
      end
      else
      begin
        // Handle RGB without alpha formats
        case BitCount of
          8:
            if MasksEqual(Desc.PixelFormat,
              GetFormatInfo(ifR3G3B2).PixelFormat) then
              SrcFormat := ifR3G3B2;
          16:
            begin
              if MasksEqual(Desc.PixelFormat,
                GetFormatInfo(ifX4R4G4B4).PixelFormat) then
                SrcFormat := ifX4R4G4B4;
              if MasksEqual(Desc.PixelFormat,
                GetFormatInfo(ifX1R5G5B5).PixelFormat) then
                SrcFormat := ifX1R5G5B5;
              if MasksEqual(Desc.PixelFormat,
                GetFormatInfo(ifR5G6B5).PixelFormat) then
                SrcFormat := ifR5G6B5;
            end;
          24: SrcFormat := ifR8G8B8;
          32:
            begin
              SrcFormat := ifX8R8G8B8;
              if BlueMask = $00FF0000 then
                NeedsSwapChannels := True;
            end;
        end;
      end;
    end
    else if (Flags and DDPF_LUMINANCE) = DDPF_LUMINANCE then
    begin
      // Handle luminance formats
      if (Flags and DDPF_ALPHAPIXELS) = DDPF_ALPHAPIXELS then
      begin
        // Handle luminance with alpha formats
        if BitCount = 16 then
          SrcFormat := ifA8Gray8;
      end
      else
      begin
        // Handle luminance without alpha formats
        case BitCount of
          8: SrcFormat := ifGray8;
          16: SrcFormat := ifGray16;
        end;
      end;
    end
    else if (Flags and DDPF_BUMPLUMINANCE) = DDPF_BUMPLUMINANCE then
    begin
      // Handle mixed bump-luminance formats like D3DFMT_X8L8V8U8
      case BitCount of
        32:
          if BlueMask = $00FF0000 then
          begin
            SrcFormat := ifX8R8G8B8; // D3DFMT_X8L8V8U8
            NeedsSwapChannels := True;
          end;
      end;
    end
    else if (Flags and DDPF_BUMPDUDV) = DDPF_BUMPDUDV then
    begin
      // Handle bumpmap formats like D3DFMT_Q8W8V8U8
      case BitCount of
        16: SrcFormat := ifA8Gray8; // D3DFMT_V8U8
        32:
          if AlphaMask = $FF000000 then
          begin
            SrcFormat := ifA8R8G8B8; // D3DFMT_Q8W8V8U8
            NeedsSwapChannels := True;
          end;
        64: SrcFormat := ifA16B16G16R16; // D3DFMT_Q16W16V16U16
      end;
    end;

    // If DDS format is not supported we will exit
    if SrcFormat = ifUnknown then Exit;

    // File contains mipmaps for each subimage.
    { Some DDS writers ignore setting proper Caps and Flags so
      this check is not usable:
    if ((Desc.Caps.Caps1 and DDSCAPS_MIPMAP) = DDSCAPS_MIPMAP) and
      ((Desc.Flags and DDSD_MIPMAPCOUNT) = DDSD_MIPMAPCOUNT) then}
    if Desc.MipMaps > 1 then
    begin
      FLoadedMipMapCount := Desc.MipMaps;
      ImageCount := Desc.MipMaps;
    end;

    // File stores volume texture
    if ((Desc.Caps.Caps2 and DDSCAPS2_VOLUME) = DDSCAPS2_VOLUME) and
      ((Desc.Flags and DDSD_DEPTH) = DDSD_DEPTH) then
    begin
      FLoadedVolume := True;
      FLoadedDepth := Desc.Depth;
      ImageCount := GetVolumeLevelCount(Desc.Depth, ImageCount);
    end;

    // File stores cube texture
    if (Desc.Caps.Caps2 and DDSCAPS2_CUBEMAP) = DDSCAPS2_CUBEMAP then
    begin
      FLoadedCubeMap := True;
      I := 0;
      if (Desc.Caps.Caps2 and DDSCAPS2_POSITIVEX) = DDSCAPS2_POSITIVEX then Inc(I);
      if (Desc.Caps.Caps2 and DDSCAPS2_POSITIVEY) = DDSCAPS2_POSITIVEY then Inc(I);
      if (Desc.Caps.Caps2 and DDSCAPS2_POSITIVEZ) = DDSCAPS2_POSITIVEZ then Inc(I);
      if (Desc.Caps.Caps2 and DDSCAPS2_NEGATIVEX) = DDSCAPS2_NEGATIVEX then Inc(I);
      if (Desc.Caps.Caps2 and DDSCAPS2_NEGATIVEY) = DDSCAPS2_NEGATIVEY then Inc(I);
      if (Desc.Caps.Caps2 and DDSCAPS2_NEGATIVEZ) = DDSCAPS2_NEGATIVEZ then Inc(I);
      FLoadedDepth := I;
      ImageCount := ImageCount * I;
    end;

    // Allocate and load all images in file
    FmtInfo := GetFormatInfo(SrcFormat);
    SetLength(Images, ImageCount);

    // Compute the pitch or get if from file if present
    UseAsPitch := (Desc.Flags and DDSD_PITCH) = DDSD_PITCH;
    UseAsLinear := (Desc.Flags and DDSD_LINEARSIZE) = DDSD_LINEARSIZE;
    // Use linear as default if none is set
    if not UseAsPitch and not UseAsLinear then
      UseAsLinear := True;
    // Main image pitch or linear size
    PitchOrLinear := Desc.PitchOrLinearSize;

    for I := 0 to ImageCount - 1 do
    begin
      // Compute dimensions of surrent subimage based on texture type and
      // number of mipmaps
      ComputeSubDimensions(I, Desc.Width, Desc.Height, Desc.MipMaps, Desc.Depth,
        FloadedCubeMap, FLoadedVolume, CurrentWidth, CurrentHeight);
      NewImage(CurrentWidth, CurrentHeight, SrcFormat, Images[I]);

      if (I > 0) or (PitchOrLinear = 0) then
      begin
        // Compute pitch or linear size for mipmap levels, or even for main image
        // since some formats do not fill pitch nor size
        if UseAsLinear then
          PitchOrLinear := FmtInfo.GetPixelsSize(SrcFormat, CurrentWidth, CurrentHeight)
        else
          PitchOrLinear := (CurrentWidth * FmtInfo.BytesPerPixel + 3) div 4 * 4; // must be DWORD aligned
      end;

      if UseAsLinear then
        LoadSize := PitchOrLinear
      else
        LoadSize := CurrentHeight * PitchOrLinear;

      if UseAsLinear or (LoadSize = Images[I].Size) then
      begin
        // If DDS does not use Pitch we can simply copy data
        Read(Handle, Images[I].Bits, LoadSize)
      end
      else
      begin
        // If DDS uses Pitch we must load aligned scanlines
        // and then remove padding
        GetMem(Data, LoadSize);
        try
          Read(Handle, Data, LoadSize);
          RemovePadBytes(Data, Images[I].Bits, CurrentWidth, CurrentHeight,
            FmtInfo.BytesPerPixel, PitchOrLinear);
       finally
          FreeMem(Data);
        end;
      end;

      if NeedsSwapChannels then
        SwapChannels(Images[I], ChannelRed, ChannelBlue);
    end;
    Result := True;
  end;
end;

function TDDSFileFormat.SaveData(Handle: TImagingHandle;
  const Images: TDynImageDataArray; Index: LongInt): Boolean;
var
  Hdr: TDDSFileHeader;
  MainImage, ImageToSave: TImageData;
  I, MainIdx, Len, ImageCount: LongInt;
  J: LongWord;
  FmtInfo: TImageFormatInfo;
  MustBeFreed: Boolean;
  Is2DTexture, IsCubeMap, IsVolume: Boolean;
  MipMapCount, CurrentWidth, CurrentHeight: LongInt;
  NeedsResize: Boolean;
  NeedsConvert: Boolean;
begin
  Result := False;
  FillChar(Hdr, Sizeof(Hdr), 0);

  MainIdx := FFirstIdx;
  Len := FLastIdx - MainIdx + 1;
  // Some DDS saving rules:
  //   2D textures: Len is used as mipmap count (FSaveMipMapCount not used!).
  //   Cube maps:   FSaveDepth * FSaveMipMapCount images are used, if Len is
  //                smaller than this file is saved as regular 2D texture.
  //   Volume maps: GetVolumeLevelCount(FSaveDepth, FSaveMipMapCount) images are
  //                used, if Len is smaller than this file is
  //                saved as regular 2D texture.

  IsCubeMap := FSaveCubeMap;
  IsVolume := FSaveVolume;
  MipMapCount := FSaveMipMapCount;

  if IsCubeMap then
  begin
    // Check if we have enough images on Input to save cube map
    if Len < FSaveDepth * FSaveMipMapCount then
      IsCubeMap := False;
  end
  else if IsVolume then
  begin
    // Check if we have enough images on Input to save volume texture
    if Len < GetVolumeLevelCount(FSaveDepth, FSaveMipMapCount) then
      IsVolume := False;
  end;

  Is2DTexture := not IsCubeMap and not IsVolume;
  if Is2DTexture then
  begin
    // Get number of mipmaps used with 2D texture
    MipMapCount := Min(Len, GetNumMipMapLevels(Images[MainIdx].Width, Images[MainIdx].Height));
  end;

  // we create compatible main image and fill headers
  if MakeCompatible(Images[MainIdx], MainImage, MustBeFreed) then
  with GetIO, MainImage, Hdr do
  try
    FmtInfo := GetFormatInfo(Format);
    Magic := DDSMagic;
    Desc.Size := SizeOf(Desc);
    Desc.Width := Width;
    Desc.Height := Height;
    Desc.Flags := DDS_SAVE_FLAGS;
    Desc.Caps.Caps1 := DDSCAPS_TEXTURE;
    Desc.PixelFormat.Size := SizeOf(Desc.PixelFormat);
    Desc.PitchOrLinearSize := MainImage.Size;
    ImageCount := MipMapCount;

    if MipMapCount > 1 then
    begin
      // Set proper flags if we have some mipmaps to be saved
      Desc.Flags := Desc.Flags or DDSD_MIPMAPCOUNT;
      Desc.Caps.Caps1 := Desc.Caps.Caps1 or DDSCAPS_MIPMAP or DDSCAPS_COMPLEX;
      Desc.MipMaps := MipMapCount;
    end;

    if IsCubeMap then
    begin
      // Set proper cube map flags - number of stored faces is taken
      // from FSaveDepth
      Desc.Caps.Caps1 := Desc.Caps.Caps1 or DDSCAPS_COMPLEX;
      Desc.Caps.Caps2 := Desc.Caps.Caps2 or DDSCAPS2_CUBEMAP;
      J := DDSCAPS2_POSITIVEX;
      for I := 0 to FSaveDepth - 1 do
      begin
        Desc.Caps.Caps2 := Desc.Caps.Caps2 or J;
        J := J shl 1;
      end;
      ImageCount := FSaveDepth * FSaveMipMapCount;
    end
    else if IsVolume then
    begin
      // Set proper flags for volume texture
      Desc.Flags := Desc.Flags or DDSD_DEPTH;
      Desc.Caps.Caps1 := Desc.Caps.Caps1 or DDSCAPS_COMPLEX;
      Desc.Caps.Caps2 := Desc.Caps.Caps2 or DDSCAPS2_VOLUME;
      Desc.Depth := FSaveDepth;
      ImageCount := GetVolumeLevelCount(FSaveDepth, FSaveMipMapCount);
    end;

    // Now we set DDS pixel format for main image
    if FmtInfo.IsSpecial or FmtInfo.IsFloatingPoint or
      (FmtInfo.BytesPerPixel > 4) then
    begin
      Desc.PixelFormat.Flags := DDPF_FOURCC;
      case Format of
        ifA16B16G16R16:  Desc.PixelFormat.FourCC := D3DFMT_A16B16G16R16;
        ifR32F:          Desc.PixelFormat.FourCC := D3DFMT_R32F;
        ifA32B32G32R32F: Desc.PixelFormat.FourCC := D3DFMT_A32B32G32R32F;
        ifR16F:          Desc.PixelFormat.FourCC := D3DFMT_R16F;
        ifA16B16G16R16F: Desc.PixelFormat.FourCC := D3DFMT_A16B16G16R16F;
        ifDXT1:          Desc.PixelFormat.FourCC := FOURCC_DXT1;
        ifDXT3:          Desc.PixelFormat.FourCC := FOURCC_DXT3;
        ifDXT5:          Desc.PixelFormat.FourCC := FOURCC_DXT5;
        ifATI1N:         Desc.PixelFormat.FourCC := FOURCC_ATI1;
        ifATI2N:         Desc.PixelFormat.FourCC := FOURCC_ATI2;
      end;
    end
    else if FmtInfo.HasGrayChannel then
    begin
      Desc.PixelFormat.Flags := DDPF_LUMINANCE;
      Desc.PixelFormat.BitCount := FmtInfo.BytesPerPixel * 8;
      case Format of
        ifGray8:  Desc.PixelFormat.RedMask := 255;
        ifGray16: Desc.PixelFormat.RedMask := 65535;
        ifA8Gray8:
          begin
            Desc.PixelFormat.Flags := Desc.PixelFormat.Flags or DDPF_ALPHAPIXELS;
            Desc.PixelFormat.RedMask := 255;
            Desc.PixelFormat.AlphaMask := 65280;
          end;
      end;
    end
    else
    begin
      Desc.PixelFormat.Flags := DDPF_RGB;
      Desc.PixelFormat.BitCount := FmtInfo.BytesPerPixel * 8;
      if FmtInfo.HasAlphaChannel then
      begin
        Desc.PixelFormat.Flags := Desc.PixelFormat.Flags or DDPF_ALPHAPIXELS;
        Desc.PixelFormat.AlphaMask := $FF000000;
      end;
      if FmtInfo.BytesPerPixel > 2 then
      begin
        Desc.PixelFormat.RedMask :=   $00FF0000;
        Desc.PixelFormat.GreenMask := $0000FF00;
        Desc.PixelFormat.BlueMask :=  $000000FF;
      end
      else
      begin
        Desc.PixelFormat.AlphaMask := FmtInfo.PixelFormat.ABitMask;
        Desc.PixelFormat.RedMask := FmtInfo.PixelFormat.RBitMask;
        Desc.PixelFormat.GreenMask := FmtInfo.PixelFormat.GBitMask;
        Desc.PixelFormat.BlueMask := FmtInfo.PixelFormat.BBitMask;
      end;
    end;

    // Header and main image are written to output
    Write(Handle, @Hdr, SizeOf(Hdr));
    Write(Handle, MainImage.Bits, MainImage.Size);

    // Write the rest of the images and convert them to
    // the same format as main image if necessary and ensure proper mipmap
    // simensions too.
    for I := MainIdx + 1 to MainIdx + ImageCount - 1 do
    begin
      // Get proper dimensions for this level
      ComputeSubDimensions(I, Desc.Width, Desc.Height, Desc.MipMaps, Desc.Depth,
        IsCubeMap, IsVolume, CurrentWidth, CurrentHeight);

      // Check if input image for this level has the right size and format
      NeedsResize := not ((Images[I].Width = CurrentWidth) and (Images[I].Height = CurrentHeight));
      NeedsConvert := not (Images[I].Format = Format);

      if NeedsResize or NeedsConvert then
      begin
        // Input image must be resized or converted to different format
        // to become valid mipmap level
        InitImage(ImageToSave);
        CloneImage(Images[I], ImageToSave);
        if NeedsConvert then
          ConvertImage(ImageToSave, Format);
        if NeedsResize then
          ResizeImage(ImageToSave, CurrentWidth, CurrentHeight, rfBilinear);
      end
      else
        // Input image can be used without any changes
        ImageToSave := Images[I];

      // Write level data and release temp image if necessary
      Write(Handle, ImageToSave.Bits, ImageToSave.Size);
      if Images[I].Bits <> ImageToSave.Bits then
        FreeImage(ImageToSave);
    end;

    Result := True;
  finally
    if MustBeFreed then
      FreeImage(MainImage);
  end;
end;

procedure TDDSFileFormat.ConvertToSupported(var Image: TImageData;
  const Info: TImageFormatInfo);
var
  ConvFormat: TImageFormat;
begin
  if Info.IsIndexed or Info.IsSpecial then
    // convert indexed and unsupported special formatd to A8R8G8B8
    ConvFormat := ifA8R8G8B8
  else if Info.IsFloatingPoint then
  begin
    if Info.Format = ifA16R16G16B16F then
      // only swap channels here
      ConvFormat := ifA16B16G16R16F
    else
      // convert other floating point formats to A32B32G32R32F
      ConvFormat := ifA32B32G32R32F
  end
  else if Info.HasGrayChannel then
  begin
    if Info.HasAlphaChannel then
      // convert grayscale with alpha to A8Gray8
      ConvFormat := ifA8Gray8
    else if Info.BytesPerPixel = 1 then
      // convert 8bit grayscale to Gray8
      ConvFormat := ifGray8
    else
      // convert 16-64bit grayscales to Gray16
      ConvFormat := ifGray16;
  end
  else if Info.BytesPerPixel > 4 then
    ConvFormat := ifA16B16G16R16
  else if Info.HasAlphaChannel then
    // convert the other images with alpha channel to A8R8G8B8
    ConvFormat := ifA8R8G8B8
  else
    // convert the other formats to X8R8G8B8
    ConvFormat := ifX8R8G8B8;

  ConvertImage(Image, ConvFormat);
end;

function TDDSFileFormat.TestFormat(Handle: TImagingHandle): Boolean;
var
  Hdr: TDDSFileHeader;
  ReadCount: LongInt;
begin
  Result := False;
  if Handle <> nil then
    with GetIO do
    begin
      ReadCount := Read(Handle, @Hdr, SizeOf(Hdr));
      Seek(Handle, -ReadCount, smFromCurrent);
      Result := (Hdr.Magic = DDSMagic) and (ReadCount = SizeOf(Hdr)) and
        ((Hdr.Desc.Caps.Caps1 and DDSCAPS_TEXTURE) = DDSCAPS_TEXTURE);
    end;
end;

initialization
  RegisterImageFileFormat(TDDSFileFormat);

{
  File Notes:

  -- TODOS ----------------------------------------------------
    - nothing now

  -- 0.25.0 Changes/Bug Fixes ---------------------------------
    - Added support for 3Dc ATI1/2 formats.

  -- 0.23 Changes/Bug Fixes -----------------------------------
    - Saved DDS with mipmaps now correctly defineds COMPLEX flag.
    - Fixed loading of RGB DDS files that use pitch and have mipmaps -
      mipmaps were loaded wrongly.

  -- 0.21 Changes/Bug Fixes -----------------------------------
    - Changed saving behaviour a bit: mipmaps are inlcuded automatically for
      2D textures if input image array has more than 1 image (no need to
      set SaveMipMapCount manually).
    - Mipmap levels are now saved with proper dimensions when saving DDS files.
    - Made some changes to not be so strict when loading DDS files.
      Many programs seem to save them in non-standard format
      (by MS DDS File Reference).
    - Added missing ifX8R8G8B8 to SupportedFormats, MakeCompatible failed
      when image was converted to this format (inside).
    - MakeCompatible method moved to base class, put ConvertToSupported here.
      GetSupportedFormats removed, it is now set in constructor.
    - Fixed bug that sometimes saved non-standard DDS files and another
      one that caused crash when these files were loaded.
    - Changed extensions to filename masks.
    - Changed SaveData, LoadData, and MakeCompatible methods according
      to changes in base class in Imaging unit.

  -- 0.19 Changes/Bug Fixes -----------------------------------
    - added support for half-float image formats
    - change in LoadData to allow support for more images
      in one stream loading

  -- 0.17 Changes/Bug Fixes -----------------------------------
    - fixed bug in TestFormat which does not recognize many DDS files
    - changed pitch/linearsize handling in DDS loading code to
      load DDS files produced by NVidia's Photoshop plugin
}

end.