3 replies to this topic

[escafandra]

Con motivo de una sugerencia que hice sobre una duda en este tema, expongo un ejemplo de enviar el contenido de la pantalla por un socket.

Se trata de enviar un bloque de memoria que contiene la imagen de la pantalla comprimida en png usando GDI plus flat API con lo que va a funcionar en cualquier versión de delphi.

delphi

uses
  Windows, ActiveX, WinSock, Forms, Classes, Controls, StdCtrls;
 
type
TCLSID = TGUID;
PCLSID = ^TCLSID;
 
TImageCodecInfo = packed record
  Clsid:            TCLSID;
  FormatID:          TGUID;
  CodecName:        PWCHAR;
  DllName:          PWCHAR;
  FormatDescription: PWCHAR;
  FilenameExtension: PWCHAR;
  MimeType:          PWCHAR;
  Flags:            DWORD;
  Version:          DWORD;
  SigCount:          DWORD;
  SigSize:          DWORD;
  SigPattern:        PBYTE;
  SigMask:          PBYTE;
end;
PImageCodecInfo = ^TImageCodecInfo;
 
 
function  wcscmp(wstr1, wstr2: PWCHAR): Integer; cdecl external 'crtdll';
 
// GDI+ Flat API...
function  GdiplusStartup(var GdiToken: DWORD; Startup, Output: PBYTE): Cardinal; stdcall external 'gdiplus';
procedure GdiplusShutdown(GdiToken: DWORD); stdcall external 'gdiplus';
function  GdipCreateBitmapFromHBITMAP(hbm: HBITMAP; hpal: HPALETTE; var GBitmap: THANDLE): Cardinal; stdcall external 'gdiplus';
function  GdipGetImageEncodersSize(var numEncoders: DWORD; var size: DWORD): Cardinal; stdcall external 'gdiplus';
function  GdipGetImageEncoders(numEncoders, size: DWORD; encoders: PImageCodecInfo): Cardinal; stdcall external 'gdiplus';
function  GdipDisposeImage(image: THANDLE): Cardinal; stdcall external 'gdiplus';
function  GdipSaveImageToStream(image: THANDLE; stream: ISTREAM; var clsidEncoder: TCLSID; encoderParams: Pointer): Cardinal; stdcall external 'gdiplus';
 
 
implementation
 
// Obtener el CLSID para la codificación de un formato gráfico
function GetEncoderClsid(Format: PWCHAR; var Clsid: TCLSID): boolean;
var
  i, N, Size: Cardinal;
  ICInfo: array of TImageCodecInfo;
begin
  Result:= false;
  i:= 0; N:= 0; Size:= 0;
  GdipGetImageEncodersSize(N, Size);
  if Size > 0 then
  begin
    SetLength(ICInfo, Size);
    GdipGetImageEncoders(N, Size, @ICInfo[0]);
    while (i< N) and (wcscmp(ICInfo[i].MimeType, Format)<>0) do inc(i);
    if i<N then Clsid:= ICInfo[i].Clsid;
  end;
  Result:= boolean(i<N);
end;
 
procedure SendScreen(hSocket: TSOCKET);
var
  gdiplusToken: DWORD;
  GdiPlusStartupInput: array[0..2] of int64;
  CursorInf: TCURSORINFO;
  IconInf: ICONINFO;
  hScreen, hCanvas: HDC;
  Bitmap: HBITMAP;
  GBitmap: THANDLE;
  Stream: IStream;
  stat: STATSTG;
  Clsid: TCLSID;
  hMem: HGLOBAL;
  Memory: Pointer;
 
begin
  // Inicializamos GDI+.
  GdiPlusStartupInput[0]:= 1; GdiPlusStartupInput[1]:= 0;
  if GdiplusStartup(gdiplusToken, @GdiPlusStartupInput, nil) <> 0 then exit;
 
  // Capturo la pantalla
  hScreen:= GetDC(0);
  hCanvas:= CreateCompatibleDC(0);
  Bitmap:= CreateCompatibleBitmap(hScreen,GetDeviceCaps(hScreen, HORZRES), GetDeviceCaps(hScreen, VERTRES));
  SelectObject(hCanvas, Bitmap);
  BitBlt(hCanvas, 0, 0, GetDeviceCaps(hScreen, HORZRES), GetDeviceCaps(hScreen, VERTRES), hScreen, 0, 0, SRCCOPY);
 
  // Capturo el cursor
  ZeroMemory(@CursorInf, sizeof(TCURSORINFO));
  CursorInf.cbSize:= sizeof(TCURSORINFO);
  if GetCursorInfo(CursorInf) and (CursorInf.flags = CURSOR_SHOWING) then
  begin
    GetIconInfo(CursorInf.hCursor, IconInf);
    DrawIcon(hCanvas, CursorInf.ptScreenPos.x - IconInf.xHotspot, CursorInf.ptScreenPos.y - IconInf.yHotspot, CursorInf.hCursor);
    DeleteObject(IconInf.hbmColor);
    DeleteObject(IconInf.hbmMask);
  end;
 
  // Procedo a enviar un bloque de memoria con la imagen comprimida en png
  CreateStreamOnHGlobal(0, true, stream);
  GdipCreateBitmapFromHBITMAP(Bitmap, 0, GBitmap);
  GetEncoderCLSID('image/png', Clsid);
  GdipSaveImageToStream(GBitmap, stream, Clsid, nil);
  // Obtengo el tamaño del bloque de memoria
  stream.Stat(stat, STATFLAG_NONAME);
  // Obtengo el puntero del bloque de memoria (stat.cbSize)
  GetHGlobalFromStream(stream, hMem);
  Memory:= GlobalLock(hMem);
 
  // Envío el bloque de memoria
  send(hSocket, Memory^, stat.cbSize, 0);
 
  // libero los Objetos usados del GDI+ bloques y Handles
  GdipDisposeImage(GBitmap);
  GlobalUnlock(hMem);
  DeleteObject(Bitmap);
  DeleteDC(hCanvas);
  ReleaseDC(0, hScreen);
 
  // Shutdown GDI+
  GdiplusShutdown(gdiplusToken);
end;

Espero que el ejemplo sea de utilidad para aquellos que se interesen por la API de GDI+  y a algunos otros curiosos  .


Saludos.

[felipe]

Interesante... falta es el how to use


Saludos!

[escafandra]

Interesante... falta es el how to use

El "how to use" es sencillo y complejo, según....

Debe realizarse una aplicación clliente-servidor. El código expuesto envía el contenido de la pantalla básicamente en la línea

delphi

send(hSocket, Memory^, stat.cbSize, 0);

Esa línea es una simplificación del envío, pues en realidad debería realizarse un sistema un poco mas complejo de envío del bloque de memoria en fragmentos y comprobar que se reciben del otro lado. También dependerá del protocolo que se elija. Tal como está puede funcionar pero la otra parte lo recibirá fragmentado. En definitiva se debe establecer en esa línea la función concreta que enviará el bloque de memoria.

En el PC remoto, una vez recibido el bloque, lo cargaremos en otro istream para reconstruir un GpBitmap con la API GdipCreateBitmapFromStream. De éste obtendremos un HBITMAP con GdipCreateHBITMAPFromBitmap. Ese HBITMAP puede ser asignado como Handle de un TBitmap de un TImage, por ejemplo, donde visualizaremos la imagen en el PC remoto. También se podría usar un TStream puesto que lo que estamos enviando es un bloque de memoria con la imagen de un fichero png. Nada nos impide elegir un formato de imagen distinto como jpg...

El ejemplo trata de mostrar una posible solución, a bajo nivel, del envío de imágenes a través de la red, aunque el código es funcional, debe completarse el código para un PC remoto y dar mas robustez al envío de grandes bloques de memoria.

¿Y porqué no complicar un poco el asunto y enviar, no imágenes completas de la pantalla, sino únicamente los cambios acaecidos  entre cada envío?. En este tema, resta de imágenes, mostré una forma para encontrar las diferencias entre dos imágenes. Enviar la diferencia ahorra tráfico de red, en ese caso enviaríamos una máscara y la diferencia entre imágenes, complicando un poco el sistema pero ganando en velocidad y eficacia.

En fin son unas cuantas ideas. Como dije al principio el "how to use" es sencillo y complejo, según lo queramos ver. Es por ese motivo que me lo reservé, para dejar libre la imaginación.


Saludos.

[escafandra]

Como sabéis, suelo publicar el código en C/C++ y delphi cuando se trata de trucos, así que aprovecho un rato libre para colocar el código equivalente del truco en C/C++ con GDI plus flat API

cpp

//---------------------------------------------------------------------------
#define STRICT
#include <windows.h>
#include <algorithm>
using std::min;
using std::max;
#include "Gdiplus.h"
#include "WinSock.h"
 
#pragma comment(lib, "Gdiplus.lib") // poner la ruta dentro de las libreriras
 
//---------------------------------------------------------------------------
Gdiplus::GdiplusStartupInput gdiplusStartupInput;
ULONG_PTR  gdiplusToken;
 
bool GetEncoderCLSID(const WCHAR* Format, CLSID* Clsid)
{
  UINT i=0, N=0, Size=0;
  Gdiplus::GetImageEncodersSize(&N, &Size);
  if(!Size) return false;
  Gdiplus::ImageCodecInfo* ICInfo = new Gdiplus::ImageCodecInfo[Size];
  Gdiplus::GetImageEncoders(N, Size, ICInfo);
  while (i<N && wcscmp(ICInfo[i].MimeType, Format)) i++;
  if(i<N) *Clsid = ICInfo[i].Clsid;
  delete [] ICInfo;
  return (i<N);
}
 
//---------------------------------------------------------------------------
void ScreenDownload(SOCKET hSocket)
{
  DWORD gdiplusToken;
  Gdiplus::GdiplusStartupInput ddiPlusStartupInput;
  BITMAPINFO BitmapInf;
  CURSORINFO CursorInf = {sizeof(CURSORINFO)};
  ICONINFO IconInf;
  HDC hScreen, hCanvas;
  HBITMAP Bitmap;
  Gdiplus::GpBitmap* GBitmap;
  IStream* Stream;
  STATSTG stat;
  TCLSID Clsid;
  HGLOBAL hMem;
  void* Memory;
 
  // Inicializamos GDI+.
  if(GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL)) return;
 
  // Capturo la pantalla
  hScreen = GetDC(0);
  hCanvas = CreateCompatibleDC(0);
  Bitmap = CreateCompatibleBitmap(hScreen, GetDeviceCaps(hScreen, HORZRES), GetDeviceCaps(hScreen, VERTRES));
  SelectObject(hCanvas, Bitmap);
  BitBlt(hCanvas, 0, 0, GetDeviceCaps(hScreen, HORZRES), GetDeviceCaps(hScreen, VERTRES), hScreen, 0, 0, SRCCOPY);
 
  // Capturo el cursor
  if(GetCursorInfo(&CursorInf) && CursorInf.flags == CURSOR_SHOWING){
    GetIconInfo(CursorInf.hCursor, &IconInf);
    DrawIcon(hCanvas, CursorInf.ptScreenPos.x - IconInf.xHotspot, CursorInf.ptScreenPos.y - IconInf.yHotspot, CursorInf.hCursor);
    DeleteObject(IconInf.hbmColor);
    DeleteObject(IconInf.hbmMask);
  }
 
  // Procedo a enviar un bloque de memoria con la imagen comprimida en png
  CreateStreamOnHGlobal(0, true, &Stream);
  Gdiplus::DllExports::GdipCreateBitmapFromHBITMAP(Bitmap, 0, &GBitmap);
  GetEncoderCLSID(L"image/png", &Clsid);
  Gdiplus::DllExports::GdipSaveImageToStream(GBitmap, Stream, &Clsid, 0);
  // Obtengo el tamaño del bloque de memoria
  Stream->Stat(&stat, STATFLAG_NONAME);
  // Obtengo el puntero del bloque de memoria (stat.cbSize)
  GetHGlobalFromStream(Stream, &hMem);
  Memory = GlobalLock(hMem);
 
  // Envío el bloque de memoria
  send(hSocket, (BYTE*)Memory, stat.cbSize.LowPart, 0);
 
  // libero los Objetos usados del GDI+
  Gdiplus::DllExports::GdipDisposeImage(GBitmap);
  GlobalUnlock(hMem);
  DeleteObject(Bitmap);
  DeleteDC(hCanvas);
  ReleaseDC(0, hScreen);
  Stream->Release();
 
  // Shutdown GDI+
  Gdiplus::GdiplusShutdown(gdiplusToken);
}

El código es una traducción del escrito en delphi por lo que no requiere mas comentarios que los expuestos mas arriba.
Espero que sea de utilidad.


Saludos.