Ejemplo n.º 1
0
        private async Task <WebCastData> GetStreamInfo(WebSocket webSocket, CancellationToken cancellation)
        {
            while (webSocket.IsConnected && !cancellation.IsCancellationRequested)
            {
                WebSocketMessageReadStream message = await webSocket.ReadMessageAsync(cancellation).ConfigureAwait(false);

                if (message == null)
                {
                    continue;
                }

                if (message.MessageType != WebSocketMessageType.Text)
                {
                    throw new Exception("Hello must be said");
                }

                string messageContent;
                using (StreamReader streamReader = new StreamReader(message, Encoding.UTF8))
                {
                    messageContent = await streamReader.ReadToEndAsync();
                }

                WebCastMessage webCastMessage = messageContent.FromJson <WebCastMessage>();

                if (webCastMessage.Type == "hello")
                {
                    WebCastMessage helloMessage = webCastMessage;
                    _logger.Debug($"Mount point: {webSocket.HttpRequest.RequestUri}");
                    _logger.Debug($"MIME type: {webCastMessage.Data.Mime}");
                    _logger.Debug($"Audio channels: {webCastMessage.Data.Audio.Channels}");
                    if (webCastMessage.Data.Mime == "audio/mpeg")
                    {
                        _logger.Debug($"Audio bitrate: {webCastMessage.Data.Audio.BitRate}");
                    }

                    helloMessage.Data.MountPoint = Regex.Replace(webSocket.HttpRequest.RequestUri.OriginalString, @"^/", string.Empty);
                    return(helloMessage.Data);
                }

                break;
            }

            _logger.Error("Say hello first!");
            throw new Exception("Should have said hello");
        }
Ejemplo n.º 2
0
        private IConnectableObservable <byte[]> CreateObserver(WebSocket webSocket)
        {
            return(Observable.Create <byte[]>(async(observer, cancellation) =>
            {
                try
                {
                    while (webSocket.IsConnected && !cancellation.IsCancellationRequested)
                    {
                        WebSocketMessageReadStream message =
                            await webSocket.ReadMessageAsync(cancellation)
                            .ConfigureAwait(false);
                        if (message == null)
                        {
                            continue;
                        }

                        switch (message.MessageType)
                        {
                        case WebSocketMessageType.Text:
                            string messageContent;
                            using (StreamReader streamReader =
                                       new StreamReader(message, Encoding.UTF8))
                            {
                                messageContent = await streamReader.ReadToEndAsync();
                            }

                            WebCastMessage webCastMessage =
                                messageContent.FromJson <WebCastMessage>();
                            switch (webCastMessage.Type)
                            {
                            case "metadata":
                                _logger.Debug("Metadata received: {webCastMessage.Data}");
                                break;

                            default:
                                _logger.Warning("Invalid message");
                                break;
                            }

                            break;

                        case WebSocketMessageType.Binary:
                            byte[] bytes = message.ReadFully();
                            observer.OnNext(bytes);

                            break;
                        }
                    }

                    observer.OnCompleted();
                }
                catch (Exception exception)
                {
                    _logger.Error(exception, "Error Handling connection");
                    observer.OnError(exception);
                }

                return Disposable.Create(webSocket.Dispose);
            })
                   .Publish());
        }