ImageEnView1 := TImageEnView.Create(nil);
  ImageEnView1.IO.Params.JPEG_EnableAdjustOrientation := True;
  ImageEnView1.IO.Params.Width := 720;
  ImageEnView1.IO.Params.Height := 720;
  ImageEnView1.IO.Params.JPEG_Scale := ioJPEG_AUTOCALC;
  ImageEnView1.IO.LoadFromFileJpeg(PChar(sFileName));

  h := ImageEnView1.Bitmap.Height;
  w := ImageEnView1.Bitmap.Width;

  if (h > w) then
    begin
      h2 := 720;
      if (h <> h2) then
        w2 := Round ( w * (h2 / h) );
    end
  else
    begin
      w2 := 720;
      if (w <> w2) then
        h2 := Round ( h * (w2 / w) );
    end;

  ImageEnView1.Proc.Resample(w2, h2, rfNone);
  ImageEnView1.Proc.AutoSharp(5);
  ImageEnView1.IO.SaveToFileJpeg(sSaveTo);

  FreeAndNil(ImageEnView1);

  if (h > w) then
    begin
      h2 := 720;
      if (h <> h2) then
        w2 := Round ( w * (h2 / h) );
    end
  else
    begin
      w2 := 720;
      if (w <> w2) then
        h2 := Round ( h * (w2 / w) );
    end;

  ImageEnView1.Proc.Resample(w2, h2, rfNone);

ImageEnView1.Proc.Resample(720, 720, rfNone, True);

TProcessingThread = class(TThread)
  private
    { Private declarations }
    procedure ImageEnProcFinishWork(Sender: TObject);
    procedure ImageEnProcProgress(Sender: TObject; per: Integer);
  protected
    { Protected declarations }
    procedure Execute; override;
  public
    { Public declarations }
    constructor Create(CreateSuspended: Boolean);
  end;

{ TProcessingThread }

constructor TProcessingThread.Create(CreateSuspended: Boolean);
{ Create the thread. }
begin
  inherited;
end;

procedure TProcessingThread.ImageEnProcProgress(Sender: TObject; per: Integer);
{ Set the progressbar position. }
begin
  Synchronize(
    procedure
    begin
     { Ensure progress is painted when themes are enabled }
      Form1.ProgressBar1.Position := per;
      Form1.ProgressBar1.Position := per - 10;
      Form1.ProgressBar1.Position := per; 
    end);
end;

procedure TProcessingThread.ImageEnProcFinishWork(Sender: TObject);
{ Reset the progressbar position. }
begin
  Synchronize(
    procedure
    begin
      Form1.ProgressBar1.Position := 0;
    end);
end;

procedure TProcessingThread.Execute;
{ Process the image in the thread.
  Note: All references to GUI elements must occur inside a Synchronize method.
  Synchronize suspends the current thread and has the main thread call the procedure. When
  the procedure finishes, control returns to the current thread. The actual image processing
  is done by an imageenproc (non GUI element) directly in the thread. All of the GUI elements
  are accessed with Synchronize. }
var
  iImageEnProc: TImageEnProc;
  iIEBitmap: TIEBitmap;
  iFilename: string;
  iNewFilename: string;
begin

  inherited;

  { Set the LabelThread caption }
  if not Terminated then
  begin
    { Synchronize GUI elements }
    Synchronize(
      procedure
      begin
        Form1.LabelThread1.Caption := 'Thread is running...';
        Form1.LabelThread1.Update;
        iFilename := Form1.ImageEnView1.IO.Params.FileName;
      end);
  end;

  if not Terminated then
  begin
    { Synchronize GUI elements }
    Synchronize(
      procedure
      begin
        Form1.LabelThread1.Caption := 'Loading the image and creating thumbnail...';
        Form1.LabelThread1.Update;
      end);
  end;

  { Get the IEBitmap }
  if not Terminated then
  begin
    iIEBitmap := TIEBitmap.Create;
    try
      iIEBitmap.IELoadFromFileFast(iFilename, 720, 0, True);
      { Create a copy of ImageEnView bitmap }
      iImageEnProc := TImageEnProc.CreateFromBitmap(iIEBitmap);
      try
       { Set the OnProgress and OnFinishWork events }
        iImageEnProc.OnProgress := ImageEnProcProgress;
        iImageEnProc.OnFinishWork := ImageEnProcFinishWork;
        { resample the image }
        iIEBitmap.IEConvertToThumbnail(720, -1, False, rfLanczos3, False,
          clBlack, False, 4, 4, clBlack, clWhite);

        { AutoSharp Filter }
        if not Terminated then
        begin
          { Synchronize GUI elements }
          Synchronize(
            procedure
            begin
              Form1.LabelProcedure1.Caption := 'Applying Auto Sharp Filter...';
              Form1.LabelProcedure1.Update;
              Form1.Undo1.Hint := 'Applying Auto Sharp Filter…';
              Form1.ImageEnView1.Proc.SaveUndoCaptioned('AutoSharp Filter');
              Form1.StatusBar1.Panels[4].Text := 'Undo: ' +
                IntToStr(Form1.ImageEnView1.Proc.UndoCount);
            end);

          { Actual work done here in the secondary thread }
          iImageEnProc.AutoSharp(5);         
          { Save the thumbnail }
          //iNewFilename :=  
          //iIEBitmap.IESaveToFile(iNewFilename, 80);

          { Synchronize GUI elements }
          Synchronize(
            procedure
            begin
              Form1.ImageEnView1.IEBitmap.Assign(iIEBitmap);
              { update image seen by the user }
              Form1.ImageEnView1.Update;
              Form1.StatusBar1.Panels[2].Text := 'Width: ' +
                IntegerToStr(iIEBitmap.Width);
              Form1.StatusBar1.Panels[3].Text := 'Height: ' +
                IntegerToStr(iIEBitmap.Height);
            end);
        end;
      finally
        { Free iImageEnProc }
        iImageEnProc.Free;
      end;
    finally
      { Free iIEBitmap }
      iIEBitmap.Free;
    end;
  end;
end;

Main Form
public
  { Public declarations }
  AThread: TProcessingThread; { Image processing thread }

procedure TForm1.Process1Click(Sender: TObject);
begin
  { Create the thread suspended }
  AThread := TProcessingThread.Create(True);
  { Free the thread onTerminate }
  AThread.FreeOnTerminate := True;
  { Start the thread }
  AThread.Start;
  { Processing will occur in the TProcessingThread.Execute event }
end;