public Camera( IVideoSource source, IMotionDetector detector )
 {
     this.videoSource = source;
     this.motionDetecotor = detector;
     videoSource.NewFrame += new NewFrameEventHandler( video_NewFrame );
     videoSource.VideoSourceError += new VideoSourceErrorEventHandler( video_VideoSourceError );
 }

        // Open video source
        private void OpenVideoSource(IVideoSource source)
        {
            // set busy cursor
            this.Cursor = Cursors.WaitCursor;

            // reset glyph processor
            lock (_sync)
            {
                _imageProcessor.Reset();
            }

            // stop current video source
            videoSourcePlayer.SignalToStop();
            videoSourcePlayer.WaitForStop();

            // start new video source
            videoSourcePlayer.VideoSource = new AsyncVideoSource(source);
            videoSourcePlayer.Start();

            // reset stop watch
            //stopWatch = null;

            // start timer
            //timer.Start();

            this.Cursor = Cursors.Default;
        }

 public Camera(string deviceName, IVideoSource videoSource, VideoStore videoStore)
 {
     this.deviceName = deviceName;
     this.lastFrameTime = DateTime.MinValue;
     this.video = new Video(videoStore);
     this.videoSource = videoSource;
     this.videoSource.NewFrame += new NewFrameEventHandler(videoSource_NewFrame);
 }

 public VideoInput(IVideoSource source, int frames, int pixels, int verschil)
 {
     aFrames = frames;
     bgFrame = new Background(frames, pixels, verschil);
     this.source = source;
     this.source.NewFrame += new CameraEventHandler(source_NewFrame);
     this.source.Start();
 }

        private VideoFeed(IVideoSource source)
        {
            videoSource = source;

            //videoSource.DesiredFrameRate = 60;
            //videoSource.DesiredFrameSize = new Size(640, 480);

            videoSource.Start();
        }

 public void SetSource(IVideoSource videoSource)
 {
     EditableVideoSource.ErrorsChanged -= RaiseCanExecuteChanged;
     videoSourceCache = videoSource;
     var path = existingSourcePaths.First(p => p.Id == videoSource.PathId).Path;
     var source = EditableVideoSource.FromIVideoSource(videoSource, path);
     EditableVideoSource = source;
     EditableVideoSource.ErrorsChanged += RaiseCanExecuteChanged;
     EditSourceMode = true;
 }

 public static EditableVideoSource FromIVideoSource(IVideoSource videoSource, string path)
 {
     return new EditableVideoSource
     {
         Path = path,
         Name = videoSource.Name,
         ContentType = videoSource.ContentType,
         InfoSource = videoSource.InfoSource,
         NoUpdate = videoSource.NoUpdate
     };
 }

        public Camera RegisterNew(string deviceName, IVideoSource videoSource)
        {
            Camera camera = null;
            var dir = CheckAndGetDeviceFolder(deviceName);
            if (!cameraMap.TryGetValue(deviceName, out camera))
            {
                camera = new Camera(deviceName, videoSource, new VideoStore(string.Format(@"{0}\{1}", dir, deviceName)));
                cameraMap[deviceName] = camera;
            }

            return camera;
        }

        public Camera(CameraProfile profile, CameraConfig config, IVideoSource videoSource)
        {
            if (profile == null)
            throw new ArgumentNullException("profile");
              if (config == null)
            throw new ArgumentNullException("config");
              if (videoSource == null)
            throw new ArgumentNullException("videoSource");

              _profile = profile;
              _config = config;
              _videoSource = videoSource;
        }

 public YAMDDetector(IVideoSource source, Magnitude low, Magnitude medium, Magnitude high)
 {
     detector = new MotionDetector(
         new SimpleBackgroundModelingDetector(),
         new BlobCountingObjectsProcessing(true));
     //async video source processes images in a separate thread and uses the NewFrame event
     inputStream = new AsyncVideoSource(source);
     inputStream.NewFrame += inputStream_NewFrame;
     this.low = low;
     this.medium = medium;
     this.high = high;
     timer = new Stopwatch();
     stoptimer = new Stopwatch();
     videoRecorder = new VideoFileWriter();
     Running = false;
     buffer = new FixedSizeQueue<Bitmap>();
     buffer.Limit = 50;
     magnitudes = new Queue<int>();
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="AsyncVideoSource"/> class.
 /// </summary>
 /// 
 /// <param name="nestedVideoSource">Nested video source which is the target for asynchronous processing.</param>
 /// 
 public AsyncVideoSource(IVideoSource nestedVideoSource)
 {
     this.nestedVideoSource = nestedVideoSource;
 }

        //------------------------------------------------------------------------------------------------------------------------
        #endregion

        #region Constructor
        //------------------------------------------------------------------------------------------------------------------------
        public YVideoClient(IVideoSource videosource)
        {
            this.videosource = videosource;
            this.videosource.OnFrameCaptured += Videosource_OnFrameCaptured;
        }

 public CloneStream(IVideoSource source)
 {
     _source = source;
 }

 public Camera(IVideoSource source)
 {
     VideoSource = source;
     _motionDetector = null;
     VideoSource.NewFrame += VideoNewFrame;
 }

        private void OpenVideoSource(IVideoSource source, bool @override)
        {
            if ([email protected] && Camera != null && Camera.VideoSource != null && Camera.VideoSource.Source == source.Source)
            {
                return;
            }
            if (Camera != null && Camera.IsRunning)
            {
                Disable();
            }
            if (source is VlcStream)
            {
                ((VlcStream) source).FormatWidth = Camobject.settings.desktopresizewidth;
                ((VlcStream) source).FormatHeight = Camobject.settings.desktopresizeheight;
            }

            if (source is FFMPEGStream)
            {
                ((FFMPEGStream)source).HasAudioStream += VideoSourceHasAudioStream;
            }
            if (source is VlcStream)
            {
                ((VlcStream)source).HasAudioStream += VideoSourceHasAudioStream;
            }
            if (source is KinectStream)
            {
                ((KinectStream)source).HasAudioStream += VideoSourceHasAudioStream;
                ((KinectStream)source).InitTripWires(Camobject.alerts.pluginconfig);
                ((KinectStream)source).TripWire += CameraAlarm;
            }
            if (source is KinectNetworkStream)
            {
                ((KinectNetworkStream)source).HasAudioStream += VideoSourceHasAudioStream;
                ((KinectNetworkStream)source).AlertHandler += CameraWindow_AlertHandler;
            }
            source.PlayingFinished += SourcePlayingFinished;
            source.VideoSourceError += SourceVideoSourceError;

            Camera = new Camera(source);
        }

 public void InjectVideoSource(IVideoSource source, bool skipFramesAllowed = true)
 {
     OpenVideoSource(source, skipFramesAllowed);
 }

        // Open video source
        private void OpenVideoSource( IVideoSource source, bool skippingFramesAllowed = true )
        {
            // set busy cursor
            this.Cursor = Cursors.WaitCursor;

            // reset glyph processor
            imageProcessor.Reset( );

            // stop current video source
            videoSourcePlayer.SignalToStop( );
            videoSourcePlayer.WaitForStop( );

            // start new video source
            videoSourcePlayer.VideoSource = new AsyncVideoSource(source, skippingFramesAllowed);
            videoSourcePlayer.Start( );

            // reset stop watch
            stopWatch = null;

            // start timer
            timer.Start( );

            this.Cursor = Cursors.Default;
        }

		/// <summary>
		/// Create new Camera object.
		/// </summary>
		/// <param name="source">Video source.</param>
		/// <param name="imageProcess">The image process system.</param>
		/// <param name="output">To where output results.</param>
		/// <param name="graphicalOutput">How to change the graphical output.</param>
		/// <param name="pictureBox">Where to display the final image.</param>
		public Camera(IVideoSource source, IImageProcess imageProcess, IOutput output, 
			GraphicalOutputDelegate graphicalOutput, PictureBox pictureBox)
		{
			if (source == null) throw new ArgumentNullException("source");
			if (imageProcess == null) throw new ArgumentNullException("imageProcess");
			if (output == null) throw new ArgumentNullException("output");
			if (graphicalOutput == null) throw new ArgumentNullException("graphicalOutput");
			if (pictureBox == null) throw new ArgumentNullException("pictureBox");

			videoSource = source;
			videoSource.NewFrame += new NewFrameEventHandler(video_NewFrame);
			this.imageProcess = imageProcess;
			this.output = output;
			this.graphicalOutput = graphicalOutput;
			this.pictureBox = pictureBox;
		
		}

        /*
         * Start playing video using selected video device
         */
        private void StartVideo(String url)
        {
            // do this only once in case of multiple connect/disconnect actions
            if (_stream == null)
            {
                _stream = new MJPEGStream(url);
                _videoPlayer.VideoSource = _stream;
            }

            _stream.Start();
        }

        /// <summary>
        /// Sets the device.
        /// </summary>
        /// <param name="monikerString">The moniker string.</param>
        /// <remarks></remarks>
        public void SetDevice(string monikerString)
        {
            if (monikerString == "") 
                return;

            Stop();
            MonkierString = monikerString;
            Source = new VideoCaptureDevice(MonkierString);
            VideoCaptureDevice s = (VideoCaptureDevice)Source;
            s.DesiredFrameRate = 30;
            s.DesiredFrameSize = new Size(640, 480);
        }