include/axcore.idl

   1 /*
   2  * Copyright (C) 2002 Robert Shearman
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #if 0
  20 #pragma makedep install
  21 #endif
  22
  23 #define CHARS_IN_GUID 39
  24 cpp_quote("#define CHARS_IN_GUID 39")
  25
  26 /* GetTimeFormat is defined in winnls.h as
  27  * either the W or A suffixed version */
  28 cpp_quote("#ifdef WINE_NO_UNICODE_MACROS")
  29 cpp_quote("#undef GetTimeFormat")
  30 cpp_quote("#endif")
  31
  32 typedef struct _AMMediaType
  33 {
  34     GUID       majortype;
  35     GUID       subtype;
  36     BOOL       bFixedSizeSamples;
  37     BOOL       bTemporalCompression;
  38     ULONG      lSampleSize;
  39     GUID       formattype;
  40     IUnknown * pUnk;
  41     ULONG      cbFormat;
  42     [size_is(cbFormat)] BYTE * pbFormat;
  43 } AM_MEDIA_TYPE;
  44
  45 typedef enum _PinDirection
  46 {
  47     PINDIR_INPUT,
  48     PINDIR_OUTPUT
  49 } PIN_DIRECTION;
  50
  51 #define MAX_PIN_NAME    128
  52 #define MAX_FILTER_NAME 128
  53 cpp_quote("#define MAX_PIN_NAME    128")
  54 cpp_quote("#define MAX_FILTER_NAME 128")
  55
  56 cpp_quote("#ifndef REFERENCE_TIME_DEFINED")
  57 cpp_quote("#define REFERENCE_TIME_DEFINED")
  58 typedef LONGLONG REFERENCE_TIME;
  59 cpp_quote("#endif")
  60
  61 cpp_quote("#ifndef REFTIME_DEFINED")
  62 cpp_quote("#define REFTIME_DEFINED")
  63 typedef DOUBLE REFTIME;
  64 cpp_quote("#endif")
  65
  66 typedef DWORD_PTR HSEMAPHORE;
  67 typedef DWORD_PTR HEVENT;
  68
  69 typedef struct _AllocatorProperties
  70 {
  71     long cBuffers;
  72     long cbBuffer;
  73     long cbAlign;
  74     long cbPrefix;
  75 } ALLOCATOR_PROPERTIES;
  76
  77 interface IAMovieSetup;
  78 interface IEnumFilters;
  79 interface IEnumMediaTypes;
  80 interface IEnumPins;
  81 interface IBaseFilter;
  82 interface IFilterGraph;
  83 interface IMediaFilter;
  84 interface IMediaSample;
  85 interface IMemAllocator;
  86 interface IMemAllocatorCallbackTemp;
  87 interface IMemAllocatorNotifyCallbackTemp;
  88 interface IMemInputPin;
  89 interface IPin;
  90 interface IReferenceClock;
  91
  92 [
  93 object,
  94 uuid(56a86891-0ad4-11ce-b03a-0020af0ba770),
  95 pointer_default(unique)
  96 ]
  97 interface IPin : IUnknown
  98 {
  99     typedef struct _PinInfo
 100     {
 101         IBaseFilter *pFilter;
 102         PIN_DIRECTION dir;
 103         WCHAR achName[MAX_PIN_NAME];
 104     } PIN_INFO;
 105
 106     HRESULT Connect(
 107         [in] IPin * pReceivePin,
 108         [in] const AM_MEDIA_TYPE * pmt);
 109
 110     HRESULT ReceiveConnection(
 111         [in] IPin * pConnector,
 112         [in] const AM_MEDIA_TYPE *pmt);
 113
 114     HRESULT Disconnect(void);
 115
 116     HRESULT ConnectedTo(
 117         [out] IPin **pPin);
 118
 119     HRESULT ConnectionMediaType(
 120         [out] AM_MEDIA_TYPE *pmt);
 121
 122     HRESULT QueryPinInfo(
 123         [out] PIN_INFO * pInfo);
 124
 125     HRESULT QueryDirection(
 126         [out] PIN_DIRECTION *pPinDir);
 127
 128     HRESULT QueryId(
 129         [out] LPWSTR * Id);
 130
 131     HRESULT QueryAccept(
 132         [in] const AM_MEDIA_TYPE *pmt);
 133
 134     HRESULT EnumMediaTypes(
 135         [out] IEnumMediaTypes **ppEnum);
 136
 137     HRESULT QueryInternalConnections(
 138         [out] IPin* *apPin,
 139         [in, out] ULONG *nPin);
 140
 141     HRESULT EndOfStream(void);
 142
 143     HRESULT BeginFlush(void);
 144
 145     HRESULT EndFlush(void);
 146     HRESULT NewSegment(
 147         [in] REFERENCE_TIME tStart,
 148         [in] REFERENCE_TIME tStop,
 149         [in] double dRate);
 150 }
 151
 152 typedef IPin *PPIN;
 153
 154 [
 155 object,
 156 uuid(56a86892-0ad4-11ce-b03a-0020af0ba770),
 157 pointer_default(unique)
 158 ]
 159 interface IEnumPins : IUnknown
 160 {
 161
 162     HRESULT Next(
 163         [in] ULONG cPins,
 164         [out, size_is(cPins)] IPin ** ppPins,
 165         [out] ULONG * pcFetched);
 166
 167     HRESULT Skip(
 168         [in] ULONG cPins);
 169
 170     HRESULT Reset(void);
 171
 172     HRESULT Clone(
 173         [out] IEnumPins **ppEnum);
 174 }
 175
 176 typedef IEnumPins *PENUMPINS;
 177
 178 [
 179 object,
 180 uuid(89c31040-846b-11ce-97d3-00aa0055595a),
 181 pointer_default(unique)
 182 ]
 183 interface IEnumMediaTypes : IUnknown
 184 {
 185     HRESULT Next(
 186         [in] ULONG cMediaTypes,
 187         [out, size_is(cMediaTypes)]
 188              AM_MEDIA_TYPE ** ppMediaTypes,
 189         [out] ULONG * pcFetched
 190     );
 191
 192     HRESULT Skip(
 193         [in] ULONG cMediaTypes);
 194
 195     HRESULT Reset(void);
 196
 197     HRESULT Clone(
 198         [out] IEnumMediaTypes **ppEnum
 199     );
 200 }
 201
 202 typedef IEnumMediaTypes *PENUMMEDIATYPES;
 203
 204 [
 205 object,
 206 uuid(56a8689f-0ad4-11ce-b03a-0020af0ba770),
 207 pointer_default(unique)
 208 ]
 209 interface IFilterGraph : IUnknown
 210 {
 211     HRESULT AddFilter(
 212         [in] IBaseFilter * pFilter,
 213         [in, string] LPCWSTR pName);
 214
 215     HRESULT RemoveFilter(
 216         [in] IBaseFilter * pFilter);
 217
 218     HRESULT EnumFilters(
 219         [out] IEnumFilters **ppEnum);
 220
 221     HRESULT FindFilterByName(
 222         [in, string] LPCWSTR pName,
 223         [out] IBaseFilter ** ppFilter);
 224
 225     HRESULT ConnectDirect(
 226         [in] IPin * ppinOut,
 227         [in] IPin * ppinIn,
 228         [in, unique] const AM_MEDIA_TYPE* pmt);
 229
 230     HRESULT Reconnect(
 231         [in] IPin * ppin);
 232
 233     HRESULT Disconnect(
 234         [in] IPin * ppin);
 235
 236     HRESULT SetDefaultSyncSource(void);
 237 }
 238
 239 typedef IFilterGraph *PFILTERGRAPH;
 240
 241 [
 242 object,
 243 uuid(56a86893-0ad4-11ce-b03a-0020af0ba770),
 244 pointer_default(unique)
 245 ]
 246 interface IEnumFilters : IUnknown
 247 {
 248     HRESULT Next(
 249         [in]  ULONG cFilters,
 250         [out] IBaseFilter ** ppFilter,
 251         [out] ULONG * pcFetched);
 252
 253
 254     HRESULT Skip(
 255         [in] ULONG cFilters);
 256
 257
 258     HRESULT Reset(void);
 259
 260
 261     HRESULT Clone(
 262         [out] IEnumFilters **ppEnum);
 263 }
 264
 265 typedef IEnumFilters *PENUMFILTERS;
 266
 267 [
 268 object,
 269 uuid(56a86899-0ad4-11ce-b03a-0020af0ba770),
 270 pointer_default(unique)
 271 ]
 272 interface IMediaFilter : IPersist
 273 {
 274     typedef enum _FilterState
 275     {
 276         State_Stopped,
 277         State_Paused,
 278         State_Running
 279     } FILTER_STATE;
 280
 281     HRESULT Stop(void);
 282     HRESULT Pause(void);
 283
 284     HRESULT Run(REFERENCE_TIME tStart);
 285
 286     HRESULT GetState(
 287         [in] DWORD dwMilliSecsTimeout,
 288         [out] FILTER_STATE *State);
 289
 290     HRESULT SetSyncSource(
 291         [in] IReferenceClock * pClock);
 292
 293     HRESULT GetSyncSource(
 294         [out] IReferenceClock ** pClock);
 295 }
 296
 297 typedef IMediaFilter *PMEDIAFILTER;
 298
 299 [
 300 object,
 301 uuid(56a86895-0ad4-11ce-b03a-0020af0ba770),
 302 pointer_default(unique)
 303 ]
 304 interface IBaseFilter : IMediaFilter
 305 {
 306     typedef struct _FilterInfo
 307     {
 308         WCHAR achName[MAX_FILTER_NAME];
 309         IFilterGraph * pGraph;
 310     } FILTER_INFO;
 311
 312     HRESULT EnumPins(
 313         [out] IEnumPins ** ppEnum);
 314
 315     HRESULT FindPin(
 316         [in, string] LPCWSTR Id,
 317         [out] IPin ** ppPin);
 318
 319     HRESULT QueryFilterInfo(
 320         [out] FILTER_INFO * pInfo);
 321
 322     HRESULT JoinFilterGraph(
 323         [in] IFilterGraph * pGraph,
 324         [in, string] LPCWSTR pName);
 325
 326     HRESULT QueryVendorInfo(
 327         [out, string] LPWSTR* pVendorInfo);
 328 }
 329
 330 typedef IBaseFilter *PFILTER;
 331
 332 [
 333 object,
 334 uuid(56a86897-0ad4-11ce-b03a-0020af0ba770),
 335 pointer_default(unique)
 336 ]
 337 interface IReferenceClock : IUnknown
 338 {
 339     HRESULT GetTime(
 340         [out] REFERENCE_TIME *pTime);
 341
 342     HRESULT AdviseTime(
 343         [in] REFERENCE_TIME baseTime,
 344         [in] REFERENCE_TIME streamTime,
 345         [in] HEVENT hEvent,
 346         [out] DWORD_PTR * pdwAdviseCookie);
 347
 348     HRESULT AdvisePeriodic(
 349         [in] REFERENCE_TIME startTime,
 350         [in] REFERENCE_TIME periodTime,
 351         [in] HSEMAPHORE hSemaphore,
 352         [out] DWORD_PTR * pdwAdviseCookie);
 353
 354     HRESULT Unadvise(
 355         [in] DWORD_PTR dwAdviseCookie);
 356 }
 357
 358 typedef IReferenceClock *PREFERENCECLOCK;
 359
 360 /*
 361 [
 362 object,
 363 uuid(36b73885-c2c8-11cf-8b46-00805f6cef60),
 364 pointer_default(unique)
 365 ]
 366 interface IReferenceClock2 : IReferenceClock
 367 {
 368 }
 369
 370 typedef IReferenceClock2 *PREFERENCECLOCK2;
 371
 372 */
 373
 374 [
 375 local,
 376 object,
 377 uuid(56a8689a-0ad4-11ce-b03a-0020af0ba770),
 378 pointer_default(unique)
 379 ]
 380 interface IMediaSample : IUnknown
 381 {
 382     HRESULT GetPointer([out] BYTE ** ppBuffer);
 383
 384     long GetSize(void);
 385
 386     HRESULT GetTime(
 387         [out] REFERENCE_TIME * pTimeStart,
 388         [out] REFERENCE_TIME * pTimeEnd);
 389
 390     HRESULT SetTime(
 391         [in] REFERENCE_TIME * pTimeStart,
 392         [in] REFERENCE_TIME * pTimeEnd);
 393
 394     HRESULT IsSyncPoint(void);
 395
 396     HRESULT SetSyncPoint(BOOL bIsSyncPoint);
 397
 398     HRESULT IsPreroll(void);
 399
 400     HRESULT SetPreroll(BOOL bIsPreroll);
 401
 402     LONG GetActualDataLength(void);
 403
 404     HRESULT SetActualDataLength(LONG length);
 405
 406     HRESULT GetMediaType(AM_MEDIA_TYPE **ppMediaType);
 407
 408     HRESULT SetMediaType(AM_MEDIA_TYPE *pMediaType);
 409
 410     HRESULT IsDiscontinuity(void);
 411
 412     HRESULT SetDiscontinuity(BOOL bDiscontinuity);
 413
 414     HRESULT GetMediaTime(
 415         [out] LONGLONG * pTimeStart,
 416         [out] LONGLONG * pTimeEnd);
 417
 418     HRESULT SetMediaTime(
 419         [in] LONGLONG * pTimeStart,
 420         [in] LONGLONG * pTimeEnd);
 421 }
 422
 423 typedef IMediaSample *PMEDIASAMPLE;
 424
 425 enum tagAM_SAMPLE_PROPERTY_FLAGS
 426 {
 427        AM_SAMPLE_SPLICEPOINT        = 0x01,
 428        AM_SAMPLE_PREROLL            = 0x02,
 429        AM_SAMPLE_DATADISCONTINUITY  = 0x04,
 430        AM_SAMPLE_TYPECHANGED        = 0x08,
 431        AM_SAMPLE_TIMEVALID          = 0x10,
 432        AM_SAMPLE_TIMEDISCONTINUITY  = 0x40,
 433        AM_SAMPLE_FLUSH_ON_PAUSE     = 0x80,
 434        AM_SAMPLE_STOPVALID          = 0x100,
 435        AM_SAMPLE_ENDOFSTREAM        = 0x200,
 436        AM_STREAM_MEDIA              = 0,
 437        AM_STREAM_CONTROL            = 1
 438 };
 439
 440 typedef struct tagAM_SAMPLE2_PROPERTIES
 441 {
 442     DWORD    cbData;
 443     DWORD    dwTypeSpecificFlags;
 444     DWORD    dwSampleFlags;
 445     LONG     lActual;
 446     REFERENCE_TIME tStart;
 447     REFERENCE_TIME tStop;
 448     DWORD    dwStreamId;
 449     AM_MEDIA_TYPE *pMediaType;
 450     BYTE    *pbBuffer;
 451     LONG     cbBuffer;
 452 } AM_SAMPLE2_PROPERTIES;
 453
 454 [
 455         local,
 456         object,
 457         uuid(36b73884-c2c8-11cf-8b46-00805f6cef60),
 458         pointer_default(unique)
 459 ]
 460 interface IMediaSample2 : IMediaSample
 461 {
 462     HRESULT GetProperties(
 463         [in] DWORD cbProperties,
 464         [out, size_is(cbProperties)] BYTE * pbProperties
 465     );
 466
 467     HRESULT SetProperties(
 468         [in] DWORD cbProperties,
 469         [in, size_is(cbProperties)] const BYTE * pbProperties
 470     );
 471 }
 472
 473 typedef IMediaSample2 *PMEDIASAMPLE2;
 474
 475 #define AM_GBF_PREVFRAMESKIPPED 1
 476 #define AM_GBF_NOTASYNCPOINT    2
 477 cpp_quote("#define AM_GBF_PREVFRAMESKIPPED 1")
 478 cpp_quote("#define AM_GBF_NOTASYNCPOINT 2")
 479
 480 cpp_quote("#define AM_GBF_NOWAIT 4")
 481 cpp_quote("#define AM_GBF_NODDSURFACELOCK 8")
 482
 483 [
 484 object,
 485 uuid(56a8689c-0ad4-11ce-b03a-0020af0ba770),
 486 pointer_default(unique)
 487 ]
 488 interface IMemAllocator : IUnknown
 489 {
 490     HRESULT SetProperties(
 491         [in] ALLOCATOR_PROPERTIES* pRequest,
 492         [out] ALLOCATOR_PROPERTIES* pActual);
 493
 494     HRESULT GetProperties(
 495         [out] ALLOCATOR_PROPERTIES* pProps);
 496
 497     HRESULT Commit(void);
 498
 499     HRESULT Decommit(void);
 500
 501     HRESULT GetBuffer(
 502         [out] IMediaSample **ppBuffer,
 503         [in] REFERENCE_TIME * pStartTime,
 504         [in] REFERENCE_TIME * pEndTime,
 505         [in] DWORD dwFlags);
 506
 507     HRESULT ReleaseBuffer(
 508         [in] IMediaSample *pBuffer);
 509 }
 510
 511 typedef IMemAllocator *PMEMALLOCATOR;
 512
 513 [
 514 object,
 515 uuid(379a0cf0-c1de-11d2-abf5-00a0c905f375),
 516 pointer_default(unique)
 517 ]
 518 interface IMemAllocatorCallbackTemp : IMemAllocator
 519 {
 520     HRESULT SetNotify(
 521         [in] IMemAllocatorNotifyCallbackTemp *pNotify);
 522
 523     HRESULT GetFreeCount(
 524         [out] LONG *plBuffersFree);
 525 }
 526
 527 [
 528 object,
 529 uuid(92980b30-c1de-11d2-abf5-00a0c905f375),
 530 pointer_default(unique)
 531 ]
 532 interface IMemAllocatorNotifyCallbackTemp : IUnknown
 533 {
 534     HRESULT NotifyRelease();
 535 }
 536
 537 [
 538 object,
 539 uuid(56a8689d-0ad4-11ce-b03a-0020af0ba770),
 540 pointer_default(unique)
 541 ]
 542 interface IMemInputPin : IUnknown
 543 {
 544     HRESULT GetAllocator(
 545         [out] IMemAllocator ** ppAllocator);
 546
 547     HRESULT NotifyAllocator(
 548         [in] IMemAllocator * pAllocator,
 549         [in] BOOL bReadOnly);
 550
 551     HRESULT GetAllocatorRequirements( [out] ALLOCATOR_PROPERTIES*pProps );
 552
 553     HRESULT Receive(
 554         [in] IMediaSample * pSample);
 555
 556     HRESULT ReceiveMultiple(
 557         [in, size_is(nSamples)] IMediaSample **pSamples,
 558         [in] long nSamples,
 559         [out] long *nSamplesProcessed);
 560
 561     HRESULT ReceiveCanBlock();
 562 }
 563
 564 typedef IMemInputPin *PMEMINPUTPIN;
 565
 566 [
 567 object,
 568 uuid(a3d8cec0-7e5a-11cf-bbc5-00805f6cef20),
 569 pointer_default(unique)
 570 ]
 571 interface IAMovieSetup : IUnknown
 572 {
 573     HRESULT Register( );
 574     HRESULT Unregister( );
 575 }
 576
 577 typedef IAMovieSetup *PAMOVIESETUP;
 578
 579 typedef enum AM_SEEKING_SeekingFlags
 580 {
 581     AM_SEEKING_NoPositioning            = 0x00,
 582     AM_SEEKING_AbsolutePositioning      = 0x01,
 583     AM_SEEKING_RelativePositioning      = 0x02,
 584     AM_SEEKING_IncrementalPositioning   = 0x03,
 585     AM_SEEKING_PositioningBitsMask      = 0x03,
 586     AM_SEEKING_SeekToKeyFrame           = 0x04,
 587     AM_SEEKING_ReturnTime               = 0x08,
 588     AM_SEEKING_Segment                  = 0x10,
 589     AM_SEEKING_NoFlush                  = 0x20
 590 } AM_SEEKING_SEEKING_FLAGS;
 591
 592 typedef enum AM_SEEKING_SeekingCapabilities
 593 {
 594     AM_SEEKING_CanSeekAbsolute     = 0x001,
 595     AM_SEEKING_CanSeekForwards     = 0x002,
 596     AM_SEEKING_CanSeekBackwards    = 0x004,
 597     AM_SEEKING_CanGetCurrentPos    = 0x008,
 598     AM_SEEKING_CanGetStopPos       = 0x010,
 599     AM_SEEKING_CanGetDuration      = 0x020,
 600     AM_SEEKING_CanPlayBackwards    = 0x040,
 601     AM_SEEKING_CanDoSegments       = 0x080,
 602     AM_SEEKING_Source              = 0x100
 603 } AM_SEEKING_SEEKING_CAPABILITIES;
 604
 605 [
 606 object,
 607 uuid(36b73880-c2c8-11cf-8b46-00805f6cef60),
 608 pointer_default(unique)
 609 ]
 610 interface IMediaSeeking : IUnknown
 611 {
 612     HRESULT GetCapabilities( [out] DWORD * pCapabilities );
 613
 614     HRESULT CheckCapabilities( [in,out] DWORD * pCapabilities );
 615
 616     HRESULT IsFormatSupported([in] const GUID * pFormat);
 617
 618     HRESULT QueryPreferredFormat([out] GUID * pFormat);
 619
 620     HRESULT GetTimeFormat([out] GUID *pFormat);
 621
 622     HRESULT IsUsingTimeFormat([in] const GUID * pFormat);
 623
 624     HRESULT SetTimeFormat([in] const GUID * pFormat);
 625
 626     HRESULT GetDuration([out] LONGLONG *pDuration);
 627
 628     HRESULT GetStopPosition([out] LONGLONG *pStop);
 629
 630     HRESULT GetCurrentPosition([out] LONGLONG *pCurrent);
 631
 632     HRESULT ConvertTimeFormat([out] LONGLONG * pTarget, [in] const GUID * pTargetFormat,
 633                               [in]  LONGLONG    Source, [in] const GUID * pSourceFormat );
 634
 635     HRESULT SetPositions(
 636         [in,out] LONGLONG * pCurrent,
 637         [in] DWORD dwCurrentFlags,
 638         [in,out] LONGLONG * pStop,
 639         [in] DWORD dwStopFlags);
 640
 641     HRESULT GetPositions(
 642         [out] LONGLONG * pCurrent,
 643         [out] LONGLONG * pStop);
 644
 645     HRESULT GetAvailable(
 646         [out] LONGLONG * pEarliest,
 647         [out] LONGLONG * pLatest);
 648
 649     HRESULT SetRate([in]  double dRate);
 650
 651     HRESULT GetRate([out] double * pdRate);
 652
 653     HRESULT GetPreroll([out] LONGLONG * pllPreroll);
 654 }
 655
 656 typedef IMediaSeeking *PMEDIASEEKING;
 657
 658 enum tagAM_MEDIAEVENT_FLAGS
 659 {
 660     AM_MEDIAEVENT_NONOTIFY = 0x01
 661 };
 662
 663 enum _AMSTREAMSELECTINFOFLAGS
 664 {
 665     AMSTREAMSELECTINFO_ENABLED      = 0x1,
 666     AMSTREAMSELECTINFO_EXCLUSIVE    = 0x2
 667 };
 668
 669 enum _AMSTREAMSELECTENABLEFLAGS
 670 {
 671     AMSTREAMSELECTENABLE_ENABLE     = 0x1,
 672     AMSTREAMSELECTENABLE_ENABLEALL  = 0x2
 673 };
 674
 675 [
 676 object,
 677 uuid(c1960960-17f5-11d1-abe1-00a0c905f375),
 678 pointer_default(unique)
 679 ]
 680 interface IAMStreamSelect : IUnknown
 681 {
 682     HRESULT Count(
 683         [out] DWORD *streams);
 684
 685     HRESULT Info(
 686         [in] long index,
 687         [out] AM_MEDIA_TYPE **media_type,
 688         [out] DWORD *flags,
 689         [out] LCID *lcid,
 690         [out] DWORD *group,
 691         [out] WCHAR **name,
 692         [out] IUnknown **object,
 693         [out] IUnknown **unknown);
 694
 695     HRESULT Enable(
 696         [in] long index,
 697         [in] DWORD flags);
 698 }
 699
 700 typedef IAMStreamSelect *PAMSTREAMSELECT;