private IEnumerator <ITask> StreamImage(HttpListenerContext context, Bitmap bitmap) { HttpListenerResponse response = context.Response; using (MemoryStream stream = new MemoryStream()) { bitmap.Save(stream, ImageFormat.Png); stream.Position = 0; response.AddHeader("Cache-Control", "No-cache"); WriteResponseFromStream write = new WriteResponseFromStream( context, stream, "image/png" ); _utilitiesPort.Post(write); yield return(Arbiter.Choice( write.ResultPort, delegate(Stream res) { stream.Close(); }, delegate(Exception e) { stream.Close(); LogError(e); } )); } }
/// <summary> /// Handlers http query request for raw binary format. /// </summary> /// <param name="query">The http query</param> /// <param name="state">Depth camera state</param> /// <param name="transform"> XSLT transform to be applied</param> /// <param name="utilitiesPort">Utitilise port to post the response</param> /// <returns>CCR Task Chunk</returns> private static IEnumerator <ITask> HttpQueryHelperRawFormat( HttpQuery query, DepthCamSensorState state, string transform, DsspHttpUtilitiesPort utilitiesPort) { var type = query.Body.Query[QueryType]; byte[] imageByteArray = null; switch (type.ToLowerInvariant()) { case DepthPlusRgb: imageByteArray = ConvertVisibleAndDepthToByteArray( state.VisibleImage, state.DepthImage); break; case Rgb: imageByteArray = state.VisibleImage; break; case Depth: imageByteArray = new byte[state.DepthImage.Length * sizeof(short)]; Buffer.BlockCopy(state.DepthImage, 0, imageByteArray, 0, imageByteArray.Length); break; case Ir: imageByteArray = state.VisibleImage; break; } if (imageByteArray == null) { query.ResponsePort.Post( new HttpResponseType( HttpStatusCode.OK, state, transform)); } else { using (var mem = new MemoryStream(imageByteArray)) { var response = new WriteResponseFromStream( query.Body.Context, mem, OctetStream); utilitiesPort.Post(response); yield return(response.ResultPort.Choice()); } } }
private PortSet <Stream, Exception> WriteImageToHttpResponse(HttpListenerContext context, string type, Stream stream) { var response = context.Response; response.AddHeader("Cache-Control", "No-cache"); WriteResponseFromStream write = new WriteResponseFromStream( context, stream, type ); _utilitiesPort.Post(write); return(write.ResultPort); }
private void SendJpeg(HttpListenerContext context, Stream stream) { WriteResponseFromStream write = new WriteResponseFromStream(context, stream, MediaTypeNames.Image.Jpeg); _httpUtilities.Post(write); Activate( Arbiter.Choice( write.ResultPort, delegate(Stream res) { stream.Close(); }, delegate(Exception e) { stream.Close(); LogError(e); } ) ); }
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.ToLowerInvariant(); 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; case "/tif": case "/tiff": type = "image/tiff"; format = ImageFormat.Tiff; break; case "/gif": type = MediaTypeNames.Image.Gif; format = ImageFormat.Gif; break; default: if (alternate) { responsePort.Post(new HttpResponseType(HttpStatusCode.OK, _state.Clone(), _transform)); } else { responsePort.Post(new HttpResponseType(HttpStatusCode.OK, _state, _transform)); } yield break; } if (_state.Frame == null) { if (alternate) { responsePort.Post(new HttpResponseType(HttpStatusCode.NotFound, _state.Clone(), _transform)); } else { responsePort.Post(new HttpResponseType(HttpStatusCode.NotFound, _state, _transform)); } yield break; } using (MemoryStream stream = new MemoryStream()) { _state.Frame.Save(stream, format); stream.Position = 0; response.AddHeader("Cache-Control", "No-cache"); WriteResponseFromStream write = new WriteResponseFromStream( context, stream, type ); _utilitiesPort.Post(write); yield return(Arbiter.Choice( write.ResultPort, delegate(Stream res) { stream.Close(); }, delegate(Exception e) { stream.Close(); LogError(e); } )); } }
/// <summary> /// Provides a standard implementation of HttpQuery /// </summary> /// <param name="query">The HttpQuery message to process</param> /// <param name="state">The webcam state</param> /// <param name="transform">The embedded resource to use as the XSLT transform</param> /// <param name="utilitiesPort">The utilities port used to stream images</param> /// <returns>Stanard CCR iterator</returns> public IEnumerator <ITask> HttpQueryHelper(HttpQuery query, WebCamSensorState state, string transform, DsspHttpUtilitiesPort utilitiesPort) { var type = query.Body.Query[QueryType]; var mediaType = string.Empty; var format = default(sdi.ImageFormat); switch (type.ToLowerInvariant()) { case Jpeg: format = sdi.ImageFormat.Jpeg; mediaType = MediaTypeNames.Image.Jpeg; break; case Gif: format = sdi.ImageFormat.Gif; mediaType = MediaTypeNames.Image.Gif; break; case Png: format = sdi.ImageFormat.Png; mediaType = MediaPng; break; case Bmp: format = sdi.ImageFormat.Bmp; mediaType = MediaBmp; break; default: var copy = state.Clone() as WebCamSensorState; copy.Data = null; query.ResponsePort.Post( new HttpResponseType( HttpStatusCode.OK, copy, transform)); yield break; } if (state.Data == null || state.Data.Length == 0) { query.ResponsePort.Post( new HttpResponseType( HttpStatusCode.OK, state, transform)); yield break; } using (var image = state.Bitmap) { using (var mem = new MemoryStream()) { image.Save(mem, format); mem.Position = 0; var response = new WriteResponseFromStream( query.Body.Context, mem, mediaType); utilitiesPort.Post(response); yield return(response.ResultPort.Choice()); } } }
/// <summary> /// Handlers http query request for bitmap source format. /// </summary> /// <param name="query">The http query</param> /// <param name="state">Depth camera state</param> /// <param name="transform"> XSLT transform to be applied</param> /// <param name="utilitiesPort">Utitilise port to post the response</param> /// <param name="visibleWidth">Width of a visible image - needed to blend depth and rgb pictures for a visual represenation</param> /// <param name="visibleHeight">Height of a visible image - needed to blend depth and rgb pictures for a visual represenation</param> /// <returns>CCR Task Chunk</returns> private static IEnumerator <ITask> HttpQueryHelperBitmapSource( HttpQuery query, DepthCamSensorState state, string transform, DsspHttpUtilitiesPort utilitiesPort, int visibleWidth, int visibleHeight) { var type = query.Body.Query[QueryType]; BitmapSource bitmapSource = null; try { switch (type.ToLowerInvariant()) { case DepthPlusRgb: // we must downscale visible image to match the resolution of depth image - in order to merge the // two pictures. Its an expensive call - but we do it only here, where it was explicitly requested byte[] resizedVisibleImage = ResizeVisibleImageToMatchDepthImageDimentions( state.VisibleImage, visibleWidth, visibleHeight, state.DepthImageSize.Width, state.DepthImageSize.Height); bitmapSource = CreateBitmapSourceFromByteArray( ConvertVisibleAndDepthTo32bppByteArray(resizedVisibleImage, state.DepthImage), state.DepthImageSize.Width, state.DepthImageSize.Height, swm.PixelFormats.Bgra32); break; case Rgb: bitmapSource = CreateBitmapSourceFromByteArray( state.VisibleImage, visibleWidth, visibleHeight, swm.PixelFormats.Bgr24); break; case Depth: bitmapSource = CreateBitmapSourceFromShortPixelArray( state.DepthImage, state.DepthImageSize.Width, state.DepthImageSize.Height, (int)(state.MaximumRange * 1000), state.DepthImage.Clone() as short[]); break; case Ir: bitmapSource = CreateBitmapSourceFromInfraredArray( state.VisibleImage, state.DepthImageSize.Width, state.DepthImageSize.Height, swm.PixelFormats.Gray16); break; } } catch { // We do not attempt to synchronize the HTTP view with // state switching, so we might switch to RGB but still // have data from IR mode var width = state.DepthImageSize.Width; var height = state.DepthImageSize.Height; var zeroData = new byte[3 * width * height]; bitmapSource = BitmapSource.Create( width, height, 96, 96, swm.PixelFormats.Bgr24, null, zeroData, state.DepthImageSize.Width * 3); } if (bitmapSource == null) { query.ResponsePort.Post( new HttpResponseType( HttpStatusCode.OK, state, transform)); } else { using (var mem = new MemoryStream()) { BitmapEncoder encoder = null; PngBitmapEncoder pngEncoder = new PngBitmapEncoder(); pngEncoder.Interlace = PngInterlaceOption.Off; encoder = pngEncoder; encoder.Frames.Add(BitmapFrame.Create(bitmapSource)); encoder.Save(mem); mem.Position = 0; var response = new WriteResponseFromStream( query.Body.Context, mem, MediaPng); utilitiesPort.Post(response); yield return(response.ResultPort.Choice()); } } }
IEnumerator <ITask> HttpGetHandler(HttpGet get) { HttpListenerRequest request = get.Body.Context.Request; HttpListenerResponse response = get.Body.Context.Response; string path = request.Url.AbsolutePath; string type; ImageFormat format; switch (path) { case "/camera/jpeg": case "/camera/jpg": type = MediaTypeNames.Image.Jpeg; format = ImageFormat.Jpeg; break; case "/camera/bmp": type = "image/bmp"; format = ImageFormat.Bmp; break; case "/camera/png": type = "image/png"; format = ImageFormat.Png; break; case "/camera/tif": case "/camera/tiff": type = "image/tiff"; format = ImageFormat.Tiff; break; case "/camera/gif": type = MediaTypeNames.Image.Gif; format = ImageFormat.Gif; break; case "/camera/live": get.ResponsePort.Post(new HttpResponseType(HttpStatusCode.OK, _state, _transform)); yield break; default: get.ResponsePort.Post(new HttpResponseType(_state)); yield break; } if (_state.Image == null) { get.ResponsePort.Post(new HttpResponseType(HttpStatusCode.NotFound, _state, _transform)); yield break; } using (MemoryStream stream = new MemoryStream()) { _state.Image.Save(stream, format); stream.Position = 0; get.Body.Context.Response.AddHeader("Cache-Control", "No-cache"); WriteResponseFromStream write = new WriteResponseFromStream( get.Body.Context, stream, type ); _utilitiesPort.Post(write); yield return(Arbiter.Choice( write.ResultPort, delegate(Stream res) { stream.Close(); }, delegate(Exception e) { stream.Close(); LogError(e); } )); } }
private void SendHttp(HttpListenerContext context, Stream stream, string mediaType) { //lock (lockStatusGraphics) { WriteResponseFromStream write = new WriteResponseFromStream(context, stream, mediaType); _httpUtilities.Post(write); Activate( Arbiter.Choice( write.ResultPort, delegate(Stream res) { stream.Close(); }, delegate(Exception e) { stream.Close(); LogError(e); } ) ); } }