Example #1
0
        public IEnumerator <ITask> QueryFrameHandler(webcam.QueryFrame query)
        {
            if (_state.FramesOnDemand)
            {
                var request = new InternalFrameRequest
                {
                    DsspQuery = query
                };
                _frameRequestPort.Post(request);

                yield return(Arbiter.Receive(false, request.ResponsePort, EmptyHandler));
            }
            else if (_state.Image == null)
            {
                query.ResponsePort.Post(new webcam.QueryFrameResponse());
            }
            else
            {
                ReplyToQueryFrame(query, _state.Image);
            }
        }
Example #2
0
        IEnumerator <ITask> HttpHandler(HttpListenerContext context, PortSet <HttpResponseType, Fault> responsePort)
        {
            HttpListenerRequest  request  = context.Request;
            HttpListenerResponse response = context.Response;

            bool alternate = false;

            string path = request.Url.AbsolutePath.ToLower(ci.InvariantCulture);

            if (path.StartsWith(_alternatePrefix))
            {
                alternate = true;
                path      = path.Substring(_alternatePrefix.Length);
            }
            else if (path.StartsWith(_prefix))
            {
                path = path.Substring(_prefix.Length);
            }

            string      type;
            ImageFormat format;

            switch (path)
            {
            case "/jpeg":
            case "/jpg":
                type   = MediaTypeNames.Image.Jpeg;
                format = ImageFormat.Jpeg;
                break;

            case "/bmp":
                type   = "image/bmp";
                format = ImageFormat.Bmp;
                break;

            case "/png":
                type   = "image/png";
                format = ImageFormat.Png;
                break;

#if !URT_MINCLR
            case "/tif":
            case "/tiff":
                type   = "image/tiff";
                format = ImageFormat.Tiff;
                break;
#endif
            case "/gif":
                type   = MediaTypeNames.Image.Gif;
                format = ImageFormat.Gif;
                break;

            default:
                if (alternate)
                {
                    responsePort.Post(new HttpResponseType(HttpStatusCode.OK, _state.ToGenericState(), _transform));
                }
                else if (path == "/log")
                {
                    var log = new PipeServerOutput();
                    lock (_pipeServerOutput)
                    {
                        log.Output = new List <string>(_pipeServerOutput);
                    }
                    responsePort.Post(new HttpResponseType(log));
                }
                else
                {
                    responsePort.Post(new HttpResponseType(HttpStatusCode.OK, _state, _transform));
                }
                yield break;
            }

            if (_state.Image == null)
            {
                if (_state.FramesOnDemand)
                {
                    if (_state.Selected != null &&
                        _state.Selected.Started)
                    {
                        var internalRequest = new InternalFrameRequest
                        {
                            Context = context,
                            Type    = type,
                            Format  = format
                        };

                        _frameRequestPort.Post(internalRequest);

//                        _state.Selected.FrameGrabber.ResumeCapture();

                        yield return(Arbiter.Receive(false, internalRequest.ResponsePort, EmptyHandler));

//                        _state.Selected.FrameGrabber.PauseCapture();
                    }
                }
                else if (alternate)
                {
                    responsePort.Post(new HttpResponseType(HttpStatusCode.NotFound, _state.ToGenericState(), _transform));
                }
                else
                {
                    responsePort.Post(new HttpResponseType(HttpStatusCode.NotFound, _state, _transform));
                }
                yield break;
            }

            using (MemoryStream stream = new MemoryStream())
            {
                _state.Image.Save(stream, format);
                stream.Position = 0;

                yield return(Arbiter.Choice(
                                 WriteImageToHttpResponse(context, type, stream),
                                 success => stream.Close(),
                                 exception => { stream.Close(); LogWarning("Writing image to stream:" + exception.Message); }
                                 ));
            }
        }