#NoEnv
SetBatchLines, -1

file := "mytest.gif"
x := 0, y := 0, w := 500, h := 300
fps := 25
colorCount := 128

ContainerFormatGif        := "{1F8A5601-7D4D-4CBD-9C82-1BC8D4EEB9A5}"
WICPixelFormat32bppBGRA   := "{6FDDC324-4E03-4BFE-B185-3D77768DC90F}"
WICPixelFormat8bppIndexed := "{6FDDC324-4E03-4BFE-B185-3D77768DC904}"
CLSIDFromString(WICPixelFormat32bppBGRA  , GUID_WICPixelFormat32bppBGRA)
CLSIDFromString(WICPixelFormat8bppIndexed, GUID_WICPixelFormat8bppIndexed)
Return

$F1::
hHeap := DllCall("GetProcessHeap", "Ptr")
DataBuff := []

Device := IDirect3DDevice9.CreateFromIDirect3D9()
Surface := Device.CreateOffscreenPlainSurface()
ImagingFactory := IWICImagingFactory.Create()

Stream := ImagingFactory.CreateStream()
Stream.InitializeFromFilename(file)

GifEncoder := ImagingFactory.CreateEncoder(ContainerFormatGif)
GifEncoder.Initialize(Stream.ptr, WICBitmapEncoderNoCache := 0x2)

MetadataQueryWriter := GifEncoder.GetMetadataQueryWriter()
VarSetCapacity(PROPVARIANT, A_PtrSize*2+8, 0)

VarSetCapacity(strBuff, 11, 0)
StrPut("NETSCAPE2.0", &strBuff, "cp0")
NumPut(VT_UI1 := 0x11|VT_VECTOR := 0x1000, PROPVARIANT, "UShort")
NumPut(11, PROPVARIANT, 8, "UInt")
NumPut(&strBuff, PROPVARIANT, 8+A_PtrSize)
MetadataQueryWriter.SetMetadataByName("/appext/Application", &PROPVARIANT)

VarSetCapacity(numBuff, 5, 0)
NumPut(3, numBuff)
NumPut(1, numBuff, 1, "UChar")
NumPut(5, PROPVARIANT, 8, "UInt")
NumPut(&numBuff, PROPVARIANT, 8+A_PtrSize)
MetadataQueryWriter.SetMetadataByName("/appext/Data", &PROPVARIANT)
MetadataQueryWriter := ""

NumPut(VT_UI2 := 0x12, PROPVARIANT, "UShort")

delay := estimatedDelay := 1000//fps
startGrabbing := timeElapsed := A_TickCount
Loop 100 {
   Device.GetFrontBufferData(0, Surface.ptr)
   Surface.LockRect(D3DLOCKED_RECT, x, y, w, h)
   pitch := NumGet(D3DLOCKED_RECT, 0, "Int")
   pBits := NumGet(D3DLOCKED_RECT, A_PtrSize, "Ptr")
   newPitch := w*4, size := newPitch*h
   pHeap := DllCall("HeapAlloc", "Ptr", hHeap, "UInt", HEAP_ZERO_MEMORY := 0x8, "Ptr", size, "Ptr")
   Loop % h
      DllCall("RtlCopyMemory", "Ptr", pHeap + (A_Index - 1)*newPitch, "Ptr", pBits + (A_Index - 1)*pitch, "Ptr", newPitch)
   DataBuff.Push([pHeap, delay])
   Surface.UnlockRect()
   
   if (A_Index = 1)
      continue
   
   delay := A_TickCount - timeElapsed
   diff := estimatedDelay + diff - delay
   if (diff > 0) {
      DllCall("Winmm\timeBeginPeriod", "UInt", 3)
      DllCall("Sleep", "UInt", diff)
      DllCall("Winmm\timeEndPeriod", "UInt", 3)
   }
   delay := A_TickCount - timeElapsed
   diff := estimatedDelay - delay
   timeElapsed += delay
}
endGrabbing := A_TickCount - startGrabbing
Device := Surface := ""

startSaving := A_TickCount
for k, v in DataBuff {
   pData := v[1]
   
   Bitmap := ImagingFactory.CreateBitmapFromMemory(w, h, &GUID_WICPixelFormat32bppBGRA, newPitch, size, pData)
   DllCall("HeapFree", "Ptr", hHeap, "UInt", 0, "Ptr", pData)
   Palette := ImagingFactory.CreatePalette()
   Palette.InitializeFromBitmap(Bitmap.ptr, colorCount, true)
   FormatConverter := ImagingFactory.CreateFormatConverter()
   FormatConverter.Initialize( Bitmap.ptr, &GUID_WICPixelFormat8bppIndexed, WICBitmapDitherTypeErrorDiffusion := 0x8
                             , Palette.ptr, 0, WICBitmapPaletteTypeMedianCut := 0x1 )
   Frame := GifEncoder.CreateNewFrame()
   Frame.Initialize()
   Frame.WriteSource(FormatConverter.ptr, w, h)
   
   MetadataQueryWriter := Frame.GetMetadataQueryWriter()
   Frame.Commit(), Frame := FormatConverter := Palette := Bitmap := ""
   NumPut(Round(v[2]/10), PROPVARIANT, 8, "UInt")
   MetadataQueryWriter.SetMetadataByName("/grctlext/Delay", &PROPVARIANT)
   MetadataQueryWriter := ""
}
GifEncoder.Commit()
ImagingFactory := Stream := GifEncoder := ""

MsgBox, % "Снято 100 кадров за " . endGrabbing . " мс, обработано за " . A_TickCount - startSaving . " мс"
Return
   
CLSIDFromString(IID, ByRef CLSID) {
   VarSetCapacity(CLSID, 16, 0)
   if res := DllCall("ole32\CLSIDFromString", "WStr", IID, "Ptr", &CLSID)
      throw Exception("CLSIDFromString failed. Error: " . Format("{:#x}", res))
   Return &CLSID
}

class InterfaceBase {
   __New(ptr) {
      this.ptr := ptr
   }
   
   __Delete() {
      ObjRelease(this.ptr)
   }
   
   VTable(idx) {
      Return NumGet(NumGet(this.ptr + 0) + A_PtrSize*idx)
   }
   
   IsError(method, result, exc := true) {
      if (result = 0)
         Return 0
      this.error := method . " failed. Result: " . (result = "" ? "No result" : Format("{:#x}", result & 0xFFFFFFFF))
      if !exc
         Return this.error
      throw Exception(this.error)
   }
}

class IDirect3D9 extends InterfaceBase {
   Create(D3D_SDK_VERSION := 32) {
      hLib := DllCall("LoadLibrary", "Str", "d3d9", "Ptr")
      if !pIDirect3D9 := DllCall("d3d9\Direct3DCreate9", "UInt", D3D_SDK_VERSION)
         throw Exception("Direct3DCreate9 failed")
      Return new IDirect3D9(pIDirect3D9)
   }
   
   GetAdapterDisplayMode(Adapter, ByRef D3DDISPLAYMODE) {
      VarSetCapacity(D3DDISPLAYMODE, 16, 0)
      hr := DllCall(this.VTable(8), "Ptr", this.ptr, "UInt", Adapter, "Ptr", &D3DDISPLAYMODE)
      this.IsError("IDirect3D9::GetAdapterDisplayMode", hr)
   }
   
   CreateDevice(Adapter, DeviceType, hFocusWindow, BehaviorFlags, pPresentationParameters) {
      hr := DllCall(this.VTable(16), "Ptr", this.ptr, "UInt", Adapter, "UInt", DeviceType
                                   , "Ptr", hFocusWindow, "UInt", BehaviorFlags
                                   , "Ptr", pPresentationParameters, "PtrP", pIDirect3DDevice9)
      this.IsError("IDirect3D9::CreateDevice", hr)
      Return new IDirect3DDevice9(pIDirect3DDevice9)
   }
}

class IDirect3DDevice9 extends InterfaceBase {
   CreateFromIDirect3D9() {
      static D3DADAPTER_DEFAULT := 0, D3DSWAPEFFECT_DISCARD := 1
           , D3DDEVTYPE_HAL := 1, D3DCREATE_SOFTWARE_VERTEXPROCESSING := 0x20
           , Windowed := true, BackBufferCount := 1
      
      Direct3D9 := IDirect3D9.Create()
      Direct3D9.GetAdapterDisplayMode(D3DADAPTER_DEFAULT, D3DDISPLAYMODE)
      
      VarSetCapacity(D3DPRESENT_PARAMETERS, 48+2*A_PtrSize, 0)
      BackBufferWidth  := NumGet(D3DDISPLAYMODE, 0, "UInt")
      BackBufferHeight := NumGet(D3DDISPLAYMODE, 4, "UInt")
      NumPut(BackBufferWidth, D3DPRESENT_PARAMETERS, 0)
      NumPut(BackBufferHeight, D3DPRESENT_PARAMETERS, 4)
      NumPut(BackBufferCount, D3DPRESENT_PARAMETERS, 12)
      NumPut(D3DSWAPEFFECT_DISCARD, D3DPRESENT_PARAMETERS, 24)
      NumPut(Windowed, D3DPRESENT_PARAMETERS, 24+2*A_PtrSize)
      
      Device := Direct3D9.CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, 0, D3DCREATE_SOFTWARE_VERTEXPROCESSING, &D3DPRESENT_PARAMETERS)
      Device.width := BackBufferWidth
      Device.height := BackBufferHeight
      Return Device
   }
   
   CreateOffscreenPlainSurface() {
      static D3DFMT_A8R8G8B8 := 21, D3DPOOL_SYSTEMMEM := 2
      hr := DllCall(this.VTable(36), "Ptr", this.ptr, "UInt", this.width, "UInt", this.height
                                   , "UInt", D3DFMT_A8R8G8B8, "UInt", D3DPOOL_SYSTEMMEM
                                   , "PtrP", pIDirect3DSurface9, "Ptr", 0)
      this.IsError("IDirect3DDevice9::CreateOffscreenPlainSurface", hr)
      Return new IDirect3DSurface9(pIDirect3DSurface9)
   }
   
   GetFrontBufferData(iSwapChain, pDestSurface) {
      hr := DllCall(this.VTable(33), "Ptr", this.ptr, "UInt", iSwapChain, "Ptr", pDestSurface)
      this.IsError("IDirect3DDevice9::GetFrontBufferData", hr)
   }
}

class IDirect3DSurface9 extends InterfaceBase {
   LockRect(ByRef D3DLOCKED_RECT, x := "", y := "", w := "", h := "", flags := 0) {
      VarSetCapacity(D3DLOCKED_RECT, A_PtrSize*2, 0)
      if (x != "") {
         VarSetCapacity(RECT, 16, 0)
         NumPut(x, RECT), NumPut(y, RECT, 4), NumPut(x + w, RECT, 8), NumPut(y + h, RECT, 12, "UInt")
      }
      hr := DllCall(this.VTable(13), "Ptr", this.ptr, "Ptr", &D3DLOCKED_RECT, "Ptr", x = "" ? 0 : &RECT, "UInt", flags)
      this.IsError("IDirect3DSurface9::LockRect", hr)
   }
   
   UnlockRect() {
      hr := DllCall(this.VTable(14), "Ptr", this.ptr)
      this.IsError("IDirect3DSurface9::LockRect", hr)
   }
}

class IWICImagingFactory extends InterfaceBase {
   Create() {
      static CLSID_WICImagingFactory := "{CACAF262-9370-4615-A13B-9F5539DA4C0A}"
           , IID_IWICImagingFactory  := "{EC5EC8A9-C395-4314-9C77-54D7A935FF70}"
      if !pIWICImagingFactory := ComObjCreate(CLSID_WICImagingFactory, IID_IWICImagingFactory)
         throw Exception("Can't create IWICImagingFactory")
      Return new IWICImagingFactory(pIWICImagingFactory)
   }
   
   CreateEncoder(ContainerFormatGUID, pguidVendor := 0) {
      if (ContainerFormatGUID + 0)
         pGUID := ContainerFormatGUID
      else
         pGUID := CLSIDFromString(ContainerFormatGUID, GUID)
      hr := DllCall(this.VTable(8), "Ptr", this.ptr, "Ptr", pGUID, "Ptr", pguidVendor, "PtrP", pIWICBitmapEncoder)
      this.IsError("IWICImagingFactory::CreateEncoder", hr)
      Return new IWICBitmapEncoder(pIWICBitmapEncoder)
   }
   
   CreatePalette() {
      hr := DllCall(this.VTable(9), "Ptr", this.ptr, "PtrP", pIWICPalette)
      this.IsError("IWICImagingFactory::CreatePalette", hr)
      Return new IWICPalette(pIWICPalette)
   }
   
   CreateFormatConverter() {
      hr := DllCall(this.VTable(10), "Ptr", this.ptr, "PtrP", pIWICFormatConverter)
      this.IsError("IWICImagingFactory::CreateFormatConverter", hr)
      Return new IWICFormatConverter(pIWICFormatConverter)
   }
   
   CreateStream() {
      hr := DllCall(this.VTable(14), "Ptr", this.ptr, "PtrP", pIWICStream)
      this.IsError("IWICImagingFactory::CreateStream", hr)
      Return new IWICStream(pIWICStream)
   }
   
   CreateBitmapFromMemory(width, height, pixelFormat, cbStride, cbBufferSize, pbBuffer) {
      if (pixelFormat + 0)
         pGUID := pixelFormat
      else
         pGUID := CLSIDFromString(pixelFormat, GUID)
      hr := DllCall(this.VTable(20), "Ptr", this.ptr, "UInt", width, "UInt", height, "Ptr", pGUID
                                   , "UInt", cbStride, "UInt", cbBufferSize, "Ptr", pbBuffer, "PtrP", pIWICBitmap)
      this.IsError("IWICImagingFactory::CreateBitmapFromMemory", hr)
      Return new IWICBitmap(pIWICBitmap)
   }
}

class IWICPalette extends InterfaceBase {
   InitializeFromBitmap(pISurface, cCount, fAddTransparentColor) {
      hr := DllCall(this.VTable(5), "Ptr", this.ptr, "Ptr", pISurface, "UInt", cCount, "UInt", fAddTransparentColor)
      this.IsError("IWICPalette::InitializeFromBitmap", hr)
   }
}

class IWICBitmapEncoder extends InterfaceBase {
   Initialize(pIStream, cacheOption) {
      hr := DllCall(this.VTable(3), "Ptr", this.ptr, "Ptr", pIStream, "Int", cacheOption)
      this.IsError("IWICBitmapEncoder::Initialize", hr)
   }
   
   CreateNewFrame() {
      hr := DllCall(this.VTable(10), "Ptr", this.ptr, "PtrP", pIWICBitmapFrameEncode, "PtrP", 0)
      this.IsError("IWICBitmapEncoder::CreateNewFrame", hr)
      Return new IWICBitmapFrameEncode(pIWICBitmapFrameEncode)
   }
   
   Commit() {
      hr := DllCall(this.VTable(11), "Ptr", this.ptr)
      this.IsError("IWICBitmapEncoder::Commit", hr)
   }
   
   GetMetadataQueryWriter() {
      hr := DllCall(this.VTable(12), "Ptr", this.ptr, "PtrP", pIWICMetadataQueryWriter)
      this.IsError("IWICBitmapEncoder::GetMetadataQueryWriter", hr)
      Return new IWICMetadataQueryWriter(pIWICMetadataQueryWriter)
   }
}

class IPropertyBag2 extends InterfaceBase {
   Write(cProperties, pPropBag, pvarValue) {
      hr := DllCall(this.VTable(4), "Ptr", this.ptr, "UInt", cProperties, "Ptr", pPropBag, "Ptr", pvarValue)
      this.IsError("IPropertyBag2::Write", hr)
   }
}

class IWICFormatConverter extends InterfaceBase {
   Initialize(pISource, dstFormat, dither, pIPalette, alphaThresholdPercent, paletteTranslate) {
      if (dstFormat + 0)
         pGUID := dstFormat
      else
         pGUID := CLSIDFromString(dstFormat, GUID)
      hr := DllCall(this.VTable(8), "Ptr", this.ptr, "Ptr", pISource, "Ptr", pGUID, "UInt", dither
                                  , "Ptr", pIPalette, "Double", alphaThresholdPercent, "UInt", paletteTranslate)
      this.IsError("IWICFormatConverter::Initialize", hr)
   }
   
   CanConvert(srcPixelFormat, dstPixelFormat) {
      if (srcPixelFormat + 0)
         pSrcGUID := srcPixelFormat
      else
         pSrcGUID := CLSIDFromString(srcPixelFormat, srcGUID)
      if (dstPixelFormat + 0)
         pDstGUID := dstPixelFormat
      else
         pDstGUID := CLSIDFromString(dstPixelFormat, dstGUID)
      hr := DllCall(this.VTable(9), "Ptr", this.ptr, "Ptr", pSrcGUID, "Ptr", pDstGUID, "UIntP", CanConvert)
      this.IsError("IWICFormatConverter::CanConvert", hr)
      Return CanConvert
   }
}

class IWICStream extends InterfaceBase {
   InitializeFromFilename(fileName, access := 0x40000000) {  ; GENERIC_WRITE := 0x40000000
      hr := DllCall(this.VTable(15), "Ptr", this.ptr, "Str", fileName, "UInt", access)
      this.IsError("IWICStream::InitializeFromFilename", hr)
   }
}

class IWICBitmap extends InterfaceBase {
}

class IWICBitmapFrameEncode extends InterfaceBase {
   Initialize(pIEncoderOptions := 0) {
      hr := DllCall(this.VTable(3), "Ptr", this.ptr, "Ptr", pIEncoderOptions = 0 ? 0 : pIEncoderOptions)
      this.IsError("IWICBitmapFrameEncode::Initialize", hr)
   }
   
   SetSize(width, height) {
      hr := DllCall(this.VTable(4), "Ptr", this.ptr, "UInt", width, "UInt", height)
      this.IsError("IWICBitmapFrameEncode::SetSize", hr)
   }
   
   SetPixelFormat(pixelFormat) {
      if (pixelFormat + 0)
         pGUID := pixelFormat
      else
         pGUID := CLSIDFromString(pixelFormat, GUID)
      hr := DllCall(this.VTable(6), "Ptr", this.ptr, "Ptr", pGUID)
      this.IsError("IWICBitmapFrameEncode::SetSize", hr)
   }
   
   WriteSource(pIBitmapSource, width, height) {
      static RECT, _ := VarSetCapacity(RECT, 16, 0)
      NumPut(width, RECT, 8), NumPut(height, RECT, 12, "UInt")
      hr := DllCall(this.VTable(11), "Ptr", this.ptr, "Ptr", pIBitmapSource, "Ptr", &RECT)
      this.IsError("IWICBitmapFrameEncode::WriteSource", hr)
   }
   
   Commit() {
      hr := DllCall(this.VTable(12), "Ptr", this.ptr)
      this.IsError("IWICBitmapFrameEncode::Commit", hr)
   }
   
   GetMetadataQueryWriter() {
      hr := DllCall(this.VTable(13), "Ptr", this.ptr, "PtrP", pMetadataQueryWriter)
      this.IsError("IWICBitmapFrameEncode::GetMetadataQueryWriter", hr)
      Return new IWICMetadataQueryWriter(pMetadataQueryWriter)
   }
}

class IWICMetadataQueryWriter extends InterfaceBase {
   SetMetadataByName(wzName, pvarValue) {
      hr := DllCall(this.VTable(7), "Ptr", this.ptr, "Str", wzName, "Ptr", pvarValue)
      this.IsError("IWICMetadataQueryWriter::SetMetadataByName", hr)
   }
}

   IWICPalette_InitializeFromBitmap(pPalette, Bitmap, 256, 1)
   IWICImagingFactory_CreateFormatConverter(wic, FormatConverter)
   IWICFormatConverter_Initialize(FormatConverter, bitmap, WIC_GUID(GUID, "GUID_WICPixelFormat8bppIndexed"), WICBitmapDitherTypeErrorDiffusion := 0x00000008, pPalette, 0, WICBitmapPaletteTypeMedianCut := 1)