Javascript Disabled Detected

You currently have javascript disabled. Several functions may not work. Please re-enable javascript to access full functionality.

[MULTILENGUAJE] Extrayendo los archivos multiframe con GDIplus

Started by escafandra , Sep 09 2018 09:42 AM

Please log in to reply

2 replies to this topic

#1 escafandra

Advanced Member

Administrador
4111 posts

LocationMadrid - España

Posted 09 September 2018 - 09:42 AM

En esta ocasión os voy a mostrar una pequeña aplicación de consola que extrae y escribe en disco cada imagen de un archivo multiframe. El formato de escritura será cualquiera de los que soporta GDI+, por defecto es jpg y la calidad de compresión será configurable de 1 a 100, siendo 100 por defecto. Los nombres de los archivos escritos serán como el del original añadiendo un número que corresponde al indice del frame extraído.

La sintaxis:

delphi

GrExtract FileName [format graphic Ext] [%Quality]

Esta es la unidad corazón del sistema:

delphi

unit GDI_Extract;
 
//------------------------------------------------------------------------------
// GDI_Extract V 1.0
// escafandra 2018
// Clase para extraer archivos de un archivo grafico multipágina
// Usa GDI+
 
 
interface
 
uses
  Windows;
 
 
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;
 
TEncoderParameter = packed record
   Guid:           TGUID;
   NumberOfValues: ULONG;
   Type_:          ULONG;
   Value:          Pointer;
end;
PEncoderParameter = ^TEncoderParameter;
 
TEncoderParameters = packed record
   Count     : UINT;
   Parameter : array[0..0] of TEncoderParameter;
end;
PEncoderParameters = ^TEncoderParameters;
 
function Extract(FileName, _format: PWCHAR; Quality: ULONG = 100): boolean;
 
function  wcscmp(wstr1, wstr2: PWCHAR): Integer; cdecl external 'crtdll';
function  wsprintfW(lpOut, lpFmt: PWCHAR): Integer; cdecl; varargs; external 'User32.dll' name 'wsprintfW';
function  AttachConsole(dwProcessId: DWORD): BOOL; stdcall external 'Kernel32.dll';
 
// GDI+ Flat API...
function  GdiplusStartup(var GdiToken: DWORD; Startup, Output: PBYTE): Cardinal; stdcall external 'gdiplus';
procedure GdiplusShutdown(GdiToken: DWORD); stdcall external 'gdiplus';
function  GdipLoadImageFromFile(lpFileName: PWideChar; var hImage: THANDLE): DWORD; stdcall external 'gdiplus';
function  GdipImageGetFrameDimensionsList(hImage: THANDLE; dimensionIDs: PGUID; Count: Integer): DWORD; stdcall external 'gdiplus';
function  GdipImageGetFrameCount(hImage: THANDLE; lpDimensionID: PGUID; out Count: UINT): DWORD; stdcall external 'gdiplus';
function  GdipImageSelectActiveFrame(hImage: THANDLE; DimensionID: PGUID; frameIndex: Integer): DWORD; 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  GdipSaveImageToFile(image: THANDLE; FileName: PWCHAR; var clsidEncoder: TCLSID; encoderParams: Pointer): Cardinal; stdcall external 'gdiplus';
 
 
implementation
 
// Calidad de imagen y factor de compresión
// Quality = 100 es la maxima calidad.
procedure GetEncoderParameters(EP: PEncoderParameters; Quality: PULONG);
const
  EncoderQuality: TGUID = '{1d5be4b5-fa4a-452d-9cdd-5db35105e7eb}';
begin
  EP.Count:= 1;
  EP.Parameter[0].Guid:= EncoderQuality;
  EP.Parameter[0].Type_:= 4; //Gdiplus::EncoderParameterValueTypeLong;
  EP.Parameter[0].NumberOfValues:= 1;
  EP.Parameter[0].Value:= Quality;
end;
 
// 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
  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;
 
function Extract(FileName, _format: PWCHAR; Quality: ULONG = 100): boolean;
var
  gdiplusToken: DWORD;
  GdiPlusStartupInput: array[0..2] of int64;
  hGdipImage: THANDLE;
  Clsid: TCLSID;
  EP: TEncoderParameters;
  dimensionID: TGUID;
  Frames: UINT;
  Index: integer;
  Format: Array [0..80] of WCHAR;
  lpFile: Array [0..MAX_PATH] of WCHAR;
  Ext: PWCHAR;
begin
  Result:= false;
 
  // Inicializamos GDI+.
  GdiPlusStartupInput[0]:= 1; GdiPlusStartupInput[1]:= 0;
  if GdiplusStartup(gdiplusToken, @GdiPlusStartupInput, nil) <> 0 then exit;
 
  if lstrcmpiW(_format, 'jpg') = 0 then
    wsprintfW(@Format, 'image/jpeg')
  else if lstrcmpiW(_format, 'tif') = 0 then
    wsprintfW(@Format, 'image/tiff')
  else
    wsprintfW(@Format, 'image/%s', _format);
 
  lstrcpyW(@lpFile, FileName);
  Ext:= @lpFile[lstrlenW(@lpFile)-4];
 
  if GdipLoadImageFromFile(FileName, hGdipImage) <> 0 then exit;
  if hGdipImage = 0 then exit;
 
  GetEncoderClsid(@Format, Clsid);
  GetEncoderParameters(@EP, @Quality);
 
  if hGdipImage <> 0 then
  begin
    GdipImageGetFrameDimensionsList(hGdipImage, @dimensionID, 1);
    GdipImageGetFrameCount(hGdipImage, @dimensionID, Frames);
    for Index:= 0 to Frames-1 do
    begin
      GdipImageSelectActiveFrame(hGdipImage, @dimensionID, Index);
      wsprintfW(Ext, '%d.%s', Index, _format);
      GdipSaveImageToFile(hGdipImage, @lpFile, Clsid, @EP);
    end;
  end;
  GdipDisposeImage(hGdipImage);
  GdiplusShutdown(gdiplusToken);
  Result:= true;
end;
 
end.

Y esta es la aplicación de consola que sirve de interface:

delphi

program Gr_Extract;
 
 
uses
  Windows, ShellAPI, GDI_Extract;
 
 
function  _wtoi(wstr: PWCHAR): Integer; cdecl external 'crtdll';
 
type
AWCHAR  = Array [0..10] of PWCHAR;
PAWCHAR = ^AWCHAR;
 
var
  Argc: integer;
  Argv: PAWCHAR;
  Help: ShortString;
  F: THANDLE;
begin
  // Buscando los parámetros pasados
  Argv:= PAWCHAR(CommandLineToArgvW(GetCommandLineW, Argc));
 
  // Si no hay parámetros, muestro ayuda
  if Argc <= 1 then
  begin
    Help:= #10+#10+'GrExtract FileName [format graphic Ext] [%Quality]' +#10 + #0;
    AttachConsole(DWORD(-1));
    F:= CreateFile('CONOUT$', GENERIC_READ or GENERIC_WRITE, FILE_SHARE_WRITE, nil, OPEN_EXISTING, 0, 0);
    WriteConsole(F, @Help[1], lstrlen(@Help[1]), PDWORD(nil)^, nil);
    CloseHandle(F);
    FreeConsole;
  end
  else if Argc = 2 then
    Extract(Argv[1], 'jpg')
  else if Argc = 3 then
    Extract(Argv[1], Argv[2])
  else if Argc > 3 then
    Extract(Argv[1], Argv[2], _wtoi(Argv[3]));
 
end.

Si la aplicación se ejecuta en una consola mostrará los errores de sintaxis en ella. En caso contrario será mudo. Para realizar la extracción de los frames de un archivo Gif o Tif, soltadlo sobre el ejecutable o usad la consola para pasar más parámetros.

Saludos.

Attached Files

Gr_Extract_Delphi.rar 12.09KB 1 downloads

0

Back to top

#2 escafandra

Advanced Member

Administrador
4111 posts

LocationMadrid - España

Posted 09 September 2018 - 09:45 AM

La versión C/Cpp es idéntica:

La sintaxis:

php

GrExtract FileName [format graphic Ext] [%Quality]

La unidad extractora:

cpp

//------------------------------------------------------------------------------
// GifExtract V 1.0
// escafandra 2018
// Clase para representar un gif estático o animado sobre cualquier ventana.
// Usa GDI+
 
 
#include <windows.h>
#include <initguid.h>
#pragma hdrstop
 
#pragma link "gdiplus.lib"
 
struct EncoderParameter
{
  GUID    Guid;               // GUID of the parameter
  ULONG   NumberOfValues;     // Number of the parameter values
  ULONG   Type;               // Value type, like ValueTypeLONG  etc.
  VOID*   Value;              // A pointer to the parameter values
};
 
struct EncoderParameters
{
  UINT Count;                  // Number of parameters in this struct
  EncoderParameter Parameter[1]; // Parameter values
};
 
struct ImageCodecInfo
{
  CLSID Clsid;
  GUID FormatID;
  PWCHAR CodecName;
  PWCHAR DllName;
  PWCHAR FormatDescription;
  PWCHAR FilenameExtension;
  PWCHAR MimeType;
  DWORD Flags;
  DWORD Version;
  DWORD SigCount;
  DWORD SigSize;
  PBYTE SigPattern;
  PBYTE SigMask;
};
 
extern "C"{
DWORD __stdcall GdiplusStartup(ULONG_PTR *hToken, void *input, void *Output);
void  __stdcall GdiplusShutdown(ULONG_PTR token);
DWORD __stdcall GdipLoadImageFromFile(PWCHAR FileName, HANDLE &hImage);
DWORD __stdcall GdipSaveImageToFile(HANDLE himage, PWCHAR FileName, CLSID &clsidEncoder, void *encoderParams);
DWORD __stdcall GdipGetImageEncodersSize(UINT *numEncoders, UINT *size);
DWORD __stdcall GdipGetImageEncoders(UINT numEncoders,  UINT size, ImageCodecInfo *encoders);
DWORD __stdcall GdipImageGetFrameDimensionsList(HANDLE image, GUID* dimensionIDs, UINT count);
DWORD __stdcall GdipImageGetFrameCount(HANDLE image, const GUID* dimensionIDs, UINT *count);
DWORD __stdcall GdipImageSelectActiveFrame(HANDLE image, const GUID* dimensionIDs, UINT frameIndex);
DWORD __stdcall GdipDisposeImage(HANDLE hImage);
}
 
 
WCHAR lpFile[MAX_PATH];
 
//---------------------------------------------------------------------------
 
void GetEncoderParameters(EncoderParameters *EP, PULONG Quality)
{
  // Calidad de imagen y dfactor de compresión
  // 100 = maxima calidad
  // _GUID _EncoderQuality: Adaptado de GdiplusImaging.h para evitar error en Link
  _GUID _EncoderQuality = {0x1d5be4b5,0xfa4a,0x452d,0x9c,0xdd,0x5d,0xb3,0x51,0x05,0xe7,0xeb};
  EP->Count = 1;
  EP->Parameter[0].Guid = _EncoderQuality;
  EP->Parameter[0].Type = 4;  //Gdiplus::EncoderParameterValueTypeLong; //GdiplusEnums.h
  EP->Parameter[0].NumberOfValues = 1;
  EP->Parameter[0].Value = Quality;
}
//---------------------------------------------------------------------------
 
bool GetEncoderClsid(const WCHAR* Format, CLSID* Clsid)
{
  UINT i=0, N=0, Size=0;
 
  GdipGetImageEncodersSize(&N, &Size);
  if(!Size) return false;
 
  ImageCodecInfo* ICInfo = new ImageCodecInfo[Size];
  GdipGetImageEncoders(N, Size, ICInfo);
 
  while (i<N && wcscmp(ICInfo[i].MimeType, Format)) i++;
  if(i<N) *Clsid = ICInfo[i].Clsid;
  delete [] ICInfo;
 
  return (i<N);
}
//---------------------------------------------------------------------------
 
 
BOOL __stdcall Extract(PWCHAR FileName, PWCHAR format, ULONG Quality = 100)
{
  ULONG_PTR  gdiplusToken;
  char GdiPlusStartupInput[16] = {1,0};
  HANDLE hGdipImage;
  GUID   dimensionID;
  UINT   Frames;
  CLSID  Clsid;
  EncoderParameters EP;
  WCHAR Format[20];
 
  GdiplusStartup(&gdiplusToken, GdiPlusStartupInput, NULL);
 
  if(!lstrcmpiW(format, L"jpg"))
    wsprintfW(Format, L"image/jpeg");
  else if(!lstrcmpiW(format, L"tif"))
    wsprintfW(Format, L"image/tiff");
  else
    wsprintfW(Format, L"image/%s", format);
 
  lstrcpyW(lpFile, FileName);
  PWCHAR Ext = &lpFile[lstrlenW(lpFile)-4];
 
  if(GdipLoadImageFromFile(FileName, hGdipImage) !=0) return false;
  if(!hGdipImage) return false;
  GetEncoderClsid(Format, &Clsid);
  GetEncoderParameters(&EP, &Quality);
 
  if(hGdipImage){
    GdipImageGetFrameDimensionsList(hGdipImage, &dimensionID, 1);
    GdipImageGetFrameCount(hGdipImage, &dimensionID, &Frames);
    for(int Index = 0; Index < Frames; Index++){
      GdipImageSelectActiveFrame(hGdipImage, &dimensionID, Index);
      wsprintfW(Ext, L"%d.%s", Index, format);
      GdipSaveImageToFile(hGdipImage, lpFile, Clsid, &EP);
    }
  }
  GdipDisposeImage(hGdipImage);
  GdiplusShutdown(gdiplusToken);
  return true;
}

Y la interface de consola:

cpp

//---------------------------------------------------------------------------
 
#include <windows.h>
#pragma hdrstop
 
#pragma link "gdiplus.lib"
 
typedef BOOL (WINAPI *PAttachConsole)(DWORD dwProcessId);
 
BOOL __stdcall Extract(PWCHAR FileName, PWCHAR format, ULONG Quality = 100);
 
PWCHAR lpFileName;
 
//---------------------------------------------------------------------------
#pragma argsused
WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
  int Argc;
  LPWSTR *Argv = CommandLineToArgvW(GetCommandLineW(), &Argc);
  if(Argc <= 1){
    char Help[] = "\nGrExtract FileName [format graphic Ext] [%Quality]\n";
    PAttachConsole AttachConsole = (PAttachConsole)GetProcAddress(GetModuleHandle("Kernel32.dll"), "AttachConsole");
    AttachConsole(-1);
    HANDLE F = CreateFile("CONOUT$", GENERIC_READ | GENERIC_WRITE, FILE_SHARE_WRITE, 0, OPEN_EXISTING, 0, 0 );
    WriteConsole(F, Help, lstrlen(Help), 0, 0);
  }
  else if(Argc == 2)
    Extract(Argv[1], L"jpg");
  else if(Argc == 3)
    Extract(Argv[1], Argv[2]);
  else if(Argc > 3)
    Extract(Argv[1], Argv[2], _wtoi(Argv[3]));
  return 0;
}
//---------------------------------------------------------------------------