?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Support sub-pixel in drawing commands and more check
[xy_vsfilter.git] / include / realmedia / rmaengin.h
blobabcf8a54221de8404b7fc408b0b21cd857e69e39
1 /****************************************************************************
2 *
3 * $Id: rmaengin.h 7 2003-05-30 02:18:02Z gabest $
4 *
5 * Copyright (C) 1995-1999 RealNetworks, Inc. All rights reserved.
6 *
7 * http://www.real.com/devzone
8 *
9 * This program contains proprietary
10 * information of Progressive Networks, Inc, and is licensed
11 * subject to restrictions on use and distribution.
12 *
13 *
14 * RealMedia Architecture Callback, Networking, and Scheduling interfaces.
15 *
16 */
17
18 #ifndef _RMAENGIN_H_
19 #define _RMAENGIN_H_
20
21 /*
22 * Forward declarations of some interfaces used here-in.
23 */
24
25 typedef _INTERFACE IRMABuffer IRMABuffer;
26 typedef _INTERFACE IRMACallback IRMACallback;
27 typedef _INTERFACE IRMAScheduler IRMAScheduler;
28 typedef _INTERFACE IRMATCPResponse IRMATCPResponse;
29 typedef _INTERFACE IRMALBoundTCPSocket IRMALBoundTCPSocket;
30 typedef _INTERFACE IRMATCPSocket IRMATCPSocket;
31 typedef _INTERFACE IRMAListenResponse IRMAListenResponse;
32 typedef _INTERFACE IRMAListenSocket IRMAListenSocket;
33 typedef _INTERFACE IRMANetworkServices IRMANetworkServices;
34 typedef _INTERFACE IRMANetworkServices2 IRMANetworkServices2;
35 typedef _INTERFACE IRMAUDPResponse IRMAUDPResponse;
36 typedef _INTERFACE IRMAUDPSocket IRMAUDPSocket;
37 typedef _INTERFACE IRMAResolver IRMAResolver;
38 typedef _INTERFACE IRMAResolverResponse IRMAResolverResponse;
39 typedef _INTERFACE IRMAInterruptSafe IRMAInterruptSafe;
40 typedef _INTERFACE IRMAAsyncIOSelection IRMAAsyncIOSelection;
41 typedef _INTERFACE IRMAUDPMulticastInit IRMAUDPMulticastInit;
42 typedef _INTERFACE IRMAInterruptState IRMAInterruptState;
43 typedef _INTERFACE IRMAOptimizedScheduler IRMAOptimizedScheduler;
44
45
46 /*
47 * Address flags starting with PNR are depricated.
48 */
49 #define PNR_INADDR_ANY (UINT32)0x00000000 //THIS FLAG IS DEPRICATED
50 #define PN_INADDR_ANY (UINT32)0x00000000
51
52 /*
53 * 255.255.255.254
54 *
55 * Bind to all ports in IPBindings list from
56 * server config.
57 */
58 #define PNR_INADDR_IPBINDINGS (UINT32)0xfffffffe //THIS FLAG IS DEPRICATED
59 #define PN_INADDR_IPBINDINGS (UINT32)0xfffffffe
60
61
62 /* Async IO Selection Type (Unix Only) */
63
64 #define PNAIO_READ 1
65 #define PNAIO_WRITE 2
66 #define PNAIO_EXCEPTION 4
67
68 /****************************************************************************
69 *
70 * Interface:
71 *
72 * IRMACallback
73 *
74 * Purpose:
75 *
76 * This interface defines a simple callback which will be used in
77 * various interfaces such as IRMAScheduler.
78 *
79 * IID_IRMACallback:
80 *
81 * {00000100-0901-11d1-8B06-00A024406D59}
82 *
83 */
84 DEFINE_GUID(IID_IRMACallback, 0x00000100, 0x901, 0x11d1, 0x8b, 0x6, 0x0,
85 0xa0, 0x24, 0x40, 0x6d, 0x59);
86
87 #undef INTERFACE
88 #define INTERFACE IRMACallback
89
90 DECLARE_INTERFACE_(IRMACallback, IUnknown)
91 {
92 /*
93 * IUnknown methods
94 */
95 STDMETHOD(QueryInterface) (THIS_
96 REFIID riid,
97 void** ppvObj) PURE;
98
99 STDMETHOD_(ULONG,AddRef) (THIS) PURE;
100
101 STDMETHOD_(ULONG,Release) (THIS) PURE;
102
103 /*
104 * IRMACallback methods
105 */
106
107 /************************************************************************
108 * Method:
109 * IRMACallback::Func
110 * Purpose:
111 * This is the function that will be called when a callback is
112 * to be executed.
113 */
114 STDMETHOD(Func) (THIS) PURE;
115 };
116
117
118 /****************************************************************************
119 *
120 * Interface:
121 *
122 * IRMAScheduler
123 *
124 * Purpose:
125 *
126 * This interface provides the user with a way of scheduling callbacks
127 * that will be executed at some time in the future.
128 *
129 * IID_IRMAScheduler:
130 *
131 * {00000101-0901-11d1-8B06-00A024406D59}
132 *
133 */
134 DEFINE_GUID(IID_IRMAScheduler, 0x00000101, 0x901, 0x11d1, 0x8b, 0x6, 0x0,
135 0xa0, 0x24, 0x40, 0x6d, 0x59);
136
137 #undef INTERFACE
138 #define INTERFACE IRMAScheduler
139
140 typedef ULONG32 CallbackHandle;
141
142 typedef struct _RMATimeval
143 {
144 UINT32 tv_sec;
145 UINT32 tv_usec;
146 } RMATimeval;
147
148 DECLARE_INTERFACE_(IRMAScheduler, IUnknown)
149 {
150 /*
151 * IUnknown methods
152 */
153 STDMETHOD(QueryInterface) (THIS_
154 REFIID riid,
155 void** ppvObj) PURE;
156
157 STDMETHOD_(ULONG,AddRef) (THIS) PURE;
158
159 STDMETHOD_(ULONG,Release) (THIS) PURE;
160
161 /*
162 * IRMAScheduler methods
163 */
164
165 /************************************************************************
166 * Method:
167 * IRMAScheduler::RelativeEnter
168 * Purpose:
169 * Schedule a callback to be executed "ms" milliseconds from now
170 * This function is less percise then AbsoluteEnter and should only
171 * be used when accurate timing is not critical.
172 */
173 STDMETHOD_(CallbackHandle,RelativeEnter) (THIS_
174 IRMACallback* pCallback,
175 UINT32 ms) PURE;
176
177 /************************************************************************
178 * Method:
179 * IRMAScheduler::AbsoluteEnter
180 * Purpose:
181 * Schedule a callback to be executed at time "tVal".
182 */
183 STDMETHOD_(CallbackHandle,AbsoluteEnter) (THIS_
184 IRMACallback* pCallback,
185 RMATimeval tVal) PURE;
186
187 /************************************************************************
188 * Method:
189 * IRMAScheduler::Remove
190 * Purpose:
191 * Remove a callback from the scheduler.
192 */
193 STDMETHOD(Remove) (THIS_
194 CallbackHandle Handle) PURE;
195
196 /************************************************************************
197 * Method:
198 * IRMAScheduler::GetCurrentSchedulerTime
199 * Purpose:
200 * Gives the current time (in the timeline of the scheduler).
201 */
202 STDMETHOD_(RMATimeval,GetCurrentSchedulerTime) (THIS) PURE;
203 };
204
205
206 /****************************************************************************
207 *
208 * Interface:
209 *
210 * IRMATCPResponse
211 *
212 * Purpose:
213 *
214 * This is the response interface for the asynchronous TCP networking
215 * interface.
216 *
217 * IID_IRMATCPResponse:
218 *
219 * {00000102-0901-11d1-8B06-00A024406D59}
220 *
221 */
222 DEFINE_GUID(IID_IRMATCPResponse, 0x00000102, 0x901, 0x11d1, 0x8b, 0x6, 0x0,
223 0xa0, 0x24, 0x40, 0x6d, 0x59);
224
225 #undef INTERFACE
226 #define INTERFACE IRMATCPResponse
227
228 DECLARE_INTERFACE_(IRMATCPResponse, IUnknown)
229 {
230 /*
231 * IUnknown methods
232 */
233 STDMETHOD(QueryInterface) (THIS_
234 REFIID riid,
235 void** ppvObj) PURE;
236
237 STDMETHOD_(ULONG,AddRef) (THIS) PURE;
238
239 STDMETHOD_(ULONG,Release) (THIS) PURE;
240
241 /*
242 * IRMATCPResponse methods
243 */
244
245 /************************************************************************
246 * Method:
247 * IRMATCPResponse::ConnectDone
248 * Purpose:
249 * A Connect operation has been completed or an error has occurred.
250 */
251 STDMETHOD(ConnectDone) (THIS_
252 PN_RESULT status) PURE;
253
254 /************************************************************************
255 * Method:
256 * IRMATCPResponse::ReadDone
257 * Purpose:
258 * A Read operation has been completed or an error has occurred.
259 * The data is returned in the IRMABuffer.
260 */
261 STDMETHOD(ReadDone) (THIS_
262 PN_RESULT status,
263 IRMABuffer* pBuffer) PURE;
264
265 /************************************************************************
266 * Method:
267 * IRMATCPResponse::WriteReady
268 * Purpose:
269 * This is the response method for WantWrite.
270 * If PN_RESULT is ok, then the TCP channel is ok to Write to.
271 */
272 STDMETHOD(WriteReady) (THIS_
273 PN_RESULT status) PURE;
274
275 /************************************************************************
276 * Method:
277 * IRMATCPResponse::Closed
278 * Purpose:
279 * This method is called to inform you that the TCP channel has
280 * been closed by the peer or closed due to error.
281 */
282 STDMETHOD(Closed) (THIS_
283 PN_RESULT status) PURE;
284 };
285
286
287 /****************************************************************************
288 *
289 * Interface:
290 *
291 * IRMATCPSocket
292 *
293 * Purpose:
294 *
295 * Provides the user with an asynchronous TCP networking interface.
296 *
297 * IID_IRMATCPSocket:
298 *
299 * {00000103-0901-11d1-8B06-00A024406D59}
300 *
301 */
302 DEFINE_GUID(IID_IRMATCPSocket, 0x00000103, 0x901, 0x11d1, 0x8b, 0x6, 0x0,
303 0xa0, 0x24, 0x40, 0x6d, 0x59);
304
305 #undef INTERFACE
306 #define INTERFACE IRMATCPSocket
307
308 DECLARE_INTERFACE_(IRMATCPSocket, IUnknown)
309 {
310 /*
311 * IUnknown methods
312 */
313 STDMETHOD(QueryInterface) (THIS_
314 REFIID riid,
315 void** ppvObj) PURE;
316
317 STDMETHOD_(ULONG,AddRef) (THIS) PURE;
318
319 STDMETHOD_(ULONG,Release) (THIS) PURE;
320
321 /*
322 * IRMATCPSocket methods
323 *
324 * Network addresses and ports are in native byte order
325 *
326 */
327
328 STDMETHOD(Init) (THIS_
329 IRMATCPResponse* /*IN*/ pTCPResponse) PURE;
330
331 STDMETHOD(SetResponse) (THIS_
332 IRMATCPResponse* pTCPResponse) PURE;
333
334 STDMETHOD(Bind) (THIS_
335 UINT32 ulLocalAddr,
336 UINT16 nPort) PURE;
337
338 /*
339 * pDestination is a string containing host name or dotted-ip notation
340 */
341 STDMETHOD(Connect) (THIS_
342 const char* pDestination,
343 UINT16 nPort) PURE;
344
345 STDMETHOD(Read) (THIS_
346 UINT16 Size) PURE;
347
348 STDMETHOD(Write) (THIS_
349 IRMABuffer* pBuffer) PURE;
350
351 /************************************************************************
352 * Method:
353 * IRMATCPSocket::WantWrite
354 * Purpose:
355 * This method is called when you wish to write a large amount of
356 * data. If you are only writing small amounts of data, you can
357 * just call Write (all data not ready to be transmitted will be
358 * buffered on your behalf). When the TCP channel is ready to be
359 * written to, the response interfaces WriteReady method will be
360 * called.
361 */
362 STDMETHOD(WantWrite) (THIS) PURE;
363
364 /************************************************************************
365 * Method:
366 * IRMATCPSocket::GetForeignAddress
367 * Purpose:
368 * Returns the address of the other end of the TCP socket as a
369 * ULONG32 in local host order
370 */
371 STDMETHOD(GetForeignAddress) (THIS_
372 REF(ULONG32) lAddress) PURE;
373
374 STDMETHOD(GetLocalAddress) (THIS_
375 REF(ULONG32) lAddress) PURE;
376
377 /************************************************************************
378 * Method:
379 * IRMATCPSocket::GetForeignPort
380 * Purpose:
381 * Returns the port of the other end of the TCP socket in local
382 * host order.
383 */
384 STDMETHOD(GetForeignPort) (THIS_
385 REF(UINT16) port) PURE;
386
387 STDMETHOD(GetLocalPort) (THIS_
388 REF(UINT16) port) PURE;
389 };
390
391
392 /****************************************************************************
393 *
394 * Interface:
395 *
396 * IRMAListenResponse
397 *
398 * Purpose:
399 *
400 * This is the response interface for the asynchronous TCP listening
401 * socket interface.
402 *
403 * IID_IRMAListenResponse:
404 *
405 * {00000104-0901-11d1-8B06-00A024406D59}
406 *
407 */
408 DEFINE_GUID(IID_IRMAListenResponse, 0x00000104, 0x901, 0x11d1, 0x8b, 0x6, 0x0,
409 0xa0, 0x24, 0x40, 0x6d, 0x59);
410
411 #undef INTERFACE
412 #define INTERFACE IRMAListenResponse
413
414 DECLARE_INTERFACE_(IRMAListenResponse, IUnknown)
415 {
416 /*
417 * IUnknown methods
418 */
419 STDMETHOD(QueryInterface) (THIS_
420 REFIID riid,
421 void** ppvObj) PURE;
422
423 STDMETHOD_(ULONG,AddRef) (THIS) PURE;
424
425 STDMETHOD_(ULONG,Release) (THIS) PURE;
426
427 /*
428 * IRMAListenResponse methods
429 */
430
431 STDMETHOD(NewConnection) (THIS_
432 PN_RESULT status,
433 IRMATCPSocket* pTCPSocket) PURE;
434 };
435
436 /****************************************************************************
437 *
438 * Interface:
439 *
440 * IRMAListenSocket
441 *
442 * Purpose:
443 *
444 * This interfaces allows you to asynchronously listen on a port for
445 * TCP connections.
446 *
447 * IID_IRMAListenSocket:
448 *
449 * {00000105-0901-11d1-8B06-00A024406D59}
450 *
451 */
452 DEFINE_GUID(IID_IRMAListenSocket, 0x00000105, 0x901, 0x11d1, 0x8b, 0x6, 0x0,
453 0xa0, 0x24, 0x40, 0x6d, 0x59);
454
455 #undef INTERFACE
456 #define INTERFACE IRMAListenSocket
457
458 DECLARE_INTERFACE_(IRMAListenSocket, IUnknown)
459 {
460 /*
461 * IUnknown methods
462 */
463 STDMETHOD(QueryInterface) (THIS_
464 REFIID riid,
465 void** ppvObj) PURE;
466
467 STDMETHOD_(ULONG,AddRef) (THIS) PURE;
468
469 STDMETHOD_(ULONG,Release) (THIS) PURE;
470
471 /*
472 * IRMAListenSocket methods
473 */
474
475 STDMETHOD(Init) (THIS_
476 UINT32 ulLocalAddr,
477 UINT16 port,
478 IRMAListenResponse* /*IN*/ pListenResponse
479 ) PURE;
480 };
481
482
483 /****************************************************************************
484 *
485 * Interface:
486 *
487 * IRMANetworkServices
488 *
489 * Purpose:
490 *
491 * This is a factory interface for the various types of networking
492 * interfaces described above.
493 *
494 * IID_IRMANetworkServices:
495 *
496 * {00000106-0901-11d1-8B06-00A024406D59}
497 *
498 */
499 DEFINE_GUID(IID_IRMANetworkServices, 0x00000106, 0x901, 0x11d1, 0x8b, 0x6, 0x0,
500 0xa0, 0x24, 0x40, 0x6d, 0x59);
501
502 #undef INTERFACE
503 #define INTERFACE IRMANetworkServices
504
505 DECLARE_INTERFACE_(IRMANetworkServices, IUnknown)
506 {
507 /*
508 * IUnknown methods
509 */
510 STDMETHOD(QueryInterface) (THIS_
511 REFIID riid,
512 void** ppvObj) PURE;
513
514 STDMETHOD_(ULONG,AddRef) (THIS) PURE;
515
516 STDMETHOD_(ULONG,Release) (THIS) PURE;
517
518 /*
519 * IRMANetworkServices methods
520 */
521
522 /************************************************************************
523 * Method:
524 * IRMANetworkServices::CreateTCPSocket
525 * Purpose:
526 * Create a new TCP socket.
527 */
528 STDMETHOD(CreateTCPSocket) (THIS_
529 IRMATCPSocket** /*OUT*/ ppTCPSocket) PURE;
530
531 /************************************************************************
532 * Method:
533 * IRMANetworkServices::CreateUDPSocket
534 * Purpose:
535 * Create a new UDP socket.
536 */
537 STDMETHOD(CreateUDPSocket) (THIS_
538 IRMAUDPSocket** /*OUT*/ ppUDPSocket) PURE;
539
540 /************************************************************************
541 * Method:
542 * IRMANetworkServices::CreateListenSocket
543 * Purpose:
544 * Create a new TCP socket that will listen for connections on a
545 * particular port.
546 */
547 STDMETHOD(CreateListenSocket) (THIS_
548 IRMAListenSocket** /*OUT*/ ppListenSocket
549 ) PURE;
550
551 /************************************************************************
552 * Method:
553 * IRMANetworkServices::CreateResolver
554 * Purpose:
555 * Create a new resolver that can lookup host names
556 */
557 STDMETHOD(CreateResolver) (THIS_
558 IRMAResolver** /*OUT*/ ppResolver) PURE;
559 };
560
561
562 /****************************************************************************
563 *
564 * Interface:
565 *
566 * IRMANetworkServices2
567 *
568 * Purpose:
569 *
570 * This is a factory interface for the various types of networking
571 * interfaces described above.
572 *
573 * IID_IRMANetworkServices:
574 *
575 * {17951551-5683-11d3-B6BA-00C0F031C237}
576 *
577 */
578
579 // {17951551-5683-11d3-B6BA-00C0F031C237}
580 DEFINE_GUID(IID_IRMANetworkServices2, 0x17951551, 0x5683, 0x11d3, 0xb6, 0xba, 0x0, 0xc0, 0xf0, 0x31, 0xc2, 0x37);
581
582 #undef INTERFACE
583 #define INTERFACE IRMANetworkServices2
584
585 DECLARE_INTERFACE_(IRMANetworkServices2, IRMANetworkServices)
586 {
587 /************************************************************************
588 * Method:
589 * IRMANetworkServices2::CreateLBoundTCPSocket
590 * Purpose:
591 * Create a new local bound TCP socket.
592 */
593 STDMETHOD(CreateLBoundTCPSocket) (THIS_
594 IRMATCPSocket** /*OUT*/ ppTCPSocket) PURE;
595 };
596
597
598
599 /****************************************************************************
600 *
601 * Interface:
602 *
603 * IRMAUDPResponse
604 *
605 * Purpose:
606 *
607 * This is the response interface for the asynchronous UDP networking
608 * interface.
609 *
610 * IID_IRMAUDPResponse:
611 *
612 * {00000107-0901-11d1-8B06-00A024406D59}
613 *
614 */
615 DEFINE_GUID(IID_IRMAUDPResponse, 0x00000107, 0x901, 0x11d1, 0x8b, 0x6, 0x0,
616 0xa0, 0x24, 0x40, 0x6d, 0x59);
617
618 #undef INTERFACE
619 #define INTERFACE IRMAUDPResponse
620
621 DECLARE_INTERFACE_(IRMAUDPResponse, IUnknown)
622 {
623 /*
624 * IUnknown methods
625 */
626 STDMETHOD(QueryInterface) (THIS_
627 REFIID riid,
628 void** ppvObj) PURE;
629
630 STDMETHOD_(ULONG,AddRef) (THIS) PURE;
631
632 STDMETHOD_(ULONG,Release) (THIS) PURE;
633
634 /*
635 * IRMAUDPResponse methods
636 */
637
638 STDMETHOD(ReadDone) (THIS_
639 PN_RESULT status,
640 IRMABuffer* pBuffer,
641 ULONG32 ulAddr,
642 UINT16 nPort) PURE;
643 };
644
645
646 /****************************************************************************
647 *
648 * Interface:
649 *
650 * IRMAUDPSocket
651 *
652 * Purpose:
653 *
654 * Provides the user with an asynchronous UDP networking interface.
655 *
656 * IID_IRMAUDPSocket:
657 *
658 * {00000108-0901-11d1-8B06-00A024406D59}
659 *
660 */
661 DEFINE_GUID(IID_IRMAUDPSocket, 0x00000108, 0x901, 0x11d1, 0x8b, 0x6, 0x0,
662 0xa0, 0x24, 0x40, 0x6d, 0x59);
663
664 #undef INTERFACE
665 #define INTERFACE IRMAUDPSocket
666
667 DECLARE_INTERFACE_(IRMAUDPSocket, IUnknown)
668 {
669 /*
670 * IUnknown methods
671 */
672 STDMETHOD(QueryInterface) (THIS_
673 REFIID riid,
674 void** ppvObj) PURE;
675
676 STDMETHOD_(ULONG,AddRef) (THIS) PURE;
677
678 STDMETHOD_(ULONG,Release) (THIS) PURE;
679
680 /*
681 * IRMAUDPSocket methods
682 *
683 * Network addresses and ports are in native byte order
684 */
685
686 STDMETHOD(Init) (THIS_
687 ULONG32 ulAddr,
688 UINT16 nPort,
689 IRMAUDPResponse* pUDPResponse) PURE;
690
691 STDMETHOD(Bind) (THIS_
692 UINT32 ulLocalAddr,
693 UINT16 nPort) PURE;
694
695 STDMETHOD(Read) (THIS_
696 UINT16 Size) PURE;
697
698 STDMETHOD(Write) (THIS_
699 IRMABuffer* pBuffer) PURE;
700
701 STDMETHOD(WriteTo) (THIS_
702 ULONG32 ulAddr,
703 UINT16 nPort,
704 IRMABuffer* pBuffer) PURE;
705
706 STDMETHOD(GetLocalPort) (THIS_
707 REF(UINT16) port) PURE;
708
709 STDMETHOD(JoinMulticastGroup) (THIS_
710 ULONG32 ulMulticastAddr,
711 ULONG32 ulInterfaceAddr) PURE;
712
713 STDMETHOD(LeaveMulticastGroup) (THIS_
714 ULONG32 ulMulticastAddr,
715 ULONG32 ulInterfaceAddr) PURE;
716 };
717
718
719 /****************************************************************************
720 *
721 * Interface:
722 *
723 * IRMAResolver
724 *
725 * Purpose:
726 *
727 * This interface allows you to asynchronously resolve hostnames.
728 *
729 * IID_IRMAResolver:
730 *
731 * {00000109-0901-11d1-8B06-00A024406D59}
732 *
733 */
734 DEFINE_GUID(IID_IRMAResolver, 0x00000109, 0x901, 0x11d1, 0x8b, 0x6, 0x0,
735 0xa0, 0x24, 0x40, 0x6d, 0x59);
736
737 #undef INTERFACE
738 #define INTERFACE IRMAResolver
739
740 DECLARE_INTERFACE_(IRMAResolver, IUnknown)
741 {
742 /*
743 * IUnknown methods
744 */
745 STDMETHOD(QueryInterface) (THIS_
746 REFIID riid,
747 void** ppvObj) PURE;
748
749 STDMETHOD_(ULONG,AddRef) (THIS) PURE;
750
751 STDMETHOD_(ULONG,Release) (THIS) PURE;
752
753 /*
754 * IRMAResolver methods
755 */
756
757 STDMETHOD(Init) (THIS_
758 IRMAResolverResponse* pResponse) PURE;
759
760 STDMETHOD(GetHostByName) (THIS_
761 const char* pHostName) PURE;
762 };
763
764
765 /****************************************************************************
766 *
767 * Interface:
768 *
769 * IRMAResolverResponse
770 *
771 * Purpose:
772 *
773 * This is the response interface for the asynchronous DNS hostname
774 * resolver.
775 *
776 * IID_IRMAResolverResponse:
777 *
778 * {0000010A-0901-11d1-8B06-00A024406D59}
779 *
780 */
781 DEFINE_GUID(IID_IRMAResolverResponse, 0x0000010A, 0x901, 0x11d1, 0x8b, 0x6, 0x0,
782 0xa0, 0x24, 0x40, 0x6d, 0x59);
783
784 #undef INTERFACE
785 #define INTERFACE IRMAResolverResponse
786
787 DECLARE_INTERFACE_(IRMAResolverResponse, IUnknown)
788 {
789 /*
790 * IUnknown methods
791 */
792 STDMETHOD(QueryInterface) (THIS_
793 REFIID riid,
794 void** ppvObj) PURE;
795
796 STDMETHOD_(ULONG,AddRef) (THIS) PURE;
797
798 STDMETHOD_(ULONG,Release) (THIS) PURE;
799
800 /*
801 * IRMAResolverResponse methods
802 */
803
804 STDMETHOD(GetHostByNameDone) (THIS_
805 PN_RESULT status,
806 ULONG32 ulAddr) PURE;
807 };
808
809
810 /****************************************************************************
811 *
812 * Interface:
813 *
814 * IRMAInterruptSafe
815 *
816 * Purpose:
817 *
818 * This interface is used in Macintosh implementations of callback
819 * functions, renderers, etc... to determine if interrupt time execution
820 * is supported. If this interface is not implemented then it is assumed
821 * that interrupt time execution is NOT supported. There are restrictions
822 * on what may be executed at interrupt time; please consult the Macintosh
823 * Deferred Task Manager tech notes from Apple.
824 *
825 * IID_IRMAInterruptSafe:
826 *
827 * {0000010B-0901-11d1-8B06-00A024406D59}
828 *
829 */
830 DEFINE_GUID(IID_IRMAInterruptSafe, 0x0000010B, 0x901, 0x11d1, 0x8b, 0x6, 0x0,
831 0xa0, 0x24, 0x40, 0x6d, 0x59);
832
833 #undef INTERFACE
834 #define INTERFACE IRMAInterruptSafe
835
836 DECLARE_INTERFACE_(IRMAInterruptSafe, IUnknown)
837 {
838 /*
839 * IUnknown methods
840 */
841 STDMETHOD(QueryInterface) (THIS_
842 REFIID riid,
843 void** ppvObj) PURE;
844
845 STDMETHOD_(ULONG,AddRef) (THIS) PURE;
846
847 STDMETHOD_(ULONG,Release) (THIS) PURE;
848
849 /*
850 * IRMAInterruptSafe methods
851 */
852
853 /************************************************************************
854 * Method:
855 * IRMAInterruptSafe::IsInterruptSafe
856 * Purpose:
857 * This is the function that will be called to determine if
858 * interrupt time execution is supported.
859 */
860 STDMETHOD_(BOOL,IsInterruptSafe) (THIS) PURE;
861 };
862
863
864 /****************************************************************************
865 *
866 * Interface:
867 *
868 * IRMAAsyncIOSelection
869 *
870 * Purpose:
871 *
872 * This interface is implemented by the server/player context on Unix
873 * platforms. This interface allows your plugin to get callbacks based
874 * I/O events that are normally handled by select(). This interface
875 * allows you to setup callbacks which will be executed when a file
876 * descriptor is ready for reading, writing, or has an exception.
877 *
878 * IID_IRMAAsyncIOSelection:
879 *
880 * {0000010C-0901-11d1-8B06-00A024406D59}
881 *
882 */
883 DEFINE_GUID(IID_IRMAAsyncIOSelection, 0x0000010C, 0x901, 0x11d1, 0x8b, 0x6, 0x0,
884 0xa0, 0x24, 0x40, 0x6d, 0x59);
885
886 #undef INTERFACE
887 #define INTERFACE IRMAAsyncIOSelection
888
889 DECLARE_INTERFACE_(IRMAAsyncIOSelection, IUnknown)
890 {
891 /*
892 * IUnknown methods
893 */
894 STDMETHOD(QueryInterface) (THIS_
895 REFIID riid,
896 void** ppvObj) PURE;
897
898 STDMETHOD_(ULONG,AddRef) (THIS) PURE;
899
900 STDMETHOD_(ULONG,Release) (THIS) PURE;
901
902 /*
903 * IRMAAsyncIOSelection methods
904 */
905
906 /************************************************************************
907 * Method:
908 * IRMAAsyncIOSelection::Add
909 * Purpose:
910 * This function will allow you to receive a callback when the
911 * given descriptor is ready for read, write, or has an
912 * exception. This function is only available on Unix, and is
913 * intended to replace the functionality of select().
914 */
915 STDMETHOD(Add) (THIS_
916 IRMACallback* pCallback,
917 INT32 lFileDescriptor,
918 UINT32 ulType) PURE;
919
920 /************************************************************************
921 * Method:
922 * IRMAAsyncIOSelection::Remove
923 * Purpose:
924 * This function will allow you remove the callback associated
925 * with the given descriptor from the event handler.
926 * This function is only available on Unix, and is intended to
927 * replace the functionality of select().
928 */
929 STDMETHOD(Remove) (THIS_
930 INT32 lFileDescriptor,
931 UINT32 ulType) PURE;
932 };
933
934
935 /****************************************************************************
936 *
937 * Interface:
938 *
939 * IRMAUDPMulticastInit
940 *
941 * Purpose:
942 *
943 * Provides the user with a way to set the TTL for outgoing multicast
944 * UDP packets. Usually shared with IRMAUDPSocket.
945 *
946 * IID_IRMAUDPMulticastInit:
947 *
948 * {0000010D-0901-11d1-8B06-00A024406D59}
949 *
950 */
951 DEFINE_GUID(IID_IRMAUDPMulticastInit, 0x0000010D, 0x901, 0x11d1, 0x8b, 0x6, 0x0,
952 0xa0, 0x24, 0x40, 0x6d, 0x59);
953
954 #undef INTERFACE
955 #define INTERFACE IRMAUDPMulticastInit
956
957 DECLARE_INTERFACE_(IRMAUDPMulticastInit, IUnknown)
958 {
959 /*
960 * IUnknown methods
961 */
962 STDMETHOD(QueryInterface) (THIS_
963 REFIID riid,
964 void** ppvObj) PURE;
965
966 STDMETHOD_(ULONG,AddRef) (THIS) PURE;
967
968 STDMETHOD_(ULONG,Release) (THIS) PURE;
969
970 /*
971 * IRMAUDPMulticastInit methods
972 *
973 */
974
975 /************************************************************************
976 * Method:
977 * IRMAUDPMulticastInit::InitMulticast
978 * Purpose:
979 * This function will set the TTL (time to live) for the UDP socket
980 * so it can be used as a multicast socket, sending packets across
981 * the number of routers specified in the ulTTL parameter.
982 */
983
984 STDMETHOD(InitMulticast) (THIS_
985 UINT8 chTTL) PURE;
986 };
987
988 /****************************************************************************
989 *
990 * Interface:
991 *
992 * IRMAInterruptState
993 *
994 * Purpose:
995 *
996 * This interface is used in Macintosh implementations to inform the
997 * the client engine when entering & leaving an interupt task. It is
998 * also used to determine if it is currently at interrupt time.
999 * Please consult the Macintosh Deferred Task Manager tech notes from Apple
1000 * for information on interrupt tasks.
1001 *
1002 * IID_IRMAInterruptState:
1003 *
1004 * {0000010E-0901-11d1-8B06-00A024406D59}
1005 *
1006 */
1007 DEFINE_GUID(IID_IRMAInterruptState, 0x0000010E, 0x901, 0x11d1, 0x8b, 0x6, 0x0,
1008 0xa0, 0x24, 0x40, 0x6d, 0x59);
1009
1010 #undef INTERFACE
1011 #define INTERFACE IRMAInterruptState
1012
1013 DECLARE_INTERFACE_(IRMAInterruptState, IUnknown)
1014 {
1015 /*
1016 * IUnknown methods
1017 */
1018 STDMETHOD(QueryInterface) (THIS_
1019 REFIID riid,
1020 void** ppvObj) PURE;
1021
1022 STDMETHOD_(ULONG,AddRef) (THIS) PURE;
1023
1024 STDMETHOD_(ULONG,Release) (THIS) PURE;
1025
1026 /*
1027 * IRMAInterruptState methods
1028 */
1029
1030 /************************************************************************
1031 * Method:
1032 * IRMAInterruptState::AtInterruptTime
1033 * Purpose:
1034 * This function is called to determine if we are currently at
1035 * interrupt task time.
1036 */
1037 STDMETHOD_(BOOL,AtInterruptTime) (THIS) PURE;
1038
1039 /************************************************************************
1040 * Method:
1041 * IRMAInterruptState::EnterInterruptState
1042 * Purpose:
1043 * This function is called when starting a deferred/interrupt task
1044 */
1045 STDMETHOD(EnterInterruptState) (THIS) PURE;
1046
1047 /************************************************************************
1048 * Method:
1049 * IRMAInterruptState::LeaveInterruptState
1050 * Purpose:
1051 * This function is called when leaving a deferred/interrupt task
1052 */
1053 STDMETHOD(LeaveInterruptState) (THIS) PURE;
1054
1055 /************************************************************************
1056 * Method:
1057 * IRMAInterruptState::EnableInterrupt
1058 * Purpose:
1059 * This function can be called to enable/disable interrupt time
1060 * processsing
1061 */
1062 STDMETHOD(EnableInterrupt) (THIS_
1063 BOOL bEnable) PURE;
1064
1065 /************************************************************************
1066 * Method:
1067 * IRMAInterruptState::IsInterruptEnabled
1068 * Purpose:
1069 * This function can be called to find if the core is currently
1070 * interrupt enabled.
1071 */
1072 STDMETHOD_(BOOL, IsInterruptEnabled) (THIS) PURE;
1073 };
1074
1075
1076 /****************************************************************************
1077 *
1078 * Interface:
1079 *
1080 * IRMAOptimizedScheduler
1081 *
1082 * Purpose:
1083 *
1084 * This interface provides the user with a way of scheduling callbacks
1085 * that will be executed at some time in the future.
1086 *
1087 * This interface should ONLY be used if you need accurately timed
1088 * callbacks. These callbacks should be efficient and should not consume
1089 * much time/CPU. This is not a thread safe interface. The user has to
1090 * take care of synchronization in their callbacks.
1091 *
1092 * IID_IRMAOptimizedScheduler:
1093 *
1094 * {0000010F-0901-11d1-8B06-00A024406D59}
1095 *
1096 */
1097 DEFINE_GUID(IID_IRMAOptimizedScheduler, 0x0000010F, 0x901, 0x11d1, 0x8b, 0x6, 0x0,
1098 0xa0, 0x24, 0x40, 0x6d, 0x59);
1099
1100 #undef INTERFACE
1101 #define INTERFACE IRMAOptimizedScheduler
1102
1103 DECLARE_INTERFACE_(IRMAOptimizedScheduler, IUnknown)
1104 {
1105 /*
1106 * IUnknown methods
1107 */
1108 STDMETHOD(QueryInterface) (THIS_
1109 REFIID riid,
1110 void** ppvObj) PURE;
1111
1112 STDMETHOD_(ULONG,AddRef) (THIS) PURE;
1113
1114 STDMETHOD_(ULONG,Release) (THIS) PURE;
1115
1116 /*
1117 * IRMAOptimizedScheduler methods
1118 */
1119
1120 /************************************************************************
1121 * Method:
1122 * IRMAOptimizedScheduler::RelativeEnter
1123 * Purpose:
1124 * Schedule a callback to be executed "ms" milliseconds from now
1125 * This function is less percise then AbsoluteEnter and should only
1126 * be used when accurate timing is not critical.
1127 */
1128 STDMETHOD_(CallbackHandle,RelativeEnter) (THIS_
1129 IRMACallback* pCallback,
1130 UINT32 ms) PURE;
1131
1132 /************************************************************************
1133 * Method:
1134 * IRMAOptimizedScheduler::AbsoluteEnter
1135 * Purpose:
1136 * Schedule a callback to be executed at time "tVal".
1137 */
1138 STDMETHOD_(CallbackHandle,AbsoluteEnter) (THIS_
1139 IRMACallback* pCallback,
1140 RMATimeval tVal) PURE;
1141
1142 /************************************************************************
1143 * Method:
1144 * IRMAOptimizedScheduler::Remove
1145 * Purpose:
1146 * Remove a callback from the scheduler.
1147 */
1148 STDMETHOD(Remove) (THIS_
1149 CallbackHandle Handle) PURE;
1150
1151 /************************************************************************
1152 * Method:
1153 * IRMAOptimizedScheduler::GetCurrentSchedulerTime
1154 * Purpose:
1155 * Gives the current time (in the timeline of the scheduler).
1156 */
1157 STDMETHOD_(RMATimeval,GetCurrentSchedulerTime) (THIS) PURE;
1158 };
1159
1160
1161 /****************************************************************************
1162 *
1163 * Interface:
1164 *
1165 * IRMALoadBalancedListen
1166 *
1167 * Purpose:
1168 *
1169 * This interface is queried off of IRMAListenSocket. It allows
1170 * a plugin to specify that it wants the server to load balance
1171 * multiple instances of itself. The server will instantiate multiple
1172 * instances of the plugin as needed based on socket / descriptor limits.
1173 * Each plugin instance should attempt to listen on the same port as
1174 * other instances (they will share the port).
1175 *
1176 * IID_IRMALoadBalancedListen:
1177 *
1178 * {00000110-0901-11d1-8B06-00A024406D59}
1179 *
1180 */
1181 DEFINE_GUID(IID_IRMALoadBalancedListen, 0x00000110, 0x901, 0x11d1, 0x8b, 0x6, 0x0,
1182 0xa0, 0x24, 0x40, 0x6d, 0x59);
1183
1184 #undef INTERFACE
1185 #define INTERFACE IRMALoadBalancedListen
1186
1187 DECLARE_INTERFACE_(IRMALoadBalancedListen, IUnknown)
1188 {
1189 /*
1190 * IUnknown methods
1191 */
1192 STDMETHOD(QueryInterface) (THIS_
1193 REFIID riid,
1194 void** ppvObj) PURE;
1195
1196 STDMETHOD_(ULONG,AddRef) (THIS) PURE;
1197
1198 STDMETHOD_(ULONG,Release) (THIS) PURE;
1199
1200 /*
1201 * IRMALoadBalancedListen methods
1202 */
1203
1204 /************************************************************************
1205 * Method:
1206 * IRMALoadBalancedListen::SetID
1207 * Purpose:
1208 * This function set's the unique ID for this listen socket. This
1209 * ID is used to determine whether or not different instances of
1210 * a plugin trying to listen on a single port are actually the
1211 * same plugin. Without this function, it would be possible for
1212 * two completely different plugins to listen on the same port using
1213 * the load balanced listener.
1214 */
1215 STDMETHOD(SetID) (THIS_
1216 REFIID ID) PURE;
1217
1218 /************************************************************************
1219 * Method:
1220 * IRMALoadBalancedListen::SetReserveLimit
1221 * Purpose:
1222 * Sets the reserve limit for descriptors / sockets. If less
1223 * than reserve limit descriptors / sockets are left then a new
1224 * instance of the plugin will be created.
1225 */
1226 STDMETHOD(SetReserveLimit) (THIS_
1227 UINT32 ulDescriptors,
1228 UINT32 ulSockets) PURE;
1229 };
1230
1231
1232 /****************************************************************************
1233 *
1234 * Interface:
1235 *
1236 * IRMAOverrideDefaultServices
1237 *
1238 * Purpose:
1239 *
1240 * This interface is queried off of the context. It allows
1241 * a plugin to override any default services provided by the G2 system.
1242 * Currently, it is supported only on the client side.
1243 * You may currently override IRMANetworkServices using this interface
1244 * You can use the same interface to later restore back the overriden services.
1245 * This is done by calling the same OverrideServices() function with the
1246 * original service QIed before the initial override.
1247 *
1248 * IID_IRMAOverrideDefaultServices:
1249 *
1250 * {00000111-0901-11d1-8B06-00A024406D59}
1251 *
1252 */
1253 DEFINE_GUID(IID_IRMAOverrideDefaultServices, 0x00000111, 0x901, 0x11d1, 0x8b, 0x6, 0x0,
1254 0xa0, 0x24, 0x40, 0x6d, 0x59);
1255
1256 #undef INTERFACE
1257 #define INTERFACE IRMAOverrideDefaultServices
1258
1259 DECLARE_INTERFACE_(IRMAOverrideDefaultServices, IUnknown)
1260 {
1261 /*
1262 * IUnknown methods
1263 */
1264 STDMETHOD(QueryInterface) (THIS_
1265 REFIID riid,
1266 void** ppvObj) PURE;
1267
1268 STDMETHOD_(ULONG,AddRef) (THIS) PURE;
1269
1270 STDMETHOD_(ULONG,Release) (THIS) PURE;
1271
1272 /*
1273 * IRMAOverrideDefaultServices methods
1274 */
1275
1276 /************************************************************************
1277 * Method:
1278 * IRMAOverrideDefaultServices::OverrideServices
1279 * Purpose:
1280 * Override default services provided by the G2 system.
1281 *
1282 */
1283 STDMETHOD(OverrideServices) (THIS_
1284 IUnknown* pContext) PURE;
1285 };
1286
1287 enum PN_SOCKET_OPTION
1288 {
1289 PN_SOCKOPT_REUSE_ADDR,
1290 PN_SOCKOPT_REUSE_PORT,
1291 PN_SOCKOPT_BROADCAST,
1292 PN_SOCKOPT_SET_RECVBUF_SIZE,
1293 PN_SOCKOPT_SET_SENDBUF_SIZE
1294 };
1295
1296 /****************************************************************************
1297 *
1298 * Interface:
1299 *
1300 * IRMASetSocketOption
1301 *
1302 * Purpose:
1303 *
1304 * Set sockt option
1305 *
1306 * IID_IRMASetSocketOption:
1307 *
1308 * IID_IRMASetSocketOption: {00000114-0901-11d1-8B06-00A024406D59}
1309 *
1310 */
1311 DEFINE_GUID(IID_IRMASetSocketOption,
1312 0x00000114, 0x901, 0x11d1, 0x8b, 0x6, 0x0, 0xa0, 0x24, 0x40, 0x6d, 0x59);
1313
1314 #undef INTERFACE
1315 #define INTERFACE IRMASetSocketOption
1316 DECLARE_INTERFACE_(IRMASetSocketOption, IUnknown)
1317 {
1318 /*
1319 * IUnknown methods
1320 */
1321 STDMETHOD(QueryInterface) (THIS_
1322 REFIID riid,
1323 void** ppvObj) PURE;
1324
1325 STDMETHOD_(ULONG,AddRef) (THIS) PURE;
1326
1327 STDMETHOD_(ULONG,Release) (THIS) PURE;
1328
1329 /*
1330 * IRMAListenSocket methods
1331 */
1332
1333 STDMETHOD(SetOption) (THIS_
1334 PN_SOCKET_OPTION option,
1335 UINT32 ulValue) PURE;
1336 };
1337
1338 #define RMA_THREADSAFE_METHOD_FF_GETPACKET 0x00000001
1339 /*
1340 * FileFormat::GetPacket() only calls:
1341 * CCF->CI(Buffer), CCF->CI(Packet), CCF->CI(Values), *Alloc, *Free,
1342 * FS->Read(), FS->Close(), FS->Seek(),
1343 * FFR->PacketReady(), FFR->StreamDone()
1344 * Context->Scheduler->*,
1345 * CCF->CI(Mutex), Mutex->*
1346 * Context->ErrorMessages
1347 *
1348 * XXXSMPNOW
1349 */
1350
1351 #define RMA_THREADSAFE_METHOD_FS_READ 0x00000002
1352 /*
1353 * FileSystem::Read()/Seek()/Close() only calls:
1354 * CCF->CI(Buffer), CCF->CI(Packet), CCF->CI(Values), *Alloc, *Free,
1355 * FS->Read(), FS->Close(), FS->Seek(),
1356 * Context->Scheduler->*,
1357 * CCF->CI(Mutex), Mutex->*
1358 * Context->ErrorMessages
1359 *
1360 * XXXSMPNOW
1361 */
1362 #define RMA_THREADSAFE_METHOD_FSR_READDONE 0x00000004
1363 /*
1364 * FileFormat::ReadDone()/SeekDone()/CloseDone() only calls:
1365 * CCF->CI(Buffer), CCF->CI(Packet), CCF->CI(Values), *Alloc, *Free,
1366 * FS->Read(), FS->Close(), FS->Seek(),
1367 * FFR->PacketReady(), FFR->StreamDone()
1368 * Context->Scheduler->*,
1369 * CCF->CI(Mutex), Mutex->*
1370 * Context->ErrorMessages
1371 *
1372 * XXXSMPNOW
1373 */
1374 #define RMA_THREADSAFE_METHOD_CACHE_FILE 0x00000008
1375 /*
1376 * FileSystem::Read()/Seek()/Close() only calls:
1377 * CCF->CI(Buffer), CCF->CI(Packet), CCF->CI(Values), *Alloc, *Free,
1378 * FS->Read(), FS->Close(), FS->Seek(),
1379 * IRMACacheFile->*, IRMACacheFileResponse->*,
1380 * Context->Scheduler->*,
1381 * CCF->CI(Mutex), Mutex->*
1382 * Context->ErrorMessages
1383 *
1384 * XXXSMPNOW
1385 */
1386 #define RMA_THREADSAFE_METHOD_CACHE_FILE_RESPONSE 0x00000010
1387 /*
1388 * FileSystem::Read()/Seek()/Close() only calls:
1389 * CCF->CI(Buffer), CCF->CI(Packet), CCF->CI(Values), *Alloc, *Free,
1390 * FS->Read(), FS->Close(), FS->Seek(),
1391 * IRMACacheFile->*, IRMACacheFileResponse->*,
1392 * Context->Scheduler->*,
1393 * CCF->CI(Mutex), Mutex->*
1394 * Context->ErrorMessages
1395 *
1396 * XXXSMPNOW
1397 */
1398
1399 /****************************************************************************
1400 *
1401 * Interface:
1402 *
1403 * IRMAThreadSafeMethods
1404 *
1405 * Purpose:
1406 *
1407 * XXXSMPNOW
1408 *
1409 * IID_IRMAThreadSafeMethods:
1410 *
1411 * {00000115-0901-11d1-8B06-00A024406D59}
1412 *
1413 */
1414 DEFINE_GUID(IID_IRMAThreadSafeMethods, 0x00000115, 0x901, 0x11d1, 0x8b, 0x6, 0x0,
1415 0xa0, 0x24, 0x40, 0x6d, 0x59);
1416
1417 #undef INTERFACE
1418 #define INTERFACE IRMAThreadSafeMethods
1419
1420 DECLARE_INTERFACE_(IRMAThreadSafeMethods, IUnknown)
1421 {
1422 /*
1423 * IUnknown methods
1424 */
1425 STDMETHOD(QueryInterface) (THIS_
1426 REFIID riid,
1427 void** ppvObj) PURE;
1428
1429 STDMETHOD_(ULONG,AddRef) (THIS) PURE;
1430
1431 STDMETHOD_(ULONG,Release) (THIS) PURE;
1432
1433 /*
1434 * IRMAThreadSafeMethods methods
1435 */
1436
1437 /************************************************************************
1438 * Method:
1439 * IRMAThreadSafeMethods::IsThreadSafe
1440 * Purpose:
1441 * XXXSMPNOW
1442 */
1443 STDMETHOD_(UINT32,IsThreadSafe) (THIS) PURE;
1444 };
1445
1446
1447 /****************************************************************************
1448 *
1449 * Interface:
1450 *
1451 * IRMAMutex
1452 *
1453 * Purpose:
1454 *
1455 * XXXSMPNOW
1456 *
1457 * IID_IRMAMutex:
1458 *
1459 * {00000116-0901-11d1-8B06-00A024406D59}
1460 *
1461 */
1462 DEFINE_GUID(IID_IRMAMutex, 0x00000116, 0x901, 0x11d1, 0x8b, 0x6, 0x0,
1463 0xa0, 0x24, 0x40, 0x6d, 0x59);
1464
1465 #undef INTERFACE
1466 #define INTERFACE IRMAMutex
1467
1468 /*
1469 * The IRMACommonClassFactory supports creating an instance
1470 * of this object.
1471 */
1472 #define CLSID_IRMAMutex IID_IRMAMutex
1473
1474 DECLARE_INTERFACE_(IRMAMutex, IUnknown)
1475 {
1476 /*
1477 * IUnknown methods
1478 */
1479 STDMETHOD(QueryInterface) (THIS_
1480 REFIID riid,
1481 void** ppvObj) PURE;
1482
1483 STDMETHOD_(ULONG,AddRef) (THIS) PURE;
1484
1485 STDMETHOD_(ULONG,Release) (THIS) PURE;
1486
1487 /*
1488 * IRMAMutex methods
1489 */
1490
1491 /* XXXSMPNOW Comments */
1492 STDMETHOD(Lock) (THIS) PURE;
1493
1494 STDMETHOD(TryLock) (THIS) PURE;
1495
1496 STDMETHOD(Unlock) (THIS) PURE;
1497 };
1498
1499
1500 #endif /* _RMAENGIN_H_ */
vsfilter mod based on vsfilter 2.39