eventidShowMenu,
eventidResume,
eventidSelectOrActivateButton,
eventidStillOff,
eventidPauseOn,
eventidChangeCurrentAudioStream,
eventidChangeCurrentSubpictureStream,
eventidChangeCurrentAngle,
eventidPlayAtTimeInTitle,
eventidPlayAtTime,
eventidPlayChapterInTitle,
eventidPlayChapter,
eventidReplayChapter,
eventidPlayNextChapter,
eventidStop,
eventidReturnFromSubmenu,
eventidPlayTitle,
eventidPlayPrevChapter,
eventidChangeKaraokePresMode,
eventidChangeVideoPresMode,
eventidOverlayUnavailable,
eventidSinkCertificateFailure,
eventidSinkCertificateSuccess,
eventidSourceCertificateFailure,
eventidSourceCertificateSuccess,
eventidRatingsBlocked,
eventidRatingsUnlocked,
eventidRatingsChanged,
eventidWriteFailure,
eventidTimeHole,
eventidStaleDataRead,
eventidContentBecomingStale,
eventidStaleFileDeleted,
LastReservedDeviceEvent=0x3fff
} SegEventidList;
typedef enum {
    FrameMode,
    TenthsSecondsMode
} PositionModeList;
typedef enum {
    CONTENT = 0,
    REFERENCE
} RecordingType;       

 typedef enum {
    None,
    Caption1,
    Caption2,
    Text1,
    Text2,
    XDS
} MSVidCCService;
   
//*****************************************************************************
//*****************************************************************************
///////////////////////////////////////////////////////////////////////////////
//
// 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 case of 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);
        };