سوال: درخواست کامپونت ویا ... کار با وبکم شخصی

C#‎‎

	public class CaptureDevice : IVideoSource

	{

		private string	source;

		private object	userData = null;

		private int		framesReceived;



		private Thread	thread = null;

		private ManualResetEvent stopEvent = null;



		// new frame event

		public event CameraEventHandler NewFrame;



		// VideoSource property

		public virtual string VideoSource

		{

			get { return source; }

			set { source = value; }

		}

		// Login property

		public string Login

		{

			get { return null; }

			set { }

		}

		// Password property

		public string Password

		{

			get { return null; }

			set {  }

		}

		// FramesReceived property

		public int FramesReceived

		{

			get

			{

				int frames = framesReceived;

				framesReceived = 0;

				return frames;

			}

		}

		// BytesReceived property

		public int BytesReceived

		{

			get { return 0; }

		}

		// UserData property

		public object UserData

		{

			get { return userData; }

			set { userData = value; }

		}

		// Get state of the video source thread

		public bool Running

		{

			get

			{

				if (thread != null)

				{

					if (thread.Join(0) == false)

						return true;



					// the thread is not running, so free resources

					Free();

				}

				return false;

			}

		}





		// Constructor

		public CaptureDevice()

		{

		}



		// Start work

		public void Start()

		{

			if (thread == null)

			{

				framesReceived = 0;



				// create events

				stopEvent	= new ManualResetEvent(false);

				

				// create and start new thread

				thread = new Thread(new ThreadStart(WorkerThread));

				thread.Name = source;

				thread.Start();

			}

		}



		// Signal thread to stop work

		public void SignalToStop()

		{

			// stop thread

			if (thread != null)

			{

				// signal to stop

				stopEvent.Set();

			}

		}



		// Wait for thread stop

		public void WaitForStop()

		{

			if (thread != null)

			{

				// wait for thread stop

				thread.Join();



				Free();

			}

		}



		// Abort thread

		public void Stop()

		{

			if (this.Running)

			{

				thread.Abort();

				// WaitForStop();

			}

		}



		// Free resources

		private void Free()

		{

			thread = null;



			// release events

			stopEvent.Close();

			stopEvent = null;

		}



		// Thread entry point

		public void WorkerThread()

		{

			// grabber

			Grabber	grabber = new Grabber(this);



			// objects

			object	graphObj = null;

			object	sourceObj = null;

			object	grabberObj = null;



			// interfaces

			IGraphBuilder	graph = null;

			IBaseFilter		sourceBase = null;

			IBaseFilter		grabberBase = null;

			ISampleGrabber	sg = null;

			IMediaControl	mc = null;



			try

			{

				// Get type for filter graph

				Type srvType = Type.GetTypeFromCLSID(Clsid.FilterGraph);

				if (srvType == null)

					throw new ApplicationException("Failed creating filter graph");



				// create filter graph

				graphObj = Activator.CreateInstance(srvType);

				graph = (IGraphBuilder) graphObj;



				// ----

				UCOMIBindCtx bindCtx = null;

				UCOMIMoniker moniker = null;

				int n = 0;



				// create bind context

				if (Win32.CreateBindCtx(0, out bindCtx) == 0)

				{

					// convert moniker`s string to a moniker

					if (Win32.MkParseDisplayName(bindCtx, source, ref n, out moniker) == 0)

					{

						// get device base filter

						Guid filterId = typeof(IBaseFilter).GUID;

						moniker.BindToObject(null, null, ref filterId, out sourceObj);



						Marshal.ReleaseComObject(moniker);

						moniker = null;

					}

					Marshal.ReleaseComObject(bindCtx);

					bindCtx = null;

				}

				// ----



				if (sourceObj == null)

					throw new ApplicationException("Failed creating device object for moniker");



				sourceBase = (IBaseFilter) sourceObj ;



				// Get type for sample grabber

				srvType = Type.GetTypeFromCLSID(Clsid.SampleGrabber);

				if (srvType == null)

					throw new ApplicationException("Failed creating sample grabber");



				// create sample grabber

				grabberObj = Activator.CreateInstance(srvType);

				sg = (ISampleGrabber) grabberObj;

				grabberBase = (IBaseFilter) grabberObj;



				// add source filter to graph

				graph.AddFilter(sourceBase, "source");

				graph.AddFilter(grabberBase, "grabber");



				// set media type

				AMMediaType mt = new AMMediaType();

				mt.majorType = MediaType.Video;

				mt.subType = MediaSubType.RGB24;

				sg.SetMediaType(mt);



				// connect pins

				if (graph.Connect(DSTools.GetOutPin(sourceBase, 0), DSTools.GetInPin(grabberBase, 0)) < 0)

					throw new ApplicationException("Failed connecting filters");



				// get media type

				if (sg.GetConnectedMediaType(mt) == 0)

				{

					VideoInfoHeader vih = (VideoInfoHeader) Marshal.PtrToStructure(mt.formatPtr, typeof(VideoInfoHeader));



					System.Diagnostics.Debug.WriteLine("width = " + vih.BmiHeader.Width + ", height = " + vih.BmiHeader.Height);

					grabber.Width = vih.BmiHeader.Width;

					grabber.Height = vih.BmiHeader.Height;

					mt.Dispose();

				}



				// render

				graph.Render(DSTools.GetOutPin(grabberBase, 0));



				//

				sg.SetBufferSamples(false);

				sg.SetOneShot(false);

				sg.SetCallback(grabber, 1);



				// window

				IVideoWindow win = (IVideoWindow) graphObj;

				win.put_AutoShow(false);

				win = null;





				// get media control

				mc = (IMediaControl) graphObj;



				// run

				mc.Run();



				while (!stopEvent.WaitOne(0, true))

				{

					Thread.Sleep(100);

				}

				mc.StopWhenReady();

			}

			// catch any exceptions

			catch (Exception e)

			{

				System.Diagnostics.Debug.WriteLine("----: " + e.Message);

			}

			// finalization block

			finally

			{

				// release all objects

				mc = null;

				graph = null;

				sourceBase = null;

				grabberBase = null;

				sg = null;



				if (graphObj != null)

				{

					Marshal.ReleaseComObject(graphObj);

					graphObj = null;

				}

				if (sourceObj != null)

				{

					Marshal.ReleaseComObject(sourceObj);

					sourceObj = null;

				}

				if (grabberObj != null)

				{

					Marshal.ReleaseComObject(grabberObj);

					grabberObj = null;

				}

			}

		}



		// new frame

		protected void OnNewFrame(Bitmap image)

		{

			framesReceived++;

			if ((!stopEvent.WaitOne(0, true)) && (NewFrame != null))

				NewFrame(this, new CameraEventArgs(image));

		}



		// Grabber

		private class Grabber : ISampleGrabberCB

		{

			private CaptureDevice parent;

			private int width, height;



			// Width property

			public int Width

			{

				get { return width; }

				set { width = value; }

			}

			// Height property

			public int Height

			{

				get { return height; }

				set { height = value; }

			}



			// Constructor

			public Grabber(CaptureDevice parent)

			{

				this.parent = parent;

			}



			//

			public int SampleCB(double SampleTime, IntPtr pSample)

			{

				return 0;

			}



			// Callback method that receives a pointer to the sample buffer

			public int BufferCB(double SampleTime, IntPtr pBuffer, int BufferLen)

			{

				// create new image

				System.Drawing.Bitmap img = new Bitmap(width, height, PixelFormat.Format24bppRgb);



				// lock bitmap data

				BitmapData	bmData = img.LockBits(

					new Rectangle(0, 0, width, height),

					ImageLockMode.ReadWrite,

					PixelFormat.Format24bppRgb);



				// copy image data

				int srcStride = bmData.Stride;

				int dstStride = bmData.Stride;



				int dst = bmData.Scan0.ToInt32() + dstStride * (height - 1);

				int src = pBuffer.ToInt32();



				for (int y = 0; y < height; y++)

				{

					Win32.memcpy(dst, src, srcStride);

					dst -= dstStride;

					src += srcStride;

				}



				// unlock bitmap data

				img.UnlockBits(bmData);



				// notify parent

				parent.OnNewFrame(img);



				// release the image

				img.Dispose();



				return 0;

			}

		}

	}

	public interface IVideoSource

	{

		/// <summary>

		/// New frame event - notify client about the new frame

		/// </summary>

		event CameraEventHandler NewFrame;



		/// <summary>

		/// Video source property

		/// </summary>

		string VideoSource{get; set;}



		/// <summary>

		/// Login property

		/// </summary>

		string Login{get; set;}



		/// <summary>

		/// Password property

		/// </summary>

		string Password{get; set;}



		/// <summary>

		/// FramesReceived property

		/// get number of frames the video source received from the last

		/// access to the property

		/// </summary>

		int FramesReceived{get;}



		/// <summary>

		/// BytesReceived property

		/// get number of bytes the video source received from the last

		/// access to the property

		/// </summary>

		int BytesReceived{get;}



		/// <summary>

		/// UserData property

		/// allows to associate user data with an object

		/// </summary>

		object UserData{get; set;}



		/// <summary>

		/// Get state of video source

		/// </summary>

		bool Running{get;}



		/// <summary>

		/// Start receiving video frames

		/// </summary>

		void Start();



		/// <summary>

		/// Stop receiving video frames

		/// </summary>

		void SignalToStop();



		/// <summary>

		/// Wait for stop

		/// </summary>

		void WaitForStop();



		/// <summary>

		/// Stop work

		/// </summary>

		void Stop();

	}

	public delegate void CameraEventHandler(object sender, CameraEventArgs e);



	/// <summary>

	/// Camera event arguments

	/// </summary>

	public class CameraEventArgs : EventArgs

	{

		private System.Drawing.Bitmap bmp;



		// Constructor

		public CameraEventArgs(System.Drawing.Bitmap bmp)

		{

			this.bmp = bmp;

		}



		// Bitmap property

		public System.Drawing.Bitmap Bitmap

		{

			get { return bmp; }

		}

	}

	[ComImport,

	Guid("56A868B1-0AD4-11CE-B03A-0020AF0BA770"),

	InterfaceType(ComInterfaceType.InterfaceIsDual)]

	public interface IMediaControl

	{

		// Switches the entire filter graph into running mode

		[PreserveSig]

		int Run();



		// Pauses all filters in the filter graph

		[PreserveSig]

		int Pause();



		// Switches all filters in the filter graph to a stopped state

		[PreserveSig]

		int Stop();



		// Retrieves the state of the filter graph

		[PreserveSig]

		int GetState(

			int msTimeout,

			out int pfs);



		// Adds and connects filters needed to play the specified file

		[PreserveSig]

		int RenderFile(

			string strFilename);



		// Adds to the graph the source filter that can read the given file name

		[PreserveSig]

		int AddSourceFilter(

			[In] string strFilename,

			[Out, MarshalAs(UnmanagedType.IDispatch)] out object ppUnk);



		//

		[PreserveSig]

		int get_FilterCollection(

			[Out, MarshalAs(UnmanagedType.IDispatch)] out object ppUnk);



		//

		[PreserveSig]

		int get_RegFilterCollection(

			[Out, MarshalAs(UnmanagedType.IDispatch)] out object ppUnk);



		// Waits for an operation such as Pause to complete,

		// allowing filters to queue up data, then stops the filter graph

		[PreserveSig]

		int StopWhenReady();

	}

	[ComImport,

	Guid("56A868A9-0AD4-11CE-B03A-0020AF0BA770"),

	InterfaceType(ComInterfaceType.InterfaceIsIUnknown  )]

	public interface IGraphBuilder

	{

		// --- IFilterGraph Methods



		// Adds a filter to the graph and names it

		// by using the pName parameter

		[PreserveSig]

		int AddFilter(

			[In] IBaseFilter pFilter,

			[In, MarshalAs(UnmanagedType.LPWStr)] string pName);



		// Removes a filter from the graph

		[PreserveSig]

		int RemoveFilter(

			[In] IBaseFilter pFilter);



		// Provides an enumerator for all filters in the graph

		[PreserveSig]

//		int EnumFilters(

//			[Out] out IEnumFilters ppEnum);

		int EnumFilters(

			[Out] out IntPtr ppEnum);



		// Finds a filter that was added

		// to the filter graph with a specific name

		[PreserveSig]

		int FindFilterByName(

			[In, MarshalAs(UnmanagedType.LPWStr)] string pName,

			[Out] out IBaseFilter ppFilter);



		// Connects the two pins directly

		[PreserveSig]

		int ConnectDirect(

			[In] IPin ppinOut,

			[In] IPin ppinIn,

			[In, MarshalAs(UnmanagedType.LPStruct)] AMMediaType	pmt);



		// Disconnects this and the pin to which it connects and

		// then reconnects it to the same pin

		[PreserveSig]

		int Reconnect(

			[In] IPin ppin);



		// Disconnects this pin

		[PreserveSig]

		int Disconnect(

			[In] IPin ppin);



		// Sets the default source of synchronization

		[PreserveSig]

		int SetDefaultSyncSource();



		// --- IGraphBuilder methods



		// Connects the two pins, using intermediates if necessary

		[PreserveSig]

		int Connect(

			[In] IPin ppinOut,

			[In] IPin ppinIn);



		// Builds a filter graph that renders the data from this output pin

		[PreserveSig]

		int Render(

			[In] IPin ppinOut);



		// Builds a filter graph that renders the specified file

		[PreserveSig]

		int RenderFile(

			[In, MarshalAs(UnmanagedType.LPWStr)] string lpcwstrFile,

			[In, MarshalAs(UnmanagedType.LPWStr)] string lpcwstrPlayList);



		// Adds a source filter to the filter graph for a specific file

		[PreserveSig]

		int AddSourceFilter(

			[In, MarshalAs(UnmanagedType.LPWStr)] string lpcwstrFileName,

			[In, MarshalAs(UnmanagedType.LPWStr)] string lpcwstrFilterName,

			[Out] out IBaseFilter ppFilter);



		// Sets the file into which actions taken in attempting

		// to perform an operation are logged

		[PreserveSig]

		int SetLogFile(IntPtr hFile);



		//

		[PreserveSig]

		int Abort();



		//

		[PreserveSig]

		int ShouldOperationContinue();

	}

	[ComImport,

	Guid("56A86895-0AD4-11CE-B03A-0020AF0BA770"),

	InterfaceType(ComInterfaceType.InterfaceIsIUnknown  )]

	public interface IBaseFilter

	{

		// --- IPersist Methods



		// Retrieves the class identifier (CLSID) of an object

		[PreserveSig]

		int GetClassID(

			[Out] out Guid pClassID);



		// --- IMediaFilter Methods



		// Informs the filter to transition to the new state

		[PreserveSig]

		int Stop();



		// Informs the filter to transition to the new (paused) state

		[PreserveSig]

		int Pause();



		// Informs the filter to transition to the new (running) state

		[PreserveSig]

		int Run(

			long tStart);



		// Determines the state of the filter

		[PreserveSig]

		int GetState(

			int dwMilliSecsTimeout,

			[Out] out int filtState);



		// Identifies the reference clock to which the

		// filter should synchronize activity

		[PreserveSig]

//		int SetSyncSource(

//			[In] IReferenceClock pClock);

		int SetSyncSource(

			[In] IntPtr pClock);



		// Retrieves the current reference clock in use by this filter

		[PreserveSig]

//		int GetSyncSource(

//			[Out] out IReferenceClock pClock);

		int GetSyncSource(

			[Out] out IntPtr pClock);



		// --- IBaseFilter Methods



		// Enumerates the pins on this filter

		[PreserveSig]

		int EnumPins(

			[Out] out IEnumPins ppEnum);



		// Retrieves the pin with the specified identifier

		[PreserveSig]

		int FindPin(

			[In, MarshalAs(UnmanagedType.LPWStr)] string Id,

			[Out] out IPin ppPin);



		// Retrieves information about the filter

		[PreserveSig]

		int QueryFilterInfo(

			[Out] FilterInfo pInfo);



		// Notifies the filter that it has joined or left the filter graph

		[PreserveSig]

		int JoinFilterGraph(

			[In] IFilterGraph pGraph,

			[In, MarshalAs(UnmanagedType.LPWStr)] string pName);



		// Retrieves a string containing vendor information

		[PreserveSig]

		int QueryVendorInfo(

			[Out, MarshalAs(UnmanagedType.LPWStr)] out	string pVendorInfo);

	}

	// ISampleGrabber interface

	//

	// This interface provides methods for retrieving individual

	// media samples as they move through the filter graph

	//

	[ComImport,

	Guid("6B652FFF-11FE-4FCE-92AD-0266B5D7C78F"),

	InterfaceType(ComInterfaceType.InterfaceIsIUnknown  )]

	public interface ISampleGrabber

	{

		// Specifies whether the filter should stop the graph

		// after receiving one sample

		[PreserveSig]

		int SetOneShot(

			[In, MarshalAs(UnmanagedType.Bool)] bool OneShot);



		// Specifies the media type for the connection on

		// the Sample Grabber's input pin

		[PreserveSig]

		int SetMediaType(

			[In, MarshalAs(UnmanagedType.LPStruct)] AMMediaType pmt);



		// Retrieves the media type for the connection on

		// the Sample Grabber's input pin

		[PreserveSig]

		int GetConnectedMediaType(

			[Out, MarshalAs(UnmanagedType.LPStruct)] AMMediaType pmt);



		// Specifies whether to copy sample data into a buffer

		// as it goes through the filter

		[PreserveSig]

		int SetBufferSamples(

			[In, MarshalAs(UnmanagedType.Bool)] bool BufferThem);



		// Retrieves a copy of the sample that

		// the filter received most recently

		[PreserveSig]

		int GetCurrentBuffer(

			ref int pBufferSize,

			IntPtr pBuffer);



		//

		[PreserveSig]

		int GetCurrentSample(

			IntPtr ppSample);



		// Specifies a callback method to call on incoming samples

		[PreserveSig]

		int SetCallback(

			ISampleGrabberCB pCallback,

			int WhichMethodToCallback);

	}





	// ISampleGrabberCB interface

	//

	// This interface provides callback methods for the

	// ISampleGrabber::SetCallback method

	//

	[ComImport,

	Guid("0579154A-2B53-4994-B0D0-E773148EFF85"),

	InterfaceType(ComInterfaceType.InterfaceIsIUnknown  )]

	public interface ISampleGrabberCB

	{

		// Callback method that receives a pointer to the media sample

		[PreserveSig]

//		int SampleCB(

//			double SampleTime,

//			IMediaSample pSample);

		int SampleCB(

			double SampleTime,

			IntPtr pSample);



		// Callback method that receives a pointer to the sample buffer

		[PreserveSig]

		int BufferCB(

			double SampleTime,

			IntPtr pBuffer,

			int BufferLen);

	}