public void DefineParam(int iParamNum, ParamInfo p, string sText) { Debug.Assert(iParamNum < Parms.Length && iParamNum >= 0, "Invalid parameter index"); Parms[iParamNum] = p; Envelopes[iParamNum] = new MPEnvelopes(p.mpdNeutralValue, p.mopCaps, p.mpType, p.mpdMaxValue, p.mpdMaxValue); ParamText[iParamNum] = sText; }
/////////////////////////////////////////////////////////////////////////////// // Public methods // /////////////////////////////////////////////////////////////////////////////// #region PUBLICMETHODS /// <summary> /// Defines a new param. /// </summary> /// <param name="paramNum">The zero based index of the param to set.</param> /// <param name="paramInfo">The <see cref="ParamInfo"/> for this parameter</param> /// <param name="text">The descriptive string.</param> public void DefineParam(int paramNum, ParamInfo paramInfo, string text) { Debug.Assert(paramNum < this.Parms.Length && paramNum >= 0, "Invalid parameter index"); this.Parms[paramNum] = paramInfo; this.Envelopes[paramNum] = new MPEnvelopes(paramInfo.mpdNeutralValue, paramInfo.mopCaps, paramInfo.mpType, paramInfo.mpdMaxValue, paramInfo.mpdMaxValue); this.ParamText[paramNum] = text; }
/// <summary> /// COM entry point for IMediaParamInfo.GetParamInfo /// </summary> /// <remarks> /// There should be no need to modify or override this method. See /// <see cref="IMediaObjectImpl.ParamDefine"/> and <see cref="IMediaObjectImpl.ParamCalcValueForTime"/> /// for details about how this works. /// </remarks> public int GetParamInfo(int dwParamIndex, out ParamInfo pInfo) { int hr; try { m_Log.Write("GetParamInfo\r\n"); lock(this) { // If the parameter is in range, return the ParamInfo if (dwParamIndex < m_Params.Parms.Length) { pInfo = m_Params.Parms[dwParamIndex]; hr = S_OK; } else { pInfo = new ParamInfo(); hr = E_INVALIDARG; } } } catch (Exception e) { // Generic handling of all exceptions. While .NET will turn exceptions into // HRESULTS "automatically", I prefer to have some place I can set a breakpoint. hr = CatFail(e); // Have to have this to make the compiler happy. pInfo = new ParamInfo(); } return hr; }
/// <summary> /// Create a definition for a parameter that is accessible thru IMediaParamInfo /// and IMediaParams. /// </summary> /// <param name="iParamNum">Zero based parameter number to set the definition for</param> /// <param name="p">Populated ParamInfo struct</param> /// <param name="sText">Format string (described in MSDN under IMediaParamInfo::GetParamText)</param> /// <remarks> /// This method should be called from the constructor of the class that implements IMediaObjectImpl. It /// defines a single parameter that can be set on the DMO. You must call it once for each of the /// parameters defined in the call to the IMediaObjectImpl constructor. This allows for automatic /// support of the IMediaParamInfo and IMediaParams methods. See the /// <see cref="IMediaObjectImpl.ParamCalcValueForTime"/> for additional details. /// </remarks> protected void ParamDefine(int iParamNum, ParamInfo p, string sText) { m_Params.DefineParam(iParamNum, p, sText); }
/////////////////////////////////////////////////////////////////////////////// // Construction and Initializing methods // /////////////////////////////////////////////////////////////////////////////// #region CONSTRUCTION /// <summary> /// Initializes a new instance of the DmoMixer class. /// The parameters to the base class /// describe the number of input and output streams, which /// DirectShow calls Pins, followed by the number of parameters /// this class supports (can be zero), and the timeformat of those /// parameters (should include ParamClass.TimeFormatFlags.Reference /// if NumParameters > 0). /// </summary> public DmoMixer() : base(InputPinCount, OutputPinCount, NumParams, TimeFormatFlags.Reference) { // Initialize the data members this.bufferFlags = 0; this.inputStreams = new VideoStream[InputPinCount]; for (int i = 0; i < InputPinCount; i++) { this.inputStreams[i] = new VideoStream(); } this.outputStream = new VideoStream(); // Start describing the parameters this DMO supports. Building this // structure (painful as it is) will allow the base class to automatically // support IMediaParamInfo & IMediaParams, which allow clients to find // out what parameters you support, and to set them. // See the MSDN // docs for MP_PARAMINFO for a description of the other parameters ParamInfo backgroundColor = new ParamInfo(); backgroundColor.mopCaps = MPCaps.Jump; backgroundColor.mpdMinValue.vInt = int.MinValue; backgroundColor.mpdMaxValue.vInt = int.MaxValue; backgroundColor.mpdNeutralValue.vInt = 0; backgroundColor.mpType = MPType.INT; backgroundColor.szLabel = "BackgroundColor"; backgroundColor.szUnitText = "Color"; ParamDefine(0, backgroundColor, "BackgroundColor\0Color\0"); for (int i = 0; i < InputPinCount; i++) { ParamInfo streamLeft = new ParamInfo(); streamLeft.mopCaps = MPCaps.Jump; streamLeft.mpdMinValue.vFloat = 0; streamLeft.mpdMaxValue.vFloat = 1; streamLeft.mpdNeutralValue.vFloat = 0; streamLeft.mpType = MPType.FLOAT; streamLeft.szLabel = "Stream" + i.ToString() + "Left"; streamLeft.szUnitText = "Position"; ParamInfo streamTop = new ParamInfo(); streamTop.mopCaps = MPCaps.Jump; streamTop.mpdMinValue.vFloat = 0; streamTop.mpdMaxValue.vFloat = 1; streamTop.mpdNeutralValue.vFloat = 0; streamTop.mpType = MPType.FLOAT; streamTop.szLabel = "Stream" + i.ToString() + "Top"; streamTop.szUnitText = "Position"; ParamInfo streamWidth = new ParamInfo(); streamWidth.mopCaps = MPCaps.Jump; streamWidth.mpdMinValue.vFloat = 0; streamWidth.mpdMaxValue.vFloat = 1; streamWidth.mpdNeutralValue.vFloat = 1; streamWidth.mpType = MPType.FLOAT; streamWidth.szLabel = "Stream" + i.ToString() + "Width"; streamWidth.szUnitText = "Position"; ParamInfo streamHeight = new ParamInfo(); streamHeight.mopCaps = MPCaps.Jump; streamHeight.mpdMinValue.vFloat = 0; streamHeight.mpdMaxValue.vFloat = 1; streamHeight.mpdNeutralValue.vFloat = 1; streamHeight.mpType = MPType.FLOAT; streamHeight.szLabel = "Stream" + i.ToString() + "Height"; streamHeight.szUnitText = "Position"; ParamInfo streamAlpha = new ParamInfo(); streamAlpha.mopCaps = MPCaps.Jump; streamAlpha.mpdMinValue.vFloat = 0; streamAlpha.mpdMaxValue.vFloat = 1; streamAlpha.mpdNeutralValue.vFloat = 1; streamAlpha.mpType = MPType.FLOAT; streamAlpha.szLabel = "Stream" + i.ToString() + "Alpha"; streamAlpha.szUnitText = "Alpha"; ParamDefine((i * 5) + 1, streamLeft, "Stream" + i.ToString() + "Left\0Position\0"); ParamDefine((i * 5) + 2, streamTop, "Stream" + i.ToString() + "Top\0Position\0"); ParamDefine((i * 5) + 3, streamWidth, "Stream" + i.ToString() + "Width\0Position\0"); ParamDefine((i * 5) + 4, streamHeight, "Stream" + i.ToString() + "Height\0Position\0"); ParamDefine((i * 5) + 5, streamAlpha, "Stream" + i.ToString() + "Alpha\0Alpha\0"); } }
/// <summary> /// The constructor. The parameters to the base class /// describe the number of input and output streams, which /// DirectShow calls Pins, followed by the number of parameters /// this class supports (can be zero), and the timeformat of those /// parameters (should include ParamClass.TimeFormatFlags.Reference /// if NumParameters > 0). /// </summary> public DmoFlip() : base(InputPinCount, OutputPinCount, NumParams, TimeFormatFlags.Reference) { m_Log.Write("Constructor\r\n"); // Initialize the data members m_Width = 0; m_Height = 0; m_Stride = 0; m_BPP = 0; m_TimeStamp = 0; m_TimeLength = 0; m_cbInData = 0; m_Flags = 0; m_InBuffer = IntPtr.Zero; m_pBuffer = null; // Start describing the parameters this DMO supports. Building this // structure (painful as it is) will allow the base class to automatically // support IMediaParamInfo & IMediaParams, which allow clients to find // out what parameters you support, and to set them. // Our parameter has a minimum value of zero, and a max of // FlipMode.LAST, and a default of DEFAULTMODE; See the MSDN // docs for MP_PARAMINFO for a description of the other parameters ParamInfo p = new ParamInfo(); p.mopCaps = MPCaps.Jump; p.mpdMinValue.vInt = 0; p.mpdMaxValue.vInt = (int)FlipMode.LAST; p.mpdNeutralValue.vInt = (int)DEFAULTMODE; p.mpType = MPType.ENUM; p.szLabel = ""; p.szUnitText = "FlipMode"; // Parameter #0, using the struct, and a format string (described in MSDN // under IMediaParamInfo::GetParamText). Note that when marshaling strings, // .NET will add another \0 ParamDefine(0, p, "FlipMode\0\0None\0FlipY\0FlipX\0FlipY|FlipX\0"); }
/////////////////////////////////////////////////////////////////////////////// // Construction and Initializing methods // /////////////////////////////////////////////////////////////////////////////// #region CONSTRUCTION /// <summary> /// Initializes a new instance of the DmoOverlay class. /// The parameters to the base class /// describe the number of input and output streams, which /// DirectShow calls Pins, followed by the number of parameters /// this class supports (can be zero), and the timeformat of those /// parameters (should include ParamClass.TimeFormatFlags.Reference /// if NumParameters > 0). /// </summary> public DmoOverlay() : base(InputPinCount, OutputPinCount, NumParams, TimeFormatFlags.Reference) { // Initialize the data members this.streamWidth = 0; this.streamHeight = 0; this.streamStride = 0; this.streamBBP = 0; this.bufferTimeStamp = 0; this.bufferTimeLength = 0; this.bufferByteCount = 0; this.bufferFlags = 0; this.bufferPointer = IntPtr.Zero; this.buffer = null; // Start describing the parameters this DMO supports. Building this // structure (painful as it is) will allow the base class to automatically // support IMediaParamInfo & IMediaParams, which allow clients to find // out what parameters you support, and to set them. // See the MSDN // docs for MP_PARAMINFO for a description of the other parameters ParamInfo gazeX = new ParamInfo(); gazeX.mopCaps = MPCaps.Jump; gazeX.mpdMinValue.vInt = 0; gazeX.mpdMaxValue.vInt = 2000; gazeX.mpdNeutralValue.vInt = 1; gazeX.mpType = MPType.INT; gazeX.szLabel = "GazeX"; gazeX.szUnitText = "Pixel"; ParamInfo gazeY = new ParamInfo(); gazeY.mopCaps = MPCaps.Jump; gazeY.mpdMinValue.vInt = 0; gazeY.mpdMaxValue.vInt = 2000; gazeY.mpdNeutralValue.vInt = 1; gazeY.mpType = MPType.INT; gazeY.szLabel = "GazeY"; gazeY.szUnitText = "Pixel"; ParamInfo mouseX = new ParamInfo(); mouseX.mopCaps = MPCaps.Jump; mouseX.mpdMinValue.vInt = 0; mouseX.mpdMaxValue.vInt = 2000; mouseX.mpdNeutralValue.vInt = 1; mouseX.mpType = MPType.INT; mouseX.szLabel = "MouseX"; mouseX.szUnitText = "Pixel"; ParamInfo mouseY = new ParamInfo(); mouseY.mopCaps = MPCaps.Jump; mouseY.mpdMinValue.vInt = 0; mouseY.mpdMaxValue.vInt = 2000; mouseY.mpdNeutralValue.vInt = 1; mouseY.mpType = MPType.INT; mouseY.szLabel = "MouseY"; mouseY.szUnitText = "Pixel"; // Parameter #0, using the struct, and a format string (described in MSDN // under IMediaParamInfo::GetParamText). Note that when marshaling strings, // .NET will add another \0 ParamDefine(0, gazeX, "GazeX\0Pixel\0"); ParamDefine(1, gazeY, "GazeY\0Pixel\0"); ParamDefine(2, mouseX, "MouseX\0Pixel\0"); ParamDefine(3, mouseY, "MouseY\0Pixel\0"); // Initialize the buffers for the gaze and mouse cursor overlay bitmaps. Bitmap circleBitmap = (Bitmap)Properties.Resources.Circle; Rectangle circleRect = new Rectangle(0, 0, circleBitmap.Width, circleBitmap.Height); this.gazeCursorSize = circleRect.Size; this.gazeCursorData = circleBitmap.LockBits(circleRect, ImageLockMode.ReadOnly, circleBitmap.PixelFormat); // Get the address of the first line. IntPtr gazeCursorScan0Pointer = this.gazeCursorData.Scan0; // Declare an array to hold the bytes of the bitmap. int gazeCursorBytes = this.gazeCursorData.Stride * this.gazeCursorData.Height; this.gazeCursorArgbValues = new byte[gazeCursorBytes]; // Copy the RGB values into the array. Marshal.Copy(gazeCursorScan0Pointer, this.gazeCursorArgbValues, 0, gazeCursorBytes); Bitmap arrowBitmap = Properties.Resources.Arrow; Rectangle cursorRect = new Rectangle(0, 0, arrowBitmap.Width, arrowBitmap.Height); this.mouseCursorSize = cursorRect.Size; this.mouseCursorData = arrowBitmap.LockBits(cursorRect, ImageLockMode.ReadOnly, arrowBitmap.PixelFormat); // Get the address of the first line. IntPtr mouseCursorScan0Pointer = this.mouseCursorData.Scan0; // Declare an array to hold the bytes of the bitmap. int mouseCursorBytes = this.mouseCursorData.Stride * this.mouseCursorData.Height; this.mouseCursorArgbValues = new byte[mouseCursorBytes]; // Copy the RGB values into the array. Marshal.Copy(mouseCursorScan0Pointer, this.mouseCursorArgbValues, 0, mouseCursorBytes); }
/// <summary> /// Create a definition for a parameter that is accessible thru IMediaParamInfo /// and IMediaParams. /// </summary> /// <param name="paramNum">Zero based parameter number to set the definition for</param> /// <param name="p">Populated ParamInfo struct</param> /// <param name="text">Format string (described in MSDN under IMediaParamInfo::GetParamText)</param> /// <remarks> /// This method should be called from the constructor of the class that implements IMediaObjectImpl. It /// defines a single parameter that can be set on the DMO. You must call it once for each of the /// parameters defined in the call to the IMediaObjectImpl constructor. This allows for automatic /// support of the IMediaParamInfo and IMediaParams methods. See the /// <see cref="IMediaObjectImpl.ParamCalcValueForTime"/> for additional details. /// </remarks> protected void ParamDefine(int paramNum, ParamInfo p, string text) { this.paramsClass.DefineParam(paramNum, p, text); }
/// <summary> /// COM entry point for IMediaParamInfo.GetParamInfo /// </summary> /// <param name="paramIndex">[in] Zero-based index of the parameter.</param> /// <param name="info">[out] Pointer to an <see cref="ParamInfo"/> structure /// that is filled with the parameter information.</param> /// <returns>Returns an HRESULT value.</returns> /// <remarks> /// There should be no need to modify or override this method. See /// <see cref="IMediaObjectImpl.ParamDefine"/> and <see cref="IMediaObjectImpl.ParamCalcValueForTime"/> /// for details about how this works. /// </remarks> public int GetParamInfo(int paramIndex, out ParamInfo info) { int hr; try { lock (this) { // If the parameter is in range, return the ParamInfo if (paramIndex < this.paramsClass.Parms.Length) { info = this.paramsClass.Parms[paramIndex]; hr = SOK; } else { info = new ParamInfo(); hr = EINVALIDARG; } } } catch (Exception e) { // Generic handling of all exceptions. While .NET will turn exceptions into // HRESULTS "automatically", I prefer to have some place I can set a breakpoint. hr = this.CatFail(e); // Have to have this to make the compiler happy. info = new ParamInfo(); } return hr; }