segment.idl

C语言编程的不错工具

    eventidChangeCurrentAudioStream,
    eventidChangeCurrentSubpictureStream,
    eventidChangeCurrentAngle,
    eventidPlayAtTimeInTitle,
    eventidPlayAtTime,
    eventidPlayChapterInTitle,
    eventidPlayChapter,
    eventidReplayChapter,
    eventidPlayNextChapter,
    eventidStop,
    eventidReturnFromSubmenu,
    eventidPlayTitle,
    eventidPlayPrevChapter,
    eventidChangeKaraokePresMode,
    eventidChangeVideoPresMode,
    eventidOverlayUnavailable,
    LastReservedDeviceEvent=0x3fff
} SegEventidList;

typedef enum {
    FrameMode,
    TenthsSecondsMode
} PositionModeList;


//*****************************************************************************
//*****************************************************************************
///////////////////////////////////////////////////////////////////////////////
//
// interfaces
//
///////////////////////////////////////////////////////////////////////////////
//*****************************************************************************
//*****************************************************************************

//*****************************************************************************
///////////////////////////////////////////////////////////////////////////////
//
//  Utility Interfaces
//
///////////////////////////////////////////////////////////////////////////////
//*****************************************************************************

interface IMSVidRect;

[object,
        uuid(7F5000A6-A440-47ca-8ACC-C0E75531A2C2),
        helpstring("Automation Compliant GDI Rect with Automatic HWND Scaling"),
        pointer_default(unique)
]
interface IMSVidRect : IDispatch {
    [propget, helpstring("Rectangle Top")] HRESULT Top([out, retval] LONG* TopVal);
    [propput, helpstring("Rectangle Top")] HRESULT Top([in] LONG TopVal);
    [propget, helpstring("Rectangle Left")] HRESULT Left([out, retval] LONG* LeftVal);
    [propput, helpstring("Rectangle Left")] HRESULT Left([in] LONG LeftVal);
    [propget, helpstring("Rectangle Width")] HRESULT Width([out, retval] LONG* WidthVal);
    [propput, helpstring("Rectangle Width")] HRESULT Width([in] LONG WidthVal);
    [propget, helpstring("Rectangle Height")] HRESULT Height([out, retval] LONG* HeightVal);
    [propput, helpstring("Rectangle Height")] HRESULT Height([in] LONG HeightVal);
    [propget, helpstring("Coordinates relative to HWnd")] HRESULT HWnd([out, retval] HWND* HWndVal);
    [propput, helpstring("Coordinates relative to HWnd")] HRESULT HWnd([in] HWND HWndVal);
    [propput, helpstring("New Rectangle Values")] HRESULT Rect([in] IMSVidRect* RectVal);
};

interface IMSVidGraphSegmentContainer;
interface IMSVidGraphSegment;
interface IEnumMSVidGraphSegment;


//*****************************************************************************
///////////////////////////////////////////////////////////////////////////////
//
//  Segment Container interface allowing segments to find and access other segments
//
///////////////////////////////////////////////////////////////////////////////
//*****************************************************************************
        ///////////////////////////////////////////////////////////////////////////////////////
        // if segments need to change the control state(stop, run, pause, etc) or get any stock
        // properties that are also made available to clients such as HWND, then they should simply
        // QI for the main IMSVidCtl interface.  there's no reason to implement this stuff twice.
        [object,
                uuid(3DD2903D-E0AA-11d2-B63A-00C04F79498E),
                helpstring("DShow Graph Segment Container"),
                pointer_default(unique)
        ]
        interface IMSVidGraphSegmentContainer : IUnknown {
                [propget, helpstring("Graph")] HRESULT Graph([out] IGraphBuilder **ppGraph);
                [propget, helpstring("Input Segment")] HRESULT Input([out] IMSVidGraphSegment **pInput);
                [propget, helpstring("Output Segment")] HRESULT Outputs([out] IEnumMSVidGraphSegment **pOutputs);
                [propget, helpstring("Video Renderer")] HRESULT VideoRenderer([out] IMSVidGraphSegment **pVR);
                [propget, helpstring("Audio Renderer")] HRESULT AudioRenderer([out] IMSVidGraphSegment **pAR);
                [propget, helpstring("Features")] HRESULT Features([out] IEnumMSVidGraphSegment **pOutputs);
                [propget, helpstring("Composites")] HRESULT Composites([out] IEnumMSVidGraphSegment **pComposites);
                [propget, helpstring("Container")] HRESULT ParentContainer([out] IUnknown **ppContainer);           // this allows the segments to get out and walk the dhtml hierarchy             
                HRESULT Decompose(IMSVidGraphSegment *pSegment);
                HRESULT IsWindowless(); // the stock hwnd on the main vidctl is only valid if this is set
                // be very careful using GetFocus(think twice and then don't).  it is recommended that systems follow the model 
                // laid out by atvef and smil wherein the convergence of UI and video are implemented by providing the user interface 
                //  as standard html/xml, etc with video incorporated as an element of this standard presentation.   
                // however, in the special caseof dvd there is a prexisting standard which is conceptually inside out.
                // that is, the UI is embedded in the video stream rather than the stream being embedded in the UI.
                // as a consequence, buttons and menus can asynchronously pop up out of the video stream source(dvd navigator) 
                // and, may require the focus.  this inside out paradigm is the only situation where
                // getfocus should be used.  otherwise, weird non-standard interactions will result.
                HRESULT GetFocus();
        };
        

///////////////////////////////////////////////////////////////////////////////
//
//  Direct Show Segment extension interfaces
//
///////////////////////////////////////////////////////////////////////////////

        typedef enum MSVidSegmentType {
                MSVidSEG_SOURCE,
                MSVidSEG_XFORM,
                MSVidSEG_DEST,
        } MSVidSegmentType;

        ///////////////////////////////////////////////////////////////////////////////////////
        [object,
                uuid(1C15D482-911D-11d2-B632-00C04F79498E),
                helpstring("DShow Graph Segment Builder Interface"),
                pointer_default(unique)
        ]
        interface IMSVidGraphSegment : IPersist {
        // note: we separate init and load(via put_Container) because we want to associate device object
        // with their device moniker at creation time.  but, we don't want to take the
        // hit of loading their filters until we're ready to build the graph because this segment may not get used
                [propget] HRESULT Init([out, retval] IUnknown **pInit);
                [propput] HRESULT Init([in] IUnknown *pInit);
                HRESULT EnumFilters([out] IEnumFilters **pNewEnum); //filters in seg
                [propget, helpstring("Graph that contains this segment")] HRESULT Container([out, retval] IMSVidGraphSegmentContainer **ppCtl);
                [propput, helpstring("Graph that contains this segment")] HRESULT Container([in] IMSVidGraphSegmentContainer *pCtl);
                [propget, helpstring("Type of Segment")] HRESULT Type([out, retval] MSVidSegmentType *pType);
                [propget, helpstring("Category this segment is for")] HRESULT Category([out, retval] GUID *pGuid);
                HRESULT Build();   // used to notify non-composition segment that the build/composition phase is about to start
                HRESULT PreRun();  // used to notify segments that the graph is built and about to be started
                HRESULT PostRun(); // called after graph is running
                HRESULT PreStop(); // used to notify segments that the graph about to be stopped
                HRESULT PostStop();// called after graph is stopped
                HRESULT OnEventNotify(LONG lEventCode, LONG_PTR lEventParm1, LONG_PTR lEventParm2);  //DShow events
                HRESULT Decompose();
        };


        enum {
        // button state 
         MSVIDCTL_LEFT_BUTTON   =0x0001,
         MSVIDCTL_RIGHT_BUTTON  =0x0002,
         MSVIDCTL_MIDDLE_BUTTON =0x0004,
         MSVIDCTL_X_BUTTON1     =0x0008,
         MSVIDCTL_X_BUTTON2     =0x0010,
         // shift state
         MSVIDCTL_SHIFT =0x0001,
         MSVIDCTL_CTRL  =0x0002,
         MSVIDCTL_ALT   =0x0004,
        };

        [object,
                uuid(301C060E-20D9-4587-9B03-F82ED9A9943C),
                helpstring("DShow Graph Segment Input Events"),
                pointer_default(unique)
        ]
        // this should only be implemented used by input(source) devices with ui in the video 
        // stream(specifically dvd).  see discussion of getfocus above
        interface IMSVidGraphSegmentUserInput : IUnknown {
            HRESULT Click();
            HRESULT DblClick();
            HRESULT KeyDown(short* KeyCode, short ShiftState);
            HRESULT KeyPress(short* KeyAscii);
            HRESULT KeyUp(short* KeyCode, short ShiftState);
            HRESULT MouseDown(short ButtonState, short ShiftState, OLE_XPOS_PIXELS x, OLE_YPOS_PIXELS y);
            HRESULT MouseMove(short ButtonState, short ShiftState, OLE_XPOS_PIXELS x, OLE_YPOS_PIXELS y);
            HRESULT MouseUp(short ButtonState, short ShiftState, OLE_XPOS_PIXELS x, OLE_YPOS_PIXELS y);
        }

        ///////////////////////////////////////////////////////////////////////////////////////
        [object,
                uuid(1C15D483-911D-11d2-B632-00C04F79498E),
                helpstring("DShow Graph Segment Composition Interface"),
                pointer_default(unique)
        ]
        interface IMSVidCompositionSegment : IMSVidGraphSegment {
                HRESULT Compose([in] IMSVidGraphSegment *upstream, [in] IMSVidGraphSegment *downstream);
                [propget, helpstring("The upstream segment being composed by this composition segment")] HRESULT Up([out] IMSVidGraphSegment **upstream);
                [propget, helpstring("The downstream segment being composed by this composition segment")] HRESULT Down([out] IMSVidGraphSegment **downstream);

        };

        ///////////////////////////////////////////////////////////////////////////////////////
        [object,
                uuid(3DD2903E-E0AA-11d2-B63A-00C04F79498E),
                helpstring("DShow Graph Segment Enumerator"),
                pointer_default(unique)
        ]
        interface IEnumMSVidGraphSegment : IUnknown {
                HRESULT Next([in] ULONG celt, [out] IMSVidGraphSegment ** rgelt, [out] ULONG * pceltFetched);
                HRESULT Skip([in] ULONG celt);
                HRESULT Reset(void);
                HRESULT Clone([out] IEnumMSVidGraphSegment** ppenum);
        };

        ///////////////////////////////////////////////////////////////////////////////////////
        [object,
                uuid(DD47DE3F-9874-4f7b-8B22-7CB2688461E7),
                helpstring("DShow Video Renderer Graph Segment Builder Interface"),
                pointer_default(unique)
        ]
        interface IMSVidVRGraphSegment : IMSVidGraphSegment {
            // NOTE: because of the way ActiveX controls work there is a tight coupling
            // between the video control itself and the video renderer device segment
            // as a consequence there are important interfaces such as positioning that
            // come through the control via the various ole interfaces which we need to
            // pass to the video renderer but we don't want script to access directly
            // there are also stock properties such as refresh and autosize that must also be
            // implemented directly on the video control and passed through to the video renderer

            // from ole interfaces
            [hidden, restricted, propput] HRESULT _VMRendererMode([in] LONG dwMode);