home *** CD-ROM | disk | FTP | other *** search
/ Beginning Direct3D Game Programming / Direct3D.iso / directx / dxf / include / dshowidl / control.odl < prev    next >
Text File  |  2000-09-22  |  31KB  |  913 lines
  1. //==========================================================================;
  2. //
  3. //  THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY
  4. //  KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
  5. //  IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR
  6. //  PURPOSE.
  7. //
  8. //  Copyright (c) 1992 - 1999  Microsoft Corporation.  All Rights Reserved.
  9. //
  10. //--------------------------------------------------------------------------;
  11.  
  12. // Neutral/English language type library for basic Quartz control interfaces
  13.  
  14. // the quartz type library defines the basic control interfaces
  15. [
  16.     uuid(56a868b0-0ad4-11ce-b03a-0020af0ba770),
  17.     helpstring("ActiveMovie control type library"),
  18.     lcid(0x0000),
  19.     version(1.0)
  20. ]
  21. library QuartzTypeLib
  22. {
  23.     importlib("STDOLE32.TLB");
  24.  
  25.     // types are restricted to be automation-compatible
  26.     typedef double REFTIME;             // ReferenceTime
  27.     typedef LONG_PTR OAEVENT;         // should be a HANDLE
  28.     typedef LONG_PTR OAHWND;          // should be an hwnd
  29.  
  30.     // from strmif.idl
  31.     typedef long OAFilterState;
  32.  
  33.     // collection interface - represents a collection of IUnknowns
  34.     // this is used below to collect filter-info objects, registry-filters
  35.     // pin-info objects and wrapped media type objects
  36.     [
  37.         uuid(56a868b9-0ad4-11ce-b03a-0020af0ba770),
  38.         helpstring("Collection"),
  39.         odl,
  40.         oleautomation,
  41.         dual
  42.     ]
  43.     interface IAMCollection : IDispatch
  44.     {
  45.         // number of items in collection
  46.         [propget]
  47.         HRESULT Count(
  48.                     [out, retval] LONG* plCount);
  49.  
  50.         // return IUnknown for contained item by index
  51.         HRESULT Item(
  52.                     [in]  long lItem,
  53.                     [out] IUnknown** ppUnk);
  54.  
  55.         // return IUnknown for an object that implements IEnumVARIANT on
  56.         // this collection
  57.         [propget]
  58.         HRESULT _NewEnum(
  59.                     [out, retval] IUnknown** ppUnk);
  60.     }
  61.  
  62.  
  63.     // core control providing state control
  64.     [
  65.         uuid(56a868b1-0ad4-11ce-b03a-0020af0ba770),
  66.         helpstring("IMediaControl interface"),
  67.         odl,
  68.         oleautomation,
  69.         dual
  70.     ]
  71.     interface IMediaControl : IDispatch
  72.     {
  73.         // methods
  74.         HRESULT Run();
  75.         HRESULT Pause();
  76.         HRESULT Stop();
  77.  
  78.         //returns the state. same semantics as IMediaFilter::GetState
  79.  
  80.         HRESULT GetState(
  81.                     [in] LONG msTimeout,
  82.                     [out] OAFilterState* pfs);
  83.  
  84.         // adds and connects filters needed to play the specified file
  85.         // (same as IFilterGraph::RenderFile)
  86.         HRESULT RenderFile(
  87.                     [in] BSTR strFilename);
  88.  
  89.         // adds to the graph the source filter that can read this file,
  90.         // and returns an IFilterInfo object for it (actually returns
  91.         // an IDispatch for the IFilterInfo object).
  92.         HRESULT AddSourceFilter(
  93.                     [in] BSTR strFilename,
  94.                     [out] IDispatch**ppUnk);
  95.  
  96.         // get a collection of IFilterInfo objects representing the
  97.         // filters in the graph (returns IDispatch for an object
  98.         // that supports IAMCollection
  99.         [propget]
  100.         HRESULT FilterCollection(
  101.                         [out, retval] IDispatch** ppUnk);
  102.  
  103.         // get a collection of IRegFilter objects representing the
  104.         // filters available in the registry
  105.         [propget]
  106.         HRESULT RegFilterCollection(
  107.                         [out, retval] IDispatch** ppUnk);
  108.  
  109.         HRESULT StopWhenReady();
  110.     }
  111.  
  112.  
  113.     // provides an event notification scheme passing events
  114.     // asynchronously to applications. See also IMediaEventSink in
  115.     // strmif.idl and sdk\h\evcodes.h.
  116.     //
  117.     // this interface behaves as if events are held on a queue. A call to
  118.     // IMediaEventSink::Notify will place an event on this queue. Calling
  119.     // GetEvent removes the first item off the queue and returns it. Items are
  120.     // returned in the order they were queued (there is no priority scheme).
  121.     // The event handle is in a signalled state iff the queue is non-empty.
  122.     //
  123.     // Apps that issue multiple Run calls without always picking up the
  124.     // completion events are advised to call GetEvent or WaitForCompletion
  125.     // (with a 0 timeout) repeatedly to remove all events from the queue
  126.     // when in stopped or paused state before each Run method.
  127.     //
  128.     // Parameters to events are actually LONG, IUnknown* or BSTR. You need to
  129.     // look at evcode.h for details of parameters to a specific event code.
  130.     // In order to correctly free resources, always call FreeEventParams
  131.     // after receiving an event.
  132.     //
  133.  
  134.     [
  135.         uuid(56a868b6-0ad4-11ce-b03a-0020af0ba770),
  136.         helpstring("IMediaEvent interface"),
  137.         odl,
  138.         oleautomation,
  139.         dual
  140.     ]
  141.     interface IMediaEvent : IDispatch
  142.     {
  143.         // get back the event handle. This is manual-reset
  144.         // (don't - it's reset by the event mechanism) and remains set
  145.         // when events are queued, and reset when the queue is empty.
  146.         HRESULT GetEventHandle(
  147.                         [out] OAEVENT * hEvent);
  148.  
  149.         // remove the next event notification from the head of the queue and
  150.         // return it. Waits up to msTimeout millisecs if there are no events.
  151.         // if a timeout occurs without any events, this method will return
  152.         // E_ABORT, and the value of the event code and other parameters
  153.         // is undefined.
  154.         //
  155.         // If this call returns successfully the caller MUST call
  156.         // FreeEventParams(lEventCode, lParam1, lParam2) to release
  157.         // resources held inside the event arguments
  158.         //
  159.         HRESULT GetEvent(
  160.                         [out] long * lEventCode,
  161.                         [out] LONG_PTR * lParam1,
  162.                         [out] LONG_PTR * lParam2,
  163.                         [in] long msTimeout
  164.                         );
  165.  
  166.         // Calls GetEvent repeatedly discarding events until it finds a
  167.         // completion event (EC_COMPLETE, EC_ERRORABORT, or EC_USERABORT).
  168.         // The completion event is removed from the queue and returned
  169.         // in pEvCode. Note that the object is still in running mode until
  170.         // a Pause or Stop call is made.
  171.         // If the timeout occurs, *pEvCode will be 0 and E_ABORT will be
  172.         // returned.
  173.         HRESULT WaitForCompletion(
  174.                         [in] long msTimeout,
  175.                         [out] long * pEvCode);
  176.  
  177.         // cancels any system handling of the specified event code
  178.         // and ensures that the events are passed straight to the application
  179.         // (via GetEvent) and not handled. A good example of this is
  180.         // EC_REPAINT: default handling for this ensures the painting of the
  181.         // window and does not get posted to the app.
  182.         HRESULT CancelDefaultHandling(
  183.                         [in] long lEvCode);
  184.  
  185.         // restore the normal system default handling that may have been
  186.         // cancelled by CancelDefaultHandling().
  187.         HRESULT RestoreDefaultHandling( [in] long lEvCode);
  188.  
  189.     // Free any resources associated with the parameters to an event.
  190.         // Event parameters may be LONGs, IUnknown* or BSTR. No action
  191.         // is taken with LONGs. IUnknown are passed addrefed and need a
  192.         // Release call. BSTR are allocated by the task allocator and will be
  193.         // freed by calling the task allocator.
  194.         HRESULT FreeEventParams(
  195.                 [in] long lEvCode,
  196.                         [in] LONG_PTR lParam1,
  197.                         [in] LONG_PTR lParam2
  198.                         );
  199.     }
  200.  
  201.     [
  202.         uuid(56a868c0-0ad4-11ce-b03a-0020af0ba770),
  203.         helpstring("IMediaEventEx interface"),
  204.         odl
  205.     ]
  206.     interface IMediaEventEx : IMediaEvent
  207.     {
  208.  
  209.         // Register a window to send messages to when events occur
  210.         // Parameters:
  211.         //
  212.         //    hwnd - handle of window to notify -
  213.         //           pass NULL to stop notification
  214.         //    lMsg - Message id to pass messages with
  215.     //    lInstanceData - will come back in lParam
  216.         //
  217.         // The event information must still be retrived by a call
  218.         // to GetEvent when the window message is received.
  219.         //
  220.         // Multiple events may be notified with one window message.
  221.         //
  222.         HRESULT SetNotifyWindow(
  223.                         [in] OAHWND hwnd,
  224.                         [in] long lMsg,
  225.             [in] LONG_PTR lInstanceData
  226.                         );
  227.  
  228.         // Turn events notification on or off
  229.         // lNoNotify = 0x00 event notification is ON
  230.         // lNoNotify = 0x01 event notification is OFF.  The
  231.         // handle returned by GetEventHandle will be signalled at
  232.         // end of stream
  233.         HRESULT SetNotifyFlags(
  234.                         [in] long lNoNotifyFlags
  235.                          );
  236.         HRESULT GetNotifyFlags(
  237.                         [out] long *lplNoNotifyFlags
  238.                          );
  239.     }
  240.  
  241.  
  242.  
  243.  
  244.     // seek/cueing for positional media
  245.     [
  246.         uuid(56a868b2-0ad4-11ce-b03a-0020af0ba770),
  247.         helpstring("IMediaPosition interface"),
  248.         odl,
  249.         oleautomation,
  250.         dual
  251.     ]
  252.     interface IMediaPosition : IDispatch
  253.     {
  254.         // properties
  255.  
  256.         [propget]
  257.         HRESULT Duration(
  258.                     [out, retval] REFTIME* plength);
  259.  
  260.         [propput]
  261.         HRESULT CurrentPosition(
  262.                     [in] REFTIME llTime);
  263.  
  264.         [propget]
  265.         HRESULT CurrentPosition(
  266.                     [out, retval] REFTIME* pllTime);
  267.  
  268.         [propget]
  269.         HRESULT StopTime(
  270.                     [out, retval] REFTIME* pllTime);
  271.         [propput]
  272.         HRESULT StopTime(
  273.                     [in] REFTIME llTime);
  274.  
  275.         [propget]
  276.         HRESULT PrerollTime(
  277.                     [out, retval] REFTIME* pllTime);
  278.         [propput]
  279.         HRESULT PrerollTime(
  280.                     [in] REFTIME llTime);
  281.  
  282.         [propput]
  283.         HRESULT Rate(
  284.                     [in] double dRate);
  285.         [propget]
  286.         HRESULT Rate(
  287.                     [out, retval] double * pdRate);
  288.  
  289.         HRESULT CanSeekForward([out, retval] LONG *pCanSeekForward);
  290.         HRESULT CanSeekBackward([out, retval] LONG *pCanSeekBackward);
  291.     }
  292.  
  293.     // basic audio-related functionality
  294.     [
  295.         uuid(56a868b3-0ad4-11ce-b03a-0020af0ba770),
  296.         helpstring("IBasicAudio interface"),
  297.         odl,
  298.         oleautomation,
  299.         dual
  300.     ]
  301.     interface IBasicAudio : IDispatch
  302.     {
  303.         // properties
  304.  
  305.         [propput]
  306.         HRESULT Volume(
  307.                     [in] long lVolume);
  308.         [propget]
  309.         HRESULT Volume(
  310.                     [out, retval] long * plVolume);
  311.  
  312.         [propput]
  313.         HRESULT Balance(
  314.                     [in] long lBalance);
  315.         [propget]
  316.         HRESULT Balance(
  317.                     [out, retval] long * plBalance);
  318.     }
  319.  
  320.     // basic window-related functionality
  321.     [
  322.         uuid(56a868b4-0ad4-11ce-b03a-0020af0ba770),
  323.         helpstring("IVideoWindow interface"),
  324.         odl,
  325.         oleautomation,
  326.         dual
  327.     ]
  328.     interface IVideoWindow : IDispatch
  329.     {
  330.         // properties
  331.  
  332.         // set and get the window title caption
  333.  
  334.         [propput]
  335.         HRESULT Caption([in] BSTR strCaption);
  336.         [propget]
  337.         HRESULT Caption([out, retval] BSTR *strCaption);
  338.  
  339.         // change the window styles (as per Win32)
  340.  
  341.         [propput]
  342.         HRESULT WindowStyle([in] long WindowStyle);
  343.         [propget]
  344.         HRESULT WindowStyle([out, retval] long *WindowStyle);
  345.  
  346.         // change the extended window styles (as per Win32)
  347.  
  348.         [propput]
  349.         HRESULT WindowStyleEx([in] long WindowStyleEx);
  350.         [propget]
  351.         HRESULT WindowStyleEx([out, retval] long *WindowStyleEx);
  352.  
  353.         [propput]
  354.         HRESULT AutoShow([in] long AutoShow);
  355.         [propget]
  356.         HRESULT AutoShow([out, retval] long *AutoShow);
  357.  
  358.         // change the window state (as per Win32)
  359.  
  360.         [propput]
  361.         HRESULT WindowState([in] long WindowState);
  362.         [propget]
  363.         HRESULT WindowState([out, retval] long *WindowState);
  364.  
  365.         // realise the palette in the background
  366.  
  367.         [propput]
  368.         HRESULT BackgroundPalette([in] long BackgroundPalette);
  369.         [propget]
  370.         HRESULT BackgroundPalette([out, retval] long *pBackgroundPalette);
  371.  
  372.         // affect the visibility of the window
  373.  
  374.         [propput]
  375.         HRESULT Visible([in] long Visible);
  376.         [propget]
  377.         HRESULT Visible([out, retval] long *pVisible);
  378.  
  379.         // change the desktop position of the video window
  380.  
  381.         [propput]
  382.         HRESULT Left([in] long Left);
  383.         [propget]
  384.         HRESULT Left([out, retval] long *pLeft);
  385.  
  386.         [propput]
  387.         HRESULT Width([in] long Width);
  388.         [propget]
  389.         HRESULT Width([out, retval] long *pWidth);
  390.  
  391.         [propput]
  392.         HRESULT Top([in] long Top);
  393.         [propget]
  394.         HRESULT Top([out, retval] long *pTop);
  395.  
  396.         [propput]
  397.         HRESULT Height([in] long Height);
  398.         [propget]
  399.         HRESULT Height([out, retval] long *pHeight);
  400.  
  401.         // change the owning window of the video
  402.  
  403.         [propput]
  404.         HRESULT Owner([in] OAHWND Owner);
  405.         [propget]
  406.         HRESULT Owner([out, retval] OAHWND *Owner);
  407.  
  408.         // change the window to receive posted messages
  409.  
  410.         [propput]
  411.         HRESULT MessageDrain([in] OAHWND Drain);
  412.         [propget]
  413.         HRESULT MessageDrain([out, retval] OAHWND *Drain);
  414.  
  415.         [propget]
  416.         HRESULT BorderColor([out, retval] long *Color);
  417.  
  418.         [propput]
  419.         HRESULT BorderColor([in] long Color);
  420.  
  421.         [propget]
  422.         HRESULT FullScreenMode([out, retval] long *FullScreenMode);
  423.  
  424.         [propput]
  425.         HRESULT FullScreenMode([in] long FullScreenMode);
  426.  
  427.         // methods
  428.  
  429.         // ask the renderer to grab it's window the foreground
  430.         // and optionally also give the window the input focus
  431.         HRESULT SetWindowForeground([in] long Focus);
  432.  
  433.         // owners should pass WM_PALETTECHANGED and WM_SYSCOLORCHANGE
  434.         // messages on the filter graph so they can be distributed
  435.         // otherwise child renderers never see these messages go by
  436.  
  437.         HRESULT NotifyOwnerMessage([in] OAHWND hwnd,
  438.                                    [in] long uMsg,
  439.                                    [in] LONG_PTR wParam,
  440.                                    [in] LONG_PTR lParam
  441.                                    );
  442.  
  443.         // get and set the window position on the desktop
  444.  
  445.         HRESULT SetWindowPosition([in] long Left,
  446.                                   [in] long Top,
  447.                                   [in] long Width,
  448.                                   [in] long Height);
  449.  
  450.         HRESULT GetWindowPosition([out] long *pLeft,
  451.                                   [out] long *pTop,
  452.                                   [out] long *pWidth,
  453.                                   [out] long *pHeight);
  454.  
  455.         // get the ideal sizes for the video image playback (client) area
  456.  
  457.         HRESULT GetMinIdealImageSize([out] long *pWidth,[out] long *pHeight);
  458.         HRESULT GetMaxIdealImageSize([out] long *pWidth,[out] long *pHeight);
  459.  
  460.         // get the restored window size when we're maximised or iconic
  461.  
  462.         HRESULT GetRestorePosition([out] long *pLeft,
  463.                                    [out] long *pTop,
  464.                                    [out] long *pWidth,
  465.                                    [out] long *pHeight);
  466.  
  467.     // show and hide cursors useful when fullscreen
  468.     HRESULT HideCursor([in] long HideCursor);
  469.         HRESULT IsCursorHidden([out] long *CursorHidden);
  470.     }
  471.  
  472.     // basic video-related functionality
  473.     [
  474.         uuid(56a868b5-0ad4-11ce-b03a-0020af0ba770),
  475.         helpstring("IBasicVideo interface"),
  476.         odl,
  477.         oleautomation,
  478.         dual
  479.     ]
  480.     interface IBasicVideo : IDispatch
  481.     {
  482.         // properties
  483.  
  484.         // Video specific (approximate) bit and frame rates
  485.  
  486.         [propget]
  487.         HRESULT AvgTimePerFrame([out, retval] REFTIME *pAvgTimePerFrame);
  488.  
  489.         [propget]
  490.         HRESULT BitRate([out, retval] long *pBitRate);
  491.  
  492.         [propget]
  493.         HRESULT BitErrorRate([out, retval] long *pBitErrorRate);
  494.  
  495.         // read the native video size
  496.  
  497.         [propget]
  498.         HRESULT VideoWidth([out, retval] long *pVideoWidth);
  499.  
  500.         [propget]
  501.         HRESULT VideoHeight([out, retval] long *pVideoHeight);
  502.  
  503.         // change the source rectangle for the video
  504.  
  505.         [propput]
  506.         HRESULT SourceLeft([in] long SourceLeft);
  507.         [propget]
  508.         HRESULT SourceLeft([out, retval] long *pSourceLeft);
  509.  
  510.         [propput]
  511.         HRESULT SourceWidth([in] long SourceWidth);
  512.         [propget]
  513.         HRESULT SourceWidth([out, retval] long *pSourceWidth);
  514.  
  515.         [propput]
  516.         HRESULT SourceTop([in] long SourceTop);
  517.         [propget]
  518.         HRESULT SourceTop([out, retval] long *pSourceTop);
  519.  
  520.         [propput]
  521.         HRESULT SourceHeight([in] long SourceHeight);
  522.         [propget]
  523.         HRESULT SourceHeight([out, retval] long *pSourceHeight);
  524.  
  525.         // change the destination rectangle for the video
  526.  
  527.         [propput]
  528.         HRESULT DestinationLeft([in] long DestinationLeft);
  529.         [propget]
  530.         HRESULT DestinationLeft([out, retval] long *pDestinationLeft);
  531.  
  532.         [propput]
  533.         HRESULT DestinationWidth([in] long DestinationWidth);
  534.         [propget]
  535.         HRESULT DestinationWidth([out, retval] long *pDestinationWidth);
  536.  
  537.         [propput]
  538.         HRESULT DestinationTop([in] long DestinationTop);
  539.         [propget]
  540.         HRESULT DestinationTop([out, retval] long *pDestinationTop);
  541.  
  542.         [propput]
  543.         HRESULT DestinationHeight([in] long DestinationHeight);
  544.         [propget]
  545.         HRESULT DestinationHeight([out, retval] long *pDestinationHeight);
  546.  
  547.         // methods
  548.  
  549.         // get and set the source rectangle position
  550.  
  551.         HRESULT SetSourcePosition([in] long Left,
  552.                                   [in] long Top,
  553.                                   [in] long Width,
  554.                                   [in] long Height);
  555.  
  556.         HRESULT GetSourcePosition([out] long *pLeft,
  557.                                   [out] long *pTop,
  558.                                   [out] long *pWidth,
  559.                                   [out] long *pHeight);
  560.  
  561.         HRESULT SetDefaultSourcePosition();
  562.  
  563.         // get and set the destination rectangle position
  564.  
  565.         HRESULT SetDestinationPosition([in] long Left,
  566.                                        [in] long Top,
  567.                                        [in] long Width,
  568.                                        [in] long Height);
  569.  
  570.         HRESULT GetDestinationPosition([out] long *pLeft,
  571.                                        [out] long *pTop,
  572.                                        [out] long *pWidth,
  573.                                        [out] long *pHeight);
  574.  
  575.         HRESULT SetDefaultDestinationPosition();
  576.  
  577.         // get the native video dimensions
  578.  
  579.         HRESULT GetVideoSize([out] long *pWidth,[out] long *pHeight);
  580.  
  581.         // get all or some of the current video palette
  582.  
  583.         HRESULT GetVideoPaletteEntries([in] long StartIndex,
  584.                                        [in] long Entries,
  585.                                        [out] long *pRetrieved,
  586.                                        [out] long *pPalette);
  587.  
  588.         HRESULT GetCurrentImage([in,out] long *pBufferSize,
  589.                                 [out] long *pDIBImage);
  590.  
  591.         // are we using a default source or destination
  592.  
  593.         HRESULT IsUsingDefaultSource();
  594.         HRESULT IsUsingDefaultDestination();
  595.     }
  596.  
  597.     // interface extension to IBasicVideo to return preferred aspect ratio
  598.     [
  599.         uuid(329bb360-f6ea-11d1-9038-00a0c9697298),
  600.         helpstring("IBasicVideo2"),
  601.         odl
  602.     ]
  603.     interface IBasicVideo2 : IBasicVideo
  604.     {
  605.         //  This may not match the native video dimensions because of
  606.         //  non-square pixels or whatever.
  607.         //  The video may not always be displayed in the preferred
  608.         //  aspect ratio for performance reasons
  609.  
  610.         HRESULT GetPreferredAspectRatio([out] long *plAspectX,
  611.                                         [out] long *plAspectY);
  612.     }
  613.  
  614.     // interface returned to a command that has been queued via IQueueCommand
  615.     [
  616.         uuid(56a868b8-0ad4-11ce-b03a-0020af0ba770),
  617.         helpstring("IDeferredCommand"),
  618.         odl
  619.     ]
  620.     interface IDeferredCommand : IUnknown
  621.     {
  622.         HRESULT Cancel();
  623.         HRESULT Confidence(
  624.                     [out] LONG* pConfidence);
  625.         HRESULT Postpone(
  626.                     [in] REFTIME newtime);
  627.         // return value is S_OK if completed. phrResult is set to the
  628.         // result of the deferred command.
  629.         HRESULT GetHResult(
  630.                     [out] HRESULT* phrResult);
  631.     };
  632.  
  633.     // queue an IDispatch-based command for execution at a specified time
  634.     [
  635.         uuid(56a868b7-0ad4-11ce-b03a-0020af0ba770),
  636.         helpstring("IQueueCommand"),
  637.         odl
  638.     ]
  639.     interface IQueueCommand  : IUnknown
  640.     {
  641.         HRESULT InvokeAtStreamTime(
  642.                     [out] IDeferredCommand** pCmd,
  643.                     [in] REFTIME time,            // at this streamtime
  644.                     [in] GUID* iid,                   // call this interface
  645.                     [in] long dispidMethod,         // ..and this method
  646.                     [in] short wFlags,              // method/property
  647.                     [in] long cArgs,                // count of args
  648.                     [in] VARIANT* pDispParams,      // actual args
  649.                     [in, out] VARIANT* pvarResult,  // return value
  650.                     [out] short* puArgErr           // which arg in error
  651.         );
  652.  
  653.         HRESULT InvokeAtPresentationTime(
  654.                     [out] IDeferredCommand** pCmd,
  655.                     [in] REFTIME time,            // at this presentation time
  656.                     [in] GUID* iid,                   // call this interface
  657.                     [in] long dispidMethod,         // ..and this method
  658.                     [in] short wFlags,              // method/property
  659.                     [in] long cArgs,                // count of args
  660.                     [in] VARIANT* pDispParams,      // actual args
  661.                     [in, out] VARIANT* pvarResult,  // return value
  662.                     [out] short* puArgErr           // which arg in error
  663.         );
  664.  
  665.     };
  666.  
  667.  
  668.  
  669.     // the filgraph object (CLSID_Filgraph)
  670.     [
  671.         uuid(e436ebb3-524f-11ce-9f53-0020af0ba770),
  672.         helpstring("Filtergraph type info")
  673.     ]
  674.     coclass FilgraphManager
  675.     {
  676.         [default] interface IMediaControl;
  677.         interface IMediaEvent;
  678.         interface IMediaPosition;
  679.         interface IBasicAudio;
  680.         interface IBasicVideo;
  681.         interface IVideoWindow;
  682.  
  683.     };
  684.  
  685.  
  686.     // represents a filter (you can't QI for IBaseFilter from this object)
  687.     [
  688.         uuid(56a868ba-0ad4-11ce-b03a-0020af0ba770),
  689.         helpstring("FilterInfo"),
  690.         odl,
  691.         oleautomation,
  692.         dual
  693.     ]
  694.     interface IFilterInfo : IDispatch
  695.     {
  696.         // find a pin given an id - returns an object supporting
  697.         // IPinInfo
  698.         HRESULT FindPin(
  699.                     [in] BSTR strPinID,
  700.                     [out] IDispatch** ppUnk);
  701.  
  702.         // filter name
  703.         [propget]
  704.         HRESULT Name(
  705.                     [out, retval] BSTR* strName);
  706.  
  707.         // Vendor info string
  708.         [propget]
  709.         HRESULT VendorInfo(
  710.                     [out, retval] BSTR* strVendorInfo);
  711.  
  712.         // returns the actual filter object (supports IBaseFilter)
  713.         [propget]
  714.         HRESULT Filter(
  715.                     [out, retval] IUnknown **ppUnk);
  716.  
  717.         // returns an IAMCollection object containing the PinInfo objects
  718.         // for this filter
  719.         [propget]
  720.         HRESULT Pins(
  721.                     [out, retval] IDispatch ** ppUnk);
  722.  
  723.         // returns -1 if true or 0 if false (OATRUE/FALSE)
  724.         [propget]
  725.         HRESULT IsFileSource(
  726.                     [out, retval] LONG * pbIsSource);
  727.  
  728.         [propget]
  729.         HRESULT Filename(
  730.                     [out, retval] BSTR* pstrFilename);
  731.  
  732.         [propput]
  733.         HRESULT Filename(
  734.                     [in] BSTR strFilename);
  735.     }
  736.  
  737.     [
  738.         uuid(56a868bb-0ad4-11ce-b03a-0020af0ba770),
  739.         helpstring("Registry Filter Info"),
  740.         odl,
  741.         oleautomation,
  742.         dual
  743.     ]
  744.     interface IRegFilterInfo : IDispatch
  745.     {
  746.         // get the name of this filter
  747.         [propget]
  748.         HRESULT Name(
  749.                     [out, retval] BSTR* strName);
  750.  
  751.  
  752.         // make an instance of this filter, add it to the graph and
  753.         // return an IFilterInfo for it.
  754.         HRESULT Filter(
  755.                     [out] IDispatch** ppUnk);
  756.     }
  757.  
  758.     // wrapper for a media type
  759.     [
  760.         uuid(56a868bc-0ad4-11ce-b03a-0020af0ba770),
  761.         helpstring("Media Type"),
  762.         odl,
  763.         oleautomation,
  764.         dual
  765.     ]
  766.     interface IMediaTypeInfo : IDispatch
  767.     {
  768.         // get the major type GUID as a string
  769.         [propget]
  770.         HRESULT Type(
  771.                     [out, retval] BSTR* strType);
  772.  
  773.         // get the subtype GUID as a string
  774.         [propget]
  775.         HRESULT Subtype(
  776.                     [out, retval] BSTR* strType);
  777.     }
  778.  
  779.     [
  780.         uuid(56a868bd-0ad4-11ce-b03a-0020af0ba770),
  781.         helpstring("Pin Info"),
  782.         odl,
  783.         oleautomation,
  784.         dual
  785.     ]
  786.     interface IPinInfo : IDispatch
  787.     {
  788.         // get the pin object (IUnknown for an object that
  789.         // supports IPin
  790.         [propget]
  791.         HRESULT Pin(
  792.                     [out, retval] IUnknown** ppUnk);
  793.  
  794.         // get the PinInfo object for the pin we are connected to
  795.         [propget]
  796.         HRESULT ConnectedTo(
  797.                     [out, retval] IDispatch** ppUnk);
  798.  
  799.         // get the media type on this connection - returns an
  800.         // object supporting IMediaTypeInfo
  801.         [propget]
  802.         HRESULT ConnectionMediaType(
  803.                     [out, retval] IDispatch** ppUnk);
  804.  
  805.  
  806.         // return the FilterInfo object for the filter this pin
  807.         // is part of
  808.         [propget]
  809.         HRESULT FilterInfo(
  810.                     [out, retval] IDispatch** ppUnk);
  811.  
  812.         // get the name of this pin
  813.         [propget]
  814.         HRESULT Name(
  815.                     [out, retval] BSTR* ppUnk);
  816.  
  817.         // pin direction
  818.         [propget]
  819.         HRESULT Direction(
  820.                     [out, retval] LONG *ppDirection);
  821.  
  822.         // PinID - can pass to IFilterInfo::FindPin
  823.         [propget]
  824.         HRESULT PinID(
  825.                     [out, retval] BSTR* strPinID);
  826.  
  827.         // collection of preferred media types (IAMCollection)
  828.         [propget]
  829.         HRESULT MediaTypes(
  830.                     [out, retval] IDispatch** ppUnk);
  831.  
  832.         // Connect to the following pin, using other transform
  833.         // filters as necessary. pPin can support either IPin or IPinInfo
  834.         HRESULT Connect(
  835.                     [in] IUnknown* pPin);
  836.  
  837.         // Connect directly to the following pin, not using any intermediate
  838.         // filters
  839.         HRESULT ConnectDirect(
  840.                     [in] IUnknown* pPin);
  841.  
  842.         // Connect directly to the following pin, using the specified
  843.         // media type only. pPin is an object that must support either
  844.         // IPin or IPinInfo, and pMediaType must support IMediaTypeInfo.
  845.         HRESULT ConnectWithType(
  846.                     [in] IUnknown * pPin,
  847.                     [in] IDispatch * pMediaType);
  848.  
  849.         // disconnect this pin and the corresponding connected pin from
  850.         // each other. (Calls IPin::Disconnect on both pins).
  851.         HRESULT Disconnect(void);
  852.  
  853.         // render this pin using any necessary transform and rendering filters
  854.         HRESULT Render(void);
  855.     }
  856.  
  857.     //--------------------------------------------------------------------
  858.     //
  859.     //  IAMStats - statistics
  860.     //
  861.     //  Note that the calls using an index are likely to be much faster
  862.     //--------------------------------------------------------------------
  863.  
  864.     [
  865.             uuid(bc9bcf80-dcd2-11d2-abf6-00a0c905f375),
  866.             helpstring("Statistics"),
  867.             odl,
  868.             oleautomation,
  869.             dual
  870.     ]
  871.     interface IAMStats : IDispatch {
  872.         //  Reset all stats
  873.         HRESULT Reset();
  874.  
  875.         //  Get number of stats collected
  876.         [propget]
  877.         HRESULT Count(
  878.                     [out, retval] LONG* plCount);
  879.  
  880.         //  Pull out a specific value by position
  881.         HRESULT GetValueByIndex([in] long lIndex,
  882.                                 [out] BSTR *szName,
  883.                                 [out] long *lCount,
  884.                                 [out] double *dLast,
  885.                                 [out] double *dAverage,
  886.                                 [out] double *dStdDev,
  887.                                 [out] double *dMin,
  888.                                 [out] double *dMax);
  889.  
  890.         //  Pull out a specific value by name
  891.         HRESULT GetValueByName([in] BSTR szName,
  892.                                [out] long *lIndex,
  893.                                [out] long *lCount,
  894.                                 [out] double *dLast,
  895.                                [out] double *dAverage,
  896.                                [out] double *dStdDev,
  897.                                [out] double *dMin,
  898.                                [out] double *dMax);
  899.  
  900.  
  901.         //  The calls below are for generators of statistics
  902.  
  903.         //  Return the index for a string - optinally create
  904.         HRESULT GetIndex([in] BSTR szName,
  905.                          [in] long lCreate,
  906.                          [out] long *plIndex);
  907.  
  908.         //  Add a new value
  909.         HRESULT AddValue([in] long lIndex,
  910.                          [in] double dValue);
  911.     }
  912. };
  913.