ITestIntf = interface(IDispatch)
   ['{A95C745C-DD9C-4B79-9402-2E5891D9BB51}']
   procedure TestMethod; safecall;
 end;

 TTestImpl = class(TAutoObject, ITestIntf)
   procedure TestMethod; safecall;
 end;

 TMyChannel = class(TInterfacedObject, IRpcChannelBuffer)
 private
   FStub: IRpcStubBuffer;
 public
   constructor Create; virtual;

   property Stub: IRpcStubBuffer read FStub write FStub;

   function GetBuffer(var message: TRpcOleMessage; iid: TIID): HResult; stdcall;
   function SendReceive(var message: TRpcOleMessage; var status: Longint): HResult; stdcall;
   function FreeBuffer(var message: TRpcOleMessage): HResult; stdcall;
   function GetDestCtx(out dwDestContext: Longint; out pvDestContext): HResult; stdcall;
   function IsConnected: HResult; stdcall;
 end;

procedure TTestImpl.TestMethod;
begin
 ShowMessage('TestMethod');
end;

begin
 FObj := TTestImpl.Create;
 FObj._AddRef;

 Lib := LoadTypeLibrary(ShortToLongFileName(GetModuleFileName));
 Lib.GetTypeInfoOfGuid(IID_ITestIntf, TypInfo);

 OleCheck(CreateStubFromTypeInfo(TypInfo, IID_ITestIntf, nil, Stub));
 OleCheck(CreateProxyFromTypeInfo(TypInfo, nil, IID_ITestIntf, Proxy, ppv));

 Chan := TMyChannel.Create;
 Proxy.Connect(Chan);
 Chan.Stub := Stub;
 Stub.Connect(FObj);

 ITestIntf(ppv).TestMethod;
end;

constructor TMyChannel.Create;
begin
 inherited;
end;

function TMyChannel.FreeBuffer(var message: TRpcOleMessage): HResult;
begin
 FreeMem(message.Buffer);
 Result := S_OK;
end;

function TMyChannel.GetBuffer(var message: TRpcOleMessage; iid: TIID): HResult;
begin
 try
   //message.reserved1 := nil;
   //FillChar(message.reserved2, SizeOf(message.reserved2), 0);
   message.cbBuffer := 2500;
   GetMem(message.Buffer, message.cbBuffer);
   FillChar(message.Buffer^, message.cbBuffer, 0);
   Result := S_OK;
 except
   Result := E_OUTOFMEMORY;
 end;
end;

function TMyChannel.GetDestCtx(out dwDestContext: Integer;
 out pvDestContext): HResult;
begin
 dwDestContext := MSHCTX_LOCAL;
 Result := S_OK;
end;

function TMyChannel.IsConnected: HResult;
begin
 if (FStub <> nil) then
   Result := S_OK
 else
   Result := S_FALSE;
end;

function TMyChannel.SendReceive(var message: TRpcOleMessage;
 var status: Integer): HResult;
begin
 if (Stub <> nil) then
   Result := Stub.Invoke(message, Self)
 else
   Result := S_FALSE;
 if Succeeded(Result) and (status <> 0) then
   status := 0;
end;

function CreateStubFromTypeInfo(
 pTypeInfo: ITypeInfo; const riid: TGUID; pUnkServer: IInterface;
 out ppStub: IRpcStubBuffer): HRESULT; stdcall;
function CreateProxyFromTypeInfo(
 pTypeInfo: ITypeInfo; pUnkOuter: IInterface; const riid: TGUID;
 out ppProxy: IRpcProxyBuffer; out ppv: Pointer): HRESULT; stdcall;
function CreateProxyFromTypeInfo; external RPCDLL name 'CreateProxyFromTypeInfo';
function CreateStubFromTypeInfo; external RPCDLL name 'CreateStubFromTypeInfo';

 TypInfo._Release;
 Lib._Release;

 Msg: TRpcOleMessage;
 I: Integer;

 FillChar(Msg, SizeOf(Msg), 0);
 Msg.dataRepresentation := 16;
 Msg.Buffer := @I;
 Msg.cbBuffer := 4;
 Msg.iMethod := 7;
 I := 101;
 Stub.Invoke(Msg, Chan as IRpcChannelBuffer);

  //message.reserved1 := nil;
  //FillChar(message.reserved2, SizeOf(message.reserved2), 0);

 FillChar(message.reserved2, SizeOf(message.reserved2), 0);
//  message.reserved2[3]:= pointer($100);   !!!!!!!!!

GetBuffer(var message: TRpcOleMessage; iid: TIID)

function CreateProxyFromTypeInfo(
    const pTypeInfo: ITypeInfo;
    const pUnkOuter: IUnknown;
    const iid: TGUID;
    out   pProxy: IRpcProxyBuffer;
    out   ppv): HRESULT; stdcall;

function CreateStubFromTypeInfo(
    const pTypeInfo: ITypeInfo;
    const iid: TGUID;
    const pUnkServer: IUnknown;
    out   ppStub: IRpcStubBuffer): HRESULT; stdcall;