Beispiel #1
0
        public byte[] GetCameraSnapshot(string cameraId)
        {
            byte[] snapshot;

              PublishedCamera camera = GetPublishedCamera(cameraId);
              if (camera != null)
              {
            do
            {
              snapshot = camera.LatestFrameBytes;
              if (snapshot == null) Thread.Sleep(TimeSpan.FromMilliseconds(100));
            }
            while (snapshot == null);
              }
              else
              {
            using (camera = new PublishedCamera(Locator.Get<ICameraManager>().GetCamera(cameraId)))
            {
              camera.Start();

              do
              {
            snapshot = camera.LatestFrameBytes;
            if (snapshot == null) Thread.Sleep(TimeSpan.FromMilliseconds(100));
              }
              while (snapshot == null);

              camera.Stop();
            }
              }

              return snapshot;
        }
        public PublishedCamera PublishCamera(string cameraId, PublishDestination destination)
        {
            lock (_accessLock)
            {
                if (destination == null)
                {
                    throw new ArgumentNullException("destination");
                }

                PublishedCamera camera = GetPublishedCamera(cameraId);

                if (camera != null)
                {
                    camera.AddDestination(destination);
                }
                else
                {
                    camera        = new PublishedCamera(Locator.Get <ICameraManager>().GetCamera(cameraId)).AddDestination(destination);
                    camera.Sender = StreamSenderFactory.GetSender().Start();
                    camera.CameraErrorOccurred += new EventHandler <CameraErrorOccurredEventArgs>(OnCameraErrorOccurred);
                    camera.Start();
                    _cameras.Add(camera);

                    _timeToAlive.AddOrUpdate(new CameraPublishDestination(cameraId, destination),
                                             DateTime.Now, (k, v) => { return(DateTime.Now); });
                }

                return(camera);
            }
        }
        public void UnpublishCamera(string cameraId, ICollection <PublishDestination> destinations)
        {
            lock (_accessLock)
            {
                if (destinations == null)
                {
                    throw new ArgumentNullException("destinations");
                }

                PublishedCamera camera = GetPublishedCamera(cameraId);
                if (camera != null)
                {
                    foreach (var dest in destinations)
                    {
                        camera.RemoveDestination(dest);

                        DateTime aliveTime;
                        _timeToAlive.TryRemove(
                            new CameraPublishDestination(cameraId, dest), out aliveTime);
                    }
                    if (camera.Destinations.Count <= 0)
                    {
                        camera.CameraErrorOccurred -= new EventHandler <CameraErrorOccurredEventArgs>(OnCameraErrorOccurred);
                        camera.Stop();
                        _cameras.Remove(camera);
                        camera.Dispose();
                    }
                }
            }
        }
        public PublishedCamera PublishCamera(string cameraId, ICollection <PublishDestination> destinations)
        {
            lock (_accessLock)
            {
                if (destinations == null)
                {
                    throw new ArgumentNullException("destinations");
                }

                PublishedCamera camera = null;
                foreach (var dest in destinations)
                {
                    camera = PublishCamera(cameraId, dest);
                }
                return(camera);
            }
        }
 internal static PublishedCameraData Translate(PublishedCamera camera)
 {
     PublishedCameraData data = new PublishedCameraData()
       {
     CameraId = camera.Id,
     Destinations = new List<PublishDestinationData>()
       };
       foreach (var item in camera.Destinations)
       {
     data.Destinations.Add(new PublishDestinationData()
     {
       Address = item.Address,
       Port = item.Port
     });
       }
       return data;
 }
 public void UnpublishCamera(string cameraId)
 {
     lock (_accessLock)
     {
         PublishedCamera camera = GetPublishedCamera(cameraId);
         if (camera != null)
         {
             foreach (var dest in camera.Destinations)
             {
                 DateTime aliveTime;
                 _timeToAlive.TryRemove(
                     new CameraPublishDestination(cameraId, dest), out aliveTime);
             }
             camera.ClearDestination();
             camera.CameraErrorOccurred -= new EventHandler <CameraErrorOccurredEventArgs>(OnCameraErrorOccurred);
             camera.Stop();
             _cameras.Remove(camera);
             camera.Dispose();
         }
     }
 }
        public byte[] GetCameraSnapshot(string cameraId)
        {
            byte[] snapshot;

            PublishedCamera camera = GetPublishedCamera(cameraId);

            if (camera != null)
            {
                do
                {
                    snapshot = camera.LatestFrameBytes;
                    if (snapshot == null)
                    {
                        Thread.Sleep(TimeSpan.FromMilliseconds(100));
                    }
                }while (snapshot == null);
            }
            else
            {
                using (camera = new PublishedCamera(Locator.Get <ICameraManager>().GetCamera(cameraId)))
                {
                    camera.Start();

                    do
                    {
                        snapshot = camera.LatestFrameBytes;
                        if (snapshot == null)
                        {
                            Thread.Sleep(TimeSpan.FromMilliseconds(100));
                        }
                    }while (snapshot == null);

                    camera.Stop();
                }
            }

            return(snapshot);
        }
Beispiel #8
0
        public PublishedCamera PublishCamera(string cameraId, PublishDestination destination)
        {
            lock (_accessLock)
              {
            if (destination == null)
              throw new ArgumentNullException("destination");

            PublishedCamera camera = GetPublishedCamera(cameraId);

            if (camera != null)
            {
              camera.AddDestination(destination);
            }
            else
            {
              camera = new PublishedCamera(Locator.Get<ICameraManager>().GetCamera(cameraId)).AddDestination(destination);
              camera.Sender = StreamSenderFactory.GetSender().Start();
              camera.CameraErrorOccurred += new EventHandler<CameraErrorOccurredEventArgs>(OnCameraErrorOccurred);
              camera.Start();
              _cameras.Add(camera);

              _timeToAlive.AddOrUpdate(new CameraPublishDestination(cameraId, destination),
            DateTime.Now, (k, v) => { return DateTime.Now; });
            }

            return camera;
              }
        }