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