library invertt;

uses
  avisynth_c in '..\avisynth_c.pas', extctrls;

type
  PByteArray = ^TByteArray;
  TByteArray = array[0..32767] of Byte;
  Timer = TTimer;

constructor Create;
begin
   inherited;
   Timer.Enabled:=true;
   Timer.OnTimer:=Next;
end;

function invertt_get_frame(p: PAVS_FilterInfo; n: Integer): PAVS_VideoFrame; stdcall;
var
  src, dest: PAVS_VideoFrame;
  row_size, height, src_pitch, dest_pitch: Integer;
  src_data, dest_data: PByte;
  x, y: Integer;
  width, r: Integer;
begin
  src := avs_get_frame(p^.child, n);
  dest := avs_new_video_frame(p^.env, @p^.vi);

  src_data := avs_get_read_ptr(src);
  dest_data := avs_get_write_ptr(dest);
  src_pitch := avs_get_pitch(src);
  dest_pitch := avs_get_pitch(dest);

  row_size := avs_get_row_size(src);
  height := avs_get_height(src);
  width := row_size div 3;

  for y := 0 to height - 1  do
  begin

    for x := 0 to width - 1 do
      Begin
        PByteArray(dest_data)^[ x*3 ] :=  PByteArray(src_data)^[ x*3 ] + random (2*r) - r;  // Ñþäà ñìîòðè
        PByteArray(dest_data)^[ x*3+1 ] :=  PByteArray(src_data)^[ x*3+1 ] + random (2*r) - r;
        PByteArray(dest_data)^[ x*3+2 ] :=  PByteArray(src_data)^[ x*3+2 ] + random (2*r) - r;
      End;
    Inc(src_data, src_pitch);
    Inc(dest_data, dest_pitch);
  end;

  avs_release_video_frame(src);
  Result := dest;
end;

function invertt_inplace_get_frame(p: PAVS_FilterInfo; n: Integer): PAVS_VideoFrame; stdcall;
var
  frame: PAVS_VideoFrame;
  row_size, height, pitch: Integer;
  data: PByte;
  x, y: Integer;
begin
  frame := avs_get_frame(p^.child, n);

  avs_make_writable(p^.env, frame);

  data := avs_get_write_ptr(frame);
  pitch := avs_get_pitch(frame);
  row_size := avs_get_row_size(frame);
  height := avs_get_height(frame);

  for y := 0 to height - 1 do
  begin
    for x := 0 to row_size - 1 do
//      PByteArray(data)^[x] := not PByteArray(data)^[x];
    Inc(data, pitch);
  end;

  Result := frame;
end;

function create_invertt(env: PAVS_ScriptEnvironment; args: MSVC_AVS_Value; use_inplace: Pointer): MSVC_AVS_Value; stdcall;
var
  v: AVS_Value;
  fi: PAVS_FilterInfo;
  new_clip: PAVS_Clip;
begin;
  new_clip := avs_new_c_filter(env, fi, avs_array_elt(AVS_Value(args), 0), true);
  if (avs_is_planar(@fi^.vi)) then
    v := avs_new_value_error('Videoooo must be on a single plane')
  else
  begin
    if use_inplace = nil then
      fi^.get_frame := @invertt_get_frame
    else
      fi^.get_frame := @invertt_inplace_get_frame;

    v := avs_new_value_clip(new_clip);
  end;
  avs_release_clip(new_clip);
  Result := MSVC_AVS_Value(v);
end;

function avisynth_c_plugin_init(env: PAVS_ScriptEnvironment): PChar; stdcall;
begin
  avs_add_function(env, 'Invertt', 'c', @create_invertt, nil);
  avs_add_function(env, 'InverttInplace', 'c', @create_invertt, pointer(1));
  Result := '`Invertt'' sample plugin';
end;

exports
  avisynth_c_plugin_init;
end.