public BaseEncodingJobOptions() { EnableAutoStreamCopy = true; AllowVideoStreamCopy = true; AllowAudioStreamCopy = true; Context = EncodingContext.Streaming; }
public void Encode(int streamIdentifier, EncodingContext context) { if (streamIdentifier != 0) { throw new DecoderException(Http2ErrorCode.ProtocolError, "SETTINGS frame should not have a stream identifier. You specified: " + streamIdentifier); } if (IsAcknowledgment) { context.Buffer[context.Offset++] = 1; context.FreeBytesLeftInBuffer--; return; } context.Buffer[context.Offset++] = 0; foreach (var setting in _settings) { context.Buffer[context.Offset++] = (byte)setting.Key; context.Buffer[context.Offset++] = (byte)(setting.Key & 0xff); context.Buffer[context.Offset++] = (byte)(setting.Value); context.Buffer[context.Offset++] = (byte)(setting.Value & 0xff); context.Buffer[context.Offset++] = (byte)(setting.Value & 0xff00); context.Buffer[context.Offset++] = (byte)(setting.Value & 0xff0000); } context.FreeBytesLeftInBuffer -= 6 * _settings.Count; }
ValueTask IAsyncBinaryWriter.WriteAsync(ReadOnlyMemory <char> chars, EncodingContext context, LengthFormat?lengthFormat, CancellationToken token) { ValueTask result; if (token.IsCancellationRequested) { #if NETSTANDARD2_1 result = new (Task.FromCanceled(token)); #else result = ValueTask.FromCanceled(token); #endif } else { result = new(); try { writer.WriteString(chars.Span, in context, lengthFormat: lengthFormat); } catch (Exception e) { #if NETSTANDARD2_1 result = new (Task.FromException(e)); #else result = ValueTask.FromException(e); #endif } } return(result); }
protected override async Task SerializeToStreamAsync(Stream stream, TransportContext context) { const int maxChars = 128; //it is empiric value measured using Console.WriteLine(builder.Length) EncodingContext encodingContext = DefaultHttpEncoding; using (var encodingBuffer = new ArrayRental <byte>(DefaultHttpEncoding.GetMaxByteCount(maxChars))) { //write start boundary await stream.WriteStringAsync(DoubleDash + boundary + CrLf, encodingContext, (byte[])encodingBuffer).ConfigureAwait(false); encodingContext.Reset(); var builder = new StringBuilder(maxChars); //write each nested content var writeDivider = false; foreach (var entry in entries) { await EncodeHeadersToStreamAsync(stream, builder, entry, writeDivider, boundary, encodingContext, (byte[])encodingBuffer).ConfigureAwait(false); encodingContext.Reset(); Debug.Assert(builder.Length <= maxChars); writeDivider = true; await entry.CopyToAsync(stream).ConfigureAwait(false); } //write footer await stream.WriteStringAsync(CrLf + DoubleDash + boundary + DoubleDash + CrLf, encodingContext, (byte[])encodingBuffer).ConfigureAwait(false); } encodingContext.Reset(); }
public void Descriptor_FullCapacity() { var payload = new JwtPayload(); for (int i = 0; i < 256; i++) { payload.Add(i.ToString(), i); } var descriptor = new JweDescriptor(SymmetricJwk.GenerateKey(EncryptionAlgorithm.A128CbcHS256), KeyManagementAlgorithm.Dir, EncryptionAlgorithm.A128CbcHS256, CompressionAlgorithm.Def) { Payload = new JwsDescriptor(SymmetricJwk.GenerateKey(SignatureAlgorithm.HS256), SignatureAlgorithm.HS256) { Payload = payload } }; for (int i = 0; i < 256; i++) { descriptor.Payload.TryGetClaim(i.ToString(), out var member); Assert.Equal(JwtValueKind.Int32, member.Type); Assert.Equal(i.ToString(), member.Name.ToString()); Assert.Equal(i, (int)member.Value); } PooledByteBufferWriter writer = new PooledByteBufferWriter(); var context = new EncodingContext(writer, null, 0, false); descriptor.Encode(context); }
/// <summary> /// Writes the string into the stream. /// </summary> /// <remarks> /// This method doesn't encode the length of the string. /// </remarks> /// <param name="stream">The stream to write into.</param> /// <param name="value">The string to be encoded.</param> /// <param name="context">The encoding.</param> /// <param name="buffer">The buffer allocated by the caller needed for characters encoding.</param> /// <exception cref="ArgumentException"><paramref name="buffer"/> is too small for encoding.</exception> public static void WriteString(this Stream stream, string value, EncodingContext context, byte[] buffer) { if (value.Length == 0) { return; } //TODO: Should be rewritten for .NET Standard 2.1 if (context.Encoding.GetByteCount(value) <= buffer.Length) { stream.Write(buffer, 0, context.Encoding.GetBytes(value, 0, value.Length, buffer, 0)); } else { var maxChars = buffer.Length / context.Encoding.GetMaxByteCount(1); if (maxChars == 0) { throw new ArgumentException(ExceptionMessages.BufferTooSmall, nameof(buffer)); } var encoder = context.GetEncoder(); for (int charStart = 0, numLeft = value.Length, charsRead; numLeft > 0; charStart += charsRead, numLeft -= charsRead) { charsRead = Math.Min(numLeft, maxChars); stream.Write(buffer, 0, encoder.GetBytes(value, charStart, charsRead, buffer, charsRead == numLeft)); } } }
/// <summary> /// Writes the string into the stream asynchronously. /// </summary> /// <remarks> /// This method doesn't encode the length of the string. /// </remarks> /// <param name="stream">The stream to write into.</param> /// <param name="value">The string to be encoded.</param> /// <param name="context">The encoding context.</param> /// <param name="buffer">The buffer allocated by the caller needed for characters encoding.</param> /// <param name="token">The token that can be used to cancel the operation.</param> /// <returns>The task representing asynchronous state of the operation.</returns> /// <exception cref="ArgumentException"><paramref name="buffer"/> is too small for encoding.</exception> public static async Task WriteStringAsync(this Stream stream, string value, EncodingContext context, byte[] buffer, CancellationToken token = default) { if (value.Length == 0) { return; } //TODO: Should be rewritten for .NET Standard 2.1 if (context.Encoding.GetByteCount(value) <= buffer.Length) { await stream.WriteAsync(buffer, 0, context.Encoding.GetBytes(value, 0, value.Length, buffer, 0), token).ConfigureAwait(false); } else { var maxChars = buffer.Length / context.Encoding.GetMaxByteCount(1); if (maxChars == 0) { throw new ArgumentException(ExceptionMessages.BufferTooSmall, nameof(buffer)); } var encoder = context.GetEncoder(); for (int charStart = 0, numLeft = value.Length, charsRead; numLeft > 0; charStart += charsRead, numLeft -= charsRead) { charsRead = Math.Min(numLeft, maxChars); await stream.WriteAsync(buffer, 0, encoder.GetBytes(value, charStart, charsRead, buffer, charsRead == numLeft), token).ConfigureAwait(false); } } }
/// <inheritsdoc /> public override void Encode(EncodingContext context) { using var bufferWriter = new PooledByteBufferWriter(); var ctx = new EncodingContext(bufferWriter, context); Payload.Encode(ctx); EncryptToken(bufferWriter.WrittenSpan, context); }
public static void EncodeAsString(BufferWriter <byte> writer, Encoding encoding) { var encodingContext = new EncodingContext(encoding, true); using (writer) { var g = Guid.NewGuid(); var bi = new BigInteger(RandomBytes(64)); var dt = DateTime.Now; var dto = DateTimeOffset.Now; writer.WriteInt64(42L, LengthFormat.Plain, in encodingContext, provider: InvariantCulture); writer.WriteUInt64(12UL, LengthFormat.PlainLittleEndian, in encodingContext, provider: InvariantCulture); writer.WriteInt32(34, LengthFormat.PlainBigEndian, in encodingContext, provider: InvariantCulture); writer.WriteUInt32(78, LengthFormat.Plain, in encodingContext, provider: InvariantCulture); writer.WriteInt16(90, LengthFormat.Plain, in encodingContext, provider: InvariantCulture); writer.WriteUInt16(12, LengthFormat.Plain, in encodingContext, format: "X", provider: InvariantCulture); writer.WriteUInt16(12, LengthFormat.Plain, in encodingContext, provider: InvariantCulture); writer.WriteByte(10, LengthFormat.Plain, in encodingContext, format: "X", provider: InvariantCulture); writer.WriteSByte(11, LengthFormat.Plain, in encodingContext, format: "X", provider: InvariantCulture); writer.WriteByte(10, LengthFormat.Plain, in encodingContext, provider: InvariantCulture); writer.WriteSByte(11, LengthFormat.Plain, in encodingContext, provider: InvariantCulture); writer.WriteGuid(g, LengthFormat.Plain, in encodingContext); writer.WriteGuid(g, LengthFormat.Plain, in encodingContext, format: "X"); writer.WriteDateTime(dt, LengthFormat.Plain, in encodingContext, format: "O", provider: InvariantCulture); writer.WriteDateTimeOffset(dto, LengthFormat.Plain, in encodingContext, format: "O", provider: InvariantCulture); writer.WriteDateTime(dt, LengthFormat.Plain, in encodingContext, format: "O", provider: InvariantCulture); writer.WriteDateTimeOffset(dto, LengthFormat.Plain, in encodingContext, format: "O", provider: InvariantCulture); writer.WriteDecimal(42.5M, LengthFormat.Plain, in encodingContext, provider: InvariantCulture); writer.WriteSingle(32.2F, LengthFormat.Plain, in encodingContext, provider: InvariantCulture); writer.WriteDouble(56.6D, LengthFormat.Plain, in encodingContext, provider: InvariantCulture); writer.WriteBigInteger(bi, LengthFormat.Plain, in encodingContext, provider: InvariantCulture); var decodingContext = new DecodingContext(encoding, true); var reader = IAsyncBinaryReader.Create(writer.WrittenMemory); Equal(42L, reader.ReadInt64(LengthFormat.Plain, in decodingContext, provider: InvariantCulture)); Equal(12UL, reader.ReadUInt64(LengthFormat.PlainLittleEndian, in decodingContext, provider: InvariantCulture)); Equal(34, reader.ReadInt32(LengthFormat.PlainBigEndian, in decodingContext, provider: InvariantCulture)); Equal(78U, reader.ReadUInt32(LengthFormat.Plain, in decodingContext, provider: InvariantCulture)); Equal(90, reader.ReadInt16(LengthFormat.Plain, in decodingContext, provider: InvariantCulture)); Equal("C", reader.ReadString(LengthFormat.Plain, in decodingContext)); Equal(12, reader.ReadUInt16(LengthFormat.Plain, in decodingContext, provider: InvariantCulture)); Equal("A", reader.ReadString(LengthFormat.Plain, in decodingContext)); Equal("B", reader.ReadString(LengthFormat.Plain, in decodingContext)); Equal(10, reader.ReadByte(LengthFormat.Plain, in decodingContext, provider: InvariantCulture)); Equal(11, reader.ReadSByte(LengthFormat.Plain, in decodingContext, provider: InvariantCulture)); Equal(g, reader.ReadGuid(LengthFormat.Plain, in decodingContext)); Equal(g, reader.ReadGuid(LengthFormat.Plain, in decodingContext, "X")); Equal(dt, reader.ReadDateTime(LengthFormat.Plain, in decodingContext, style: DateTimeStyles.RoundtripKind, provider: InvariantCulture)); Equal(dto, reader.ReadDateTimeOffset(LengthFormat.Plain, in decodingContext, style: DateTimeStyles.RoundtripKind, provider: InvariantCulture)); Equal(dt, reader.ReadDateTime(LengthFormat.Plain, in decodingContext, formats: new[] { "O" }, style: DateTimeStyles.RoundtripKind, provider: InvariantCulture)); Equal(dto, reader.ReadDateTimeOffset(LengthFormat.Plain, in decodingContext, formats: new[] { "O" }, style: DateTimeStyles.RoundtripKind, provider: InvariantCulture)); Equal(42.5M, reader.ReadDecimal(LengthFormat.Plain, in decodingContext, provider: InvariantCulture)); Equal(32.2F, reader.ReadSingle(LengthFormat.Plain, in decodingContext, provider: InvariantCulture)); Equal(56.6D, reader.ReadDouble(LengthFormat.Plain, in decodingContext, provider: InvariantCulture)); Equal(bi, reader.ReadBigInteger(LengthFormat.Plain, in decodingContext, provider: InvariantCulture)); } }
static void Main(string[] args) { MMDevice dev = MMDeviceEnumerator.DefaultAudioEndpoint(DataFlow.Render, Role.Multimedia); capture = new WasapiLoopbackCapture(); capture.Device = dev; capture.Initialize(); SoundInSource soundInSource = new SoundInSource(capture); nStream = new SingleBlockNotificationStream(soundInSource.ToSampleSource()); final = nStream.ToWaveSource(); nStream.SingleBlockRead += NStream_SingleBlockRead; soundInSource.DataAvailable += encode; trashBuf = new byte[final.WaveFormat.BytesPerSecond / 2]; Console.WriteLine($"sample rate:{capture.WaveFormat.SampleRate}"); Console.WriteLine($"bits per sample:{capture.WaveFormat.BitsPerSample }"); Console.WriteLine($"channels:{capture.WaveFormat.Channels }"); Console.WriteLine($"bytes per sample:{capture.WaveFormat.BytesPerSample }"); Console.WriteLine($"bytes per second:{capture.WaveFormat.BytesPerSecond }"); Console.WriteLine($"AudioEncoding:{capture.WaveFormat.WaveFormatTag }"); EncodingContext context = FrameEncoder.GetDefaultsContext(); context.Channels = 6; context.SampleRate = capture.WaveFormat.SampleRate; context.AudioCodingMode = AudioCodingMode.Front3Rear2; context.HasLfe = true; context.SampleFormat = A52SampleFormat.Float; enc = new FrameEncoderFloat(ref context); //_writer = new WaveWriter("test.ac3", final.WaveFormat); capture.Start(); wBuffSrc = new WriteableBufferingSource(new WaveFormat(capture.WaveFormat.SampleRate, capture.WaveFormat.BitsPerSample, capture.WaveFormat.Channels, AudioEncoding.WAVE_FORMAT_DOLBY_AC3_SPDIF), (int)capture.WaveFormat.MillisecondsToBytes(20)); w = new WasapiOut2(false, AudioClientShareMode.Shared, 20); w.Device = MMDeviceEnumerator.EnumerateDevices(DataFlow.Render, DeviceState.Active).Where(x => x.FriendlyName.Contains("Digital")).Single(); AudioClient a = AudioClient.FromMMDevice(w.Device); w.Initialize(wBuffSrc); w.Play(); Task.Run(async() => await encoderThread()); //encodeSinus(); Console.ReadLine(); System.Environment.Exit(0); }
public IEnumerable<EncodingInstruction> ExecuteEncode(EncodingContext context) { object newValue = context.Value; if (_action != null) newValue = _action(context.Value); if (newValue != context.Value) { context.Value = newValue; yield return new ContextInvalidated(); } }
public async Task SerializeToBinaryFormMemoryStream() { await using var output = new MemoryStream(1024); var writer = IAsyncBinaryWriter.Create(output, buffer); await writer.WriteInt32Async(data.Count, true); var context = new EncodingContext(Encoding.UTF8, true); foreach (var(key, value) in data) { await writer.WriteAsync(key.AsMemory(), context, LengthFormat.Plain); await writer.WriteAsync(value.AsMemory(), context, LengthFormat.Plain); } }
public async Task ActAsServerAsync(Socket clientSocket) { var channel = new SocketChannel(); channel.Assign(clientSocket); _encodingContext = new EncodingContext(channel); _decodingContext = new DecodingContext(_channel); _encoder = new FrameEncoder(_encodingContext); _decoder = new FrameDecoder(); await channel.ReceiveAsync(_decodingContext.Buffer, _decodingContext.Offset, _decodingContext.Capacity); if (_decodingContext.BytesLeftToProcess < ClientPreface.Length) { //TODO: Invalid protocol } // ReSharper disable once LoopCanBeConvertedToQuery for (var i = 0; i < ClientPreface.Length; i++) { if (ClientPreface[i] != _decodingContext.Buffer[_decodingContext.Offset + i]) { throw new Http2Exception(Http2ErrorCode.ProtocolError, "ClientPreface was not valid."); } } _decodingContext.Offset += ClientPreface.Length; _decodingContext.BytesLeftToProcess -= ClientPreface.Length; // didn't get the settings frame directly if (_decodingContext.BytesLeftToProcess == 0) { await _decodingContext.ReceiveMoreAsync(); } var frame = await _decoder.DecodeAsync(_decodingContext) as SettingsFrame; if (frame == null) { throw new Http2Exception(Http2ErrorCode.ProtocolError, "Expected SETTINGS frame after client preface."); } //ack on client frame await _encoder.EncodeAsync(new SettingsFrame { IsAcknowledgment = true }); // our own settings. await _encoder.EncodeAsync(new SettingsFrame()); }
public void EncodeEmpty() { var descriptor = new JwsDescriptor(Jwk.None, SignatureAlgorithm.None); using (var bufferWriter = new PooledByteBufferWriter()) { var context = new EncodingContext(bufferWriter, new LruJwtHeaderCache(), 60, true); descriptor.Encode(context); var result = Jwt.TryParse(bufferWriter.WrittenSpan, TokenValidationPolicy.NoValidation, out var jwt); Assert.True(result); Assert.NotNull(jwt); Assert.True(jwt.Payload.ContainsClaim("exp")); Assert.True(jwt.Payload.ContainsClaim("iat")); jwt.Dispose(); } }
public async Task SerializeToBinaryFormFileStream() { await using var output = new FileStream(Path.Combine(Path.GetTempPath(), Path.GetRandomFileName()), FileMode.CreateNew, FileAccess.Write, FileShare.None, 1024, FileOptions.SequentialScan | FileOptions.Asynchronous | FileOptions.DeleteOnClose); var writer = IAsyncBinaryWriter.Create(output, buffer); await writer.WriteInt32Async(data.Count, true); var context = new EncodingContext(Encoding.UTF8, true); foreach (var(key, value) in data) { await writer.WriteAsync(key.AsMemory(), context, LengthFormat.Plain); await writer.WriteAsync(value.AsMemory(), context, LengthFormat.Plain); } await output.FlushAsync(); }
public void Encode() { var descriptor = new JwsDescriptor(); var context = new EncodingContext(new JsonHeaderCache(), 60, true); using (var bufferWriter = new PooledByteBufferWriter()) { descriptor.Encode(context, bufferWriter); var reader = new JwtReader(); var result = reader.TryReadToken(bufferWriter.WrittenSpan, TokenValidationPolicy.NoValidation); Assert.True(result.Succedeed); Assert.NotNull(result.Token); Assert.True(result.Token.ExpirationTime.HasValue); Assert.True(result.Token.IssuedAt.HasValue); } }
public IEnumerable<EncodingInstruction> ExecuteEncode(EncodingContext context) { if (_mapping.UsesReferencing) { if (context.Process.References.HasReferenceTo(context.Value)) { double reference = context.Process.References.GetReferenceTo(context.Value); context.Output += JsonToken.Parse(reference); yield break; } else { context.Process.References.Reference(context.Value); } } context.Output += JsonToken.BeginObject; Dictionary<string, JsonFieldMappingBase>.Enumerator fields = _mapping.FieldMappings.GetEnumerator(); for (int index = 0; fields.MoveNext(); index++ ) { JsonFieldMappingBase fieldMapping = fields.Current.Value; if (index > 0) { context.Output += JsonToken.ValueSeperator; } object value = fieldMapping.Get(context.Value); context.Output += JsonToken.Parse(fieldMapping.JsonField, JsonTokenType.String); context.Output += JsonToken.NameSeperator; DoEncode instruction = new DoEncode(fieldMapping.Encode(value), fieldMapping.DesiredType); yield return instruction; context.Output += instruction.Output; } context.Output += JsonToken.EndObject; }
public IEnumerable<EncodingInstruction> ExecuteEncode(EncodingContext context) { IList list = (IList)context.Value; bool parallel = false; // See if this list would benefit from parallel processing if (context.Process.IsParallel && _genericArgument != null && !context.Process.RequiresReferencing && TypeHelper.IsParallelBeneficial(_genericArgument)) { foreach (object el in list) { // Do parallel yield return new DoParallelEncode(el, _genericArgument); } parallel = true; } context.Output += JsonToken.BeginArray; for (int index = 0; index < list.Count; index++) { object element = list[index]; if (index > 0) { context.Output += JsonToken.ValueSeperator; } else if (parallel) { // Wait untill all parallel tasks are finished. yield return new SyncParallelEncode(); } DoEncode instruction = new DoEncode(element, _genericArgument); yield return instruction; context.Output += instruction.Output; } context.Output += JsonToken.EndArray; }
public async Task ConnectAsync(Uri uri) { if (uri.Scheme.Equals("https", StringComparison.OrdinalIgnoreCase)) { _channel = new SecureSocketChannel(); await _channel.ConnectAsync(uri.Host, uri.Port == 0? 443 : uri.Port); } else { _channel = new SocketChannel(); await _channel.ConnectAsync(uri.Host, uri.Port == 0? 443 : uri.Port); } _encodingContext = new EncodingContext(_channel); _encoder = new FrameEncoder(_encodingContext); Buffer.BlockCopy(ClientPreface, 0, _encodingContext.Buffer, _encodingContext.Offset, ClientPreface.Length); _encodingContext.Offset += ClientPreface.Length; var settingsFrame = new SettingsFrame(); await _encoder.EncodeAsync(settingsFrame); if (_encodingContext.ContainsData) { await _encodingContext.SendAsync(); } var ackOnOurFrame = await _decoder.DecodeAsync(_decodingContext) as SettingsFrame; if (ackOnOurFrame == null) { //TODO: Protocol error } var serverSettings = await _decoder.DecodeAsync(_decodingContext) as SettingsFrame; if (serverSettings == null) { //TODO: protocol error } }
public async Task ConnectAsync(Uri uri) { int port = uri.Port; if (uri.Scheme.Equals("https", StringComparison.OrdinalIgnoreCase)) { _socket = new SecureSocketChannel(); if (port == 0) { port = uri.Port == 0 ? 443 : uri.Port; } } else { _socket = new SocketChannel(); if (port == 0) { port = uri.Port == 0 ? 80 : uri.Port; } } await _socket.ConnectAsync(uri.Host, port); _context = new EncodingContext(_socket); _encoder = new FrameEncoder(_context); var http2Settings = new SettingsFrame(); http2Settings.Encode(1, new EncodingContext()); var handshake = string.Format(@"GET / HTTP/1.1 Host: {0} Connection: Upgrade, HTTP2-Settings Upgrade: h2c HTTP2-Settings: {1} ", uri.Host, http2Settings); }
ValueTask IAsyncBinaryWriter.WriteAsync(ReadOnlyMemory <char> chars, EncodingContext context, LengthFormat?lengthFormat, CancellationToken token) { Task result; if (token.IsCancellationRequested) { result = Task.FromCanceled(token); } else { result = Task.CompletedTask; try { writer.WriteString(chars.Span, in context, lengthFormat: lengthFormat); } catch (Exception e) { result = Task.FromException(e); } } return(new ValueTask(result)); }
private static ReadOnlyMemory <byte> CreateJws() { var descriptor = new JweDescriptor(encryptionKey1, KeyManagementAlgorithm.A128KW, EncryptionAlgorithm.A128CbcHS256) { Payload = new JwsDescriptor(signingKey1, SignatureAlgorithm.HS256) { Payload = new JwtPayload { { JwtClaimNames.Iat, 1500000000L }, { JwtClaimNames.Exp, 2000000000L }, { JwtClaimNames.Iss, "https://idp.example.com/" }, { JwtClaimNames.Aud, "636C69656E745F6964" }, { JwtClaimNames.Sub, "*****@*****.**" }, { JwtClaimNames.Jti, "12345667890" } } } }; var bufferWriter = new System.Buffers.ArrayBufferWriter <byte>(); var context = new EncodingContext(bufferWriter, null, 0, false); descriptor.Encode(context); return(bufferWriter.WrittenMemory); }
public static SubtitleProfile GetSubtitleProfile(MediaStream subtitleStream, SubtitleProfile[] subtitleProfiles, EncodingContext context, PlayMethod playMethod) { if (playMethod != PlayMethod.Transcode) { // Look for supported embedded subs foreach (SubtitleProfile profile in subtitleProfiles) { if (!profile.SupportsLanguage(subtitleStream.Language)) { continue; } if (profile.Method != SubtitleDeliveryMethod.Embed) { continue; } if (subtitleStream.IsTextSubtitleStream == MediaStream.IsTextFormat(profile.Format) && StringHelper.EqualsIgnoreCase(profile.Format, subtitleStream.Codec)) { return(profile); } } } // Look for an external profile that matches the stream type (text/graphical) foreach (SubtitleProfile profile in subtitleProfiles) { bool requiresConversion = !StringHelper.EqualsIgnoreCase(subtitleStream.Codec, profile.Format); if (!profile.SupportsLanguage(subtitleStream.Language)) { continue; } if (profile.Method == SubtitleDeliveryMethod.External && subtitleStream.IsTextSubtitleStream == MediaStream.IsTextFormat(profile.Format)) { if (!requiresConversion) { return(profile); } if (subtitleStream.SupportsExternalStream) { return(profile); } // For sync we can handle the longer extraction times if (context == EncodingContext.Static && subtitleStream.IsTextSubtitleStream) { return(profile); } } } return(new SubtitleProfile { Method = SubtitleDeliveryMethod.Encode, Format = subtitleStream.Codec }); }
public IEnumerable<EncodingInstruction> ExecuteEncode(EncodingContext context) { #if NET40 IDictionary<string, object> expando = null; IDictionary dict = null; #else IDictionary dict = (IDictionary)context.Value; #endif #if NET40 if(_dictType == typeof(ExpandoObject)) { expando = (IDictionary<string, object>)context.Value; } else { dict = (IDictionary)context.Value; } #endif bool parallel = false; // See if this list would benefit from parallel processing if (context.Process.IsParallel && _genericArgument != null && !context.Process.RequiresReferencing && TypeHelper.IsParallelBeneficial(_genericArgument)) { #if NET40 foreach (object el in (dict != null ? (ICollection)dict.Values : (ICollection)expando.Values)) #else foreach (object el in dict.Values) #endif { // Do parallel yield return new DoParallelEncode(el, _genericArgument); } parallel = true; } context.Output += JsonToken.BeginObject; object key; object value; #if NET40 IEnumerator enumerator = dict != null ? dict.GetEnumerator() : (IEnumerator)expando.GetEnumerator(); #else IDictionaryEnumerator enumerator = dict.GetEnumerator(); #endif for (int index = 0; enumerator.MoveNext(); index++) { #if NET40 if (expando != null) { KeyValuePair<string, object> pair = (KeyValuePair<string, object>)enumerator.Current; key = pair.Key; value = pair.Value; } else { DictionaryEntry entry = (DictionaryEntry)enumerator.Current; key = entry.Key; value = entry.Value; } #else key = enumerator.Key; value = enumerator.Value; #endif if (index > 0) { context.Output += JsonToken.ValueSeperator; } else if (parallel) { // Wait untill all parallel tasks are finished. yield return new SyncParallelEncode(); } context.Output += JsonToken.Parse(key, JsonTokenType.String); context.Output += JsonToken.NameSeperator; DoEncode instruction = new DoEncode(value, _genericArgument); yield return instruction; context.Output += instruction.Output; } context.Output += JsonToken.EndObject; }
public void Descriptor_AllKindOfObject() { var descriptor = new JweDescriptor(SymmetricJwk.GenerateKey(256), KeyManagementAlgorithm.Dir, EncryptionAlgorithm.A128CbcHS256, CompressionAlgorithm.Def) { Payload = new JwsDescriptor(SymmetricJwk.GenerateKey(SignatureAlgorithm.HS256), SignatureAlgorithm.HS256) { Header = new JwtHeader { { "H1", "value1" }, { "H2", new Dictionary <string, object> { { "prop1", "value2" } } }, { "H3", 123L }, { "H4", new Fake { Inner = new Fake { Value = "Inner1", Inner = new Fake { Value = "Inner2" } }, Value = "Inner0" } }, { "H5", new [] { "a", "b", "c" } }, { "H6", new [] { new object(), new object(), "abc", 123 } }, { "H7", true }, { "H8", false }, }, Payload = new JwtPayload { { "P1", "value1" }, { "P2", new Dictionary <string, object> { { "prop1", "value2" } } }, { "P3", 123L }, { "P4", new Fake { Inner = new Fake { Value = "Inner1", Inner = new Fake { Value = "Inner2" } }, Value = "Inner0" } }, { "P5", new [] { "a", "b", "c" } }, { "P6", new [] { new object(), new object(), "abc", 123 } }, { "P7", true }, { "P8", false }, } } }; Assert.True(descriptor.Payload.TryGetClaim("P1", out var claim)); Assert.Equal(JwtValueKind.String, claim.Type); Assert.True(descriptor.Payload.TryGetClaim("P2", out claim)); Assert.Equal(JwtValueKind.Object, claim.Type); Assert.True(descriptor.Payload.TryGetClaim("P3", out claim)); Assert.Equal(JwtValueKind.Int64, claim.Type); Assert.True(descriptor.Payload.TryGetClaim("P4", out claim)); Assert.Equal(JwtValueKind.Object, claim.Type); Assert.True(descriptor.Payload.TryGetClaim("P5", out claim)); Assert.Equal(JwtValueKind.Array, claim.Type); Assert.True(descriptor.Payload.TryGetClaim("P6", out claim)); Assert.Equal(JwtValueKind.Array, claim.Type); Assert.True(descriptor.Payload.TryGetClaim("P7", out claim)); Assert.Equal(JwtValueKind.True, claim.Type); Assert.True(descriptor.Payload.TryGetClaim("P8", out claim)); Assert.Equal(JwtValueKind.False, claim.Type); Assert.True(descriptor.Payload.Header.TryGetValue("alg", out var jwsHeaderParameter)); Assert.Equal(JwtValueKind.JsonEncodedString, jwsHeaderParameter.Type); Assert.True(descriptor.Payload.Header.TryGetValue("kid", out jwsHeaderParameter)); Assert.Equal(JwtValueKind.JsonEncodedString, jwsHeaderParameter.Type); Assert.True(descriptor.Payload.Header.TryGetValue("H1", out jwsHeaderParameter)); Assert.Equal(JwtValueKind.String, jwsHeaderParameter.Type); Assert.True(descriptor.Payload.Header.TryGetValue("H2", out jwsHeaderParameter)); Assert.Equal(JwtValueKind.Object, jwsHeaderParameter.Type); Assert.True(descriptor.Payload.Header.TryGetValue("H3", out jwsHeaderParameter)); Assert.Equal(JwtValueKind.Int64, jwsHeaderParameter.Type); Assert.True(descriptor.Payload.Header.TryGetValue("H4", out jwsHeaderParameter)); Assert.Equal(JwtValueKind.Object, jwsHeaderParameter.Type); Assert.True(descriptor.Payload.Header.TryGetValue("H5", out jwsHeaderParameter)); Assert.Equal(JwtValueKind.Array, jwsHeaderParameter.Type); Assert.True(descriptor.Payload.Header.TryGetValue("H6", out jwsHeaderParameter)); Assert.Equal(JwtValueKind.Array, jwsHeaderParameter.Type); Assert.True(descriptor.Payload.Header.TryGetValue("H7", out jwsHeaderParameter)); Assert.Equal(JwtValueKind.True, jwsHeaderParameter.Type); Assert.True(descriptor.Payload.Header.TryGetValue("H8", out jwsHeaderParameter)); Assert.Equal(JwtValueKind.False, jwsHeaderParameter.Type); Assert.True(descriptor.Header.TryGetValue("kid", out var jweHeaderParameter)); Assert.True(descriptor.Header.TryGetValue("alg", out jweHeaderParameter)); Assert.Equal(KeyManagementAlgorithm.Dir.Name, ((JsonEncodedText)jweHeaderParameter.Value)); Assert.True(descriptor.Header.TryGetValue("enc", out jweHeaderParameter)); Assert.Equal(EncryptionAlgorithm.A128CbcHS256.Name, ((JsonEncodedText)jweHeaderParameter.Value)); Assert.True(descriptor.Header.TryGetValue("zip", out jweHeaderParameter)); Assert.Equal(CompressionAlgorithm.Def.Name, (JsonEncodedText)jweHeaderParameter.Value); PooledByteBufferWriter writer = new PooledByteBufferWriter(); var context = new EncodingContext(writer, null, 0, false); descriptor.Encode(context); }
public static async Task WriteReadPrimitivesAsync(IAsyncBinaryReaderWriterSource source, bool littleEndian, Encoding encoding) { await using (source) { const byte value8 = 254; const short value16 = 42; const int value32 = int.MaxValue; const long value64 = long.MaxValue; const decimal valueM = 42M; const float valueF = 56.6F; const double valueD = 67.7D; var valueG = Guid.NewGuid(); var valueDT = DateTime.Now; var valueDTO = DateTimeOffset.Now; var valueT = TimeSpan.FromMilliseconds(1024); var writer = source.CreateWriter(); await writer.WriteInt16Async(value16, littleEndian); await writer.WriteInt32Async(value32, littleEndian); await writer.WriteInt64Async(value64, littleEndian); await writer.WriteAsync(valueM); var encodingContext = new EncodingContext(encoding, true); await writer.WriteByteAsync(value8, StringLengthEncoding.Plain, encodingContext, provider : InvariantCulture); await writer.WriteInt16Async(value16, StringLengthEncoding.Compressed, encodingContext, provider : InvariantCulture); await writer.WriteInt32Async(value32, StringLengthEncoding.Plain, encodingContext, provider : InvariantCulture); await writer.WriteInt64Async(value64, StringLengthEncoding.PlainBigEndian, encodingContext, provider : InvariantCulture); await writer.WriteDecimalAsync(valueM, StringLengthEncoding.PlainLittleEndian, encodingContext, provider : InvariantCulture); await writer.WriteSingleAsync(valueF, StringLengthEncoding.Plain, encodingContext, provider : InvariantCulture); await writer.WriteDoubleAsync(valueD, StringLengthEncoding.Plain, encodingContext, provider : InvariantCulture); await writer.WriteGuidAsync(valueG, StringLengthEncoding.Plain, encodingContext); await writer.WriteGuidAsync(valueG, StringLengthEncoding.Plain, encodingContext, "X"); await writer.WriteDateTimeAsync(valueDT, StringLengthEncoding.Plain, encodingContext, format : "O", provider : InvariantCulture); await writer.WriteDateTimeOffsetAsync(valueDTO, StringLengthEncoding.Plain, encodingContext, format : "O", provider : InvariantCulture); await writer.WriteDateTimeAsync(valueDT, StringLengthEncoding.Plain, encodingContext, format : "O", provider : InvariantCulture); await writer.WriteDateTimeOffsetAsync(valueDTO, StringLengthEncoding.Plain, encodingContext, format : "O", provider : InvariantCulture); await writer.WriteTimeSpanAsync(valueT, StringLengthEncoding.Plain, encodingContext); await writer.WriteTimeSpanAsync(valueT, StringLengthEncoding.Plain, encodingContext, "G", InvariantCulture); var reader = source.CreateReader(); Equal(value16, await reader.ReadInt16Async(littleEndian)); Equal(value32, await reader.ReadInt32Async(littleEndian)); Equal(value64, await reader.ReadInt64Async(littleEndian)); Equal(valueM, await reader.ReadAsync <decimal>()); var decodingContext = new DecodingContext(encoding, true); Equal(value8, await reader.ReadByteAsync(StringLengthEncoding.Plain, decodingContext, provider: InvariantCulture)); Equal(value16, await reader.ReadInt16Async(StringLengthEncoding.Compressed, decodingContext, provider: InvariantCulture)); Equal(value32, await reader.ReadInt32Async(StringLengthEncoding.Plain, decodingContext, provider: InvariantCulture)); Equal(value64, await reader.ReadInt64Async(StringLengthEncoding.PlainBigEndian, decodingContext, provider: InvariantCulture)); Equal(valueM, await reader.ReadDecimalAsync(StringLengthEncoding.PlainLittleEndian, decodingContext, provider: InvariantCulture)); Equal(valueF, await reader.ReadSingleAsync(StringLengthEncoding.Plain, decodingContext, provider: InvariantCulture)); Equal(valueD, await reader.ReadDoubleAsync(StringLengthEncoding.Plain, decodingContext, provider: InvariantCulture)); Equal(valueG, await reader.ReadGuidAsync(StringLengthEncoding.Plain, decodingContext)); Equal(valueG, await reader.ReadGuidAsync(StringLengthEncoding.Plain, decodingContext, "X")); Equal(valueDT, await reader.ReadDateTimeAsync(StringLengthEncoding.Plain, decodingContext, style: DateTimeStyles.RoundtripKind, provider: InvariantCulture)); Equal(valueDTO, await reader.ReadDateTimeOffsetAsync(StringLengthEncoding.Plain, decodingContext, style: DateTimeStyles.RoundtripKind, provider: InvariantCulture)); Equal(valueDT, await reader.ReadDateTimeAsync(StringLengthEncoding.Plain, decodingContext, new[] { "O" }, style: DateTimeStyles.RoundtripKind, provider: InvariantCulture)); Equal(valueDTO, await reader.ReadDateTimeOffsetAsync(StringLengthEncoding.Plain, decodingContext, new[] { "O" }, style: DateTimeStyles.RoundtripKind, provider: InvariantCulture)); Equal(valueT, await reader.ReadTimeSpanAsync(StringLengthEncoding.Plain, decodingContext, InvariantCulture)); Equal(valueT, await reader.ReadTimeSpanAsync(StringLengthEncoding.Plain, decodingContext, new[] { "G" }, TimeSpanStyles.None, InvariantCulture)); } }
ValueTask IAsyncBinaryWriter.WriteAsync(ReadOnlyMemory <char> chars, EncodingContext context, StringLengthEncoding?lengthFormat, CancellationToken token) => writer.WriteAsync(chars, context, lengthFormat, token);
private static Task EncodeHeadersToStreamAsync(Stream output, StringBuilder builder, TEntry entry, bool writeDivider, string boundary, EncodingContext context, byte[] buffer) { builder.Clear(); if (writeDivider) { builder.Append(CrLf + DoubleDash).Append(boundary).Append(CrLf); } //write headers WriteHeader(builder, RequestVoteMessage.RecordTermHeader, entry.Term.ToString(InvariantCulture)); WriteHeader(builder, HeaderNames.LastModified, HeaderUtils.FormatDate(entry.Timestamp)); // Extra CRLF to end headers (even if there are no headers) builder.Append(CrLf); return(output.WriteStringAsync(builder.ToString(), context, buffer)); }
public IEnumerable<EncodingInstruction> ExecuteEncode(EncodingContext context) { context.Output += JsonToken.Parse(context.Value); yield break; }
public static SubtitleProfile GetSubtitleProfile(MediaStream subtitleStream, SubtitleProfile[] subtitleProfiles, EncodingContext context) { // Look for an external profile that matches the stream type (text/graphical) foreach (SubtitleProfile profile in subtitleProfiles) { bool requiresConversion = !StringHelper.EqualsIgnoreCase(subtitleStream.Codec, profile.Format); if (!profile.SupportsLanguage(subtitleStream.Language)) { continue; } if (profile.Method == SubtitleDeliveryMethod.External && subtitleStream.IsTextSubtitleStream == MediaStream.IsTextFormat(profile.Format)) { if (!requiresConversion) { return profile; } if (subtitleStream.SupportsExternalStream) { return profile; } // For sync we can handle the longer extraction times if (context == EncodingContext.Static && subtitleStream.IsTextSubtitleStream) { return profile; } } } foreach (SubtitleProfile profile in subtitleProfiles) { bool requiresConversion = !StringHelper.EqualsIgnoreCase(subtitleStream.Codec, profile.Format); if (!profile.SupportsLanguage(subtitleStream.Language)) { continue; } if (profile.Method == SubtitleDeliveryMethod.Embed && subtitleStream.IsTextSubtitleStream == MediaStream.IsTextFormat(profile.Format)) { if (!requiresConversion) { return profile; } return profile; } } return new SubtitleProfile { Method = SubtitleDeliveryMethod.Encode, Format = subtitleStream.Codec }; }
public static SubtitleProfile GetSubtitleProfile(MediaStream subtitleStream, DeviceProfile deviceProfile, EncodingContext context) { // Look for an external profile that matches the stream type (text/graphical) foreach (SubtitleProfile profile in deviceProfile.SubtitleProfiles) { if (profile.Method == SubtitleDeliveryMethod.External && subtitleStream.IsTextSubtitleStream == MediaStream.IsTextFormat(profile.Format)) { if (subtitleStream.SupportsExternalStream) { return(profile); } // For sync we can handle the longer extraction times if (context == EncodingContext.Static && subtitleStream.IsTextSubtitleStream) { return(profile); } } } foreach (SubtitleProfile profile in deviceProfile.SubtitleProfiles) { if (profile.Method == SubtitleDeliveryMethod.Embed && subtitleStream.IsTextSubtitleStream == MediaStream.IsTextFormat(profile.Format)) { return(profile); } } return(new SubtitleProfile { Method = SubtitleDeliveryMethod.Encode, Format = subtitleStream.Codec }); }
public async Task <ActionResult> GetVideoStream( [FromRoute, Required] Guid itemId, [FromQuery] string?container, [FromQuery] bool? @static, [FromQuery] string? @params, [FromQuery] string?tag, [FromQuery] string?deviceProfileId, [FromQuery] string?playSessionId, [FromQuery] string?segmentContainer, [FromQuery] int?segmentLength, [FromQuery] int?minSegments, [FromQuery] string?mediaSourceId, [FromQuery] string?deviceId, [FromQuery] string?audioCodec, [FromQuery] bool?enableAutoStreamCopy, [FromQuery] bool?allowVideoStreamCopy, [FromQuery] bool?allowAudioStreamCopy, [FromQuery] bool?breakOnNonKeyFrames, [FromQuery] int?audioSampleRate, [FromQuery] int?maxAudioBitDepth, [FromQuery] int?audioBitRate, [FromQuery] int?audioChannels, [FromQuery] int?maxAudioChannels, [FromQuery] string?profile, [FromQuery] string?level, [FromQuery] float?framerate, [FromQuery] float?maxFramerate, [FromQuery] bool?copyTimestamps, [FromQuery] long?startTimeTicks, [FromQuery] int?width, [FromQuery] int?height, [FromQuery] int?videoBitRate, [FromQuery] int?subtitleStreamIndex, [FromQuery] SubtitleDeliveryMethod subtitleMethod, [FromQuery] int?maxRefFrames, [FromQuery] int?maxVideoBitDepth, [FromQuery] bool?requireAvc, [FromQuery] bool?deInterlace, [FromQuery] bool?requireNonAnamorphic, [FromQuery] int?transcodingMaxAudioChannels, [FromQuery] int?cpuCoreLimit, [FromQuery] string?liveStreamId, [FromQuery] bool?enableMpegtsM2TsMode, [FromQuery] string?videoCodec, [FromQuery] string?subtitleCodec, [FromQuery] string?transcodeReasons, [FromQuery] int?audioStreamIndex, [FromQuery] int?videoStreamIndex, [FromQuery] EncodingContext context, [FromQuery] Dictionary <string, string> streamOptions) { var isHeadRequest = Request.Method == System.Net.WebRequestMethods.Http.Head; var cancellationTokenSource = new CancellationTokenSource(); var streamingRequest = new VideoRequestDto { Id = itemId, Container = container, Static = @static ?? true, Params = @params, Tag = tag, DeviceProfileId = deviceProfileId, PlaySessionId = playSessionId, SegmentContainer = segmentContainer, SegmentLength = segmentLength, MinSegments = minSegments, MediaSourceId = mediaSourceId, DeviceId = deviceId, AudioCodec = audioCodec, EnableAutoStreamCopy = enableAutoStreamCopy ?? true, AllowAudioStreamCopy = allowAudioStreamCopy ?? true, AllowVideoStreamCopy = allowVideoStreamCopy ?? true, BreakOnNonKeyFrames = breakOnNonKeyFrames ?? false, AudioSampleRate = audioSampleRate, MaxAudioChannels = maxAudioChannels, AudioBitRate = audioBitRate, MaxAudioBitDepth = maxAudioBitDepth, AudioChannels = audioChannels, Profile = profile, Level = level, Framerate = framerate, MaxFramerate = maxFramerate, CopyTimestamps = copyTimestamps ?? true, StartTimeTicks = startTimeTicks, Width = width, Height = height, VideoBitRate = videoBitRate, SubtitleStreamIndex = subtitleStreamIndex, SubtitleMethod = subtitleMethod, MaxRefFrames = maxRefFrames, MaxVideoBitDepth = maxVideoBitDepth, RequireAvc = requireAvc ?? true, DeInterlace = deInterlace ?? true, RequireNonAnamorphic = requireNonAnamorphic ?? true, TranscodingMaxAudioChannels = transcodingMaxAudioChannels, CpuCoreLimit = cpuCoreLimit, LiveStreamId = liveStreamId, EnableMpegtsM2TsMode = enableMpegtsM2TsMode ?? true, VideoCodec = videoCodec, SubtitleCodec = subtitleCodec, TranscodeReasons = transcodeReasons, AudioStreamIndex = audioStreamIndex, VideoStreamIndex = videoStreamIndex, Context = context, StreamOptions = streamOptions }; using var state = await StreamingHelpers.GetStreamingState( streamingRequest, Request, _authContext, _mediaSourceManager, _userManager, _libraryManager, _serverConfigurationManager, _mediaEncoder, _fileSystem, _subtitleEncoder, _configuration, _dlnaManager, _deviceManager, _transcodingJobHelper, _transcodingJobType, cancellationTokenSource.Token) .ConfigureAwait(false); if (@static.HasValue && @static.Value && state.DirectStreamProvider != null) { StreamingHelpers.AddDlnaHeaders(state, Response.Headers, true, startTimeTicks, Request, _dlnaManager); await new ProgressiveFileCopier(state.DirectStreamProvider, null, _transcodingJobHelper, CancellationToken.None) { AllowEndOfFile = false }.WriteToAsync(Response.Body, CancellationToken.None) .ConfigureAwait(false); // TODO (moved from MediaBrowser.Api): Don't hardcode contentType return(File(Response.Body, MimeTypes.GetMimeType("file.ts") !)); } // Static remote stream if (@static.HasValue && @static.Value && state.InputProtocol == MediaProtocol.Http) { StreamingHelpers.AddDlnaHeaders(state, Response.Headers, true, startTimeTicks, Request, _dlnaManager); var httpClient = _httpClientFactory.CreateClient(NamedClient.Default); return(await FileStreamResponseHelpers.GetStaticRemoteStreamResult(state, isHeadRequest, httpClient, HttpContext).ConfigureAwait(false)); } if (@static.HasValue && @static.Value && state.InputProtocol != MediaProtocol.File) { return(BadRequest($"Input protocol {state.InputProtocol} cannot be streamed statically")); } var outputPath = state.OutputFilePath; var outputPathExists = System.IO.File.Exists(outputPath); var transcodingJob = _transcodingJobHelper.GetTranscodingJob(outputPath, TranscodingJobType.Progressive); var isTranscodeCached = outputPathExists && transcodingJob != null; StreamingHelpers.AddDlnaHeaders(state, Response.Headers, (@static.HasValue && @static.Value) || isTranscodeCached, startTimeTicks, Request, _dlnaManager); // Static stream if (@static.HasValue && @static.Value) { var contentType = state.GetMimeType("." + state.OutputContainer, false) ?? state.GetMimeType(state.MediaPath); if (state.MediaSource.IsInfiniteStream) { await new ProgressiveFileCopier(state.MediaPath, null, _transcodingJobHelper, CancellationToken.None) { AllowEndOfFile = false }.WriteToAsync(Response.Body, CancellationToken.None) .ConfigureAwait(false); return(File(Response.Body, contentType)); } return(FileStreamResponseHelpers.GetStaticFileResult( state.MediaPath, contentType, isHeadRequest, HttpContext)); } // Need to start ffmpeg (because media can't be returned directly) var encodingOptions = _serverConfigurationManager.GetEncodingOptions(); var encodingHelper = new EncodingHelper(_mediaEncoder, _fileSystem, _subtitleEncoder, _configuration); var ffmpegCommandLineArguments = encodingHelper.GetProgressiveVideoFullCommandLine(state, encodingOptions, outputPath, "superfast"); return(await FileStreamResponseHelpers.GetTranscodedFile( state, isHeadRequest, HttpContext, _transcodingJobHelper, ffmpegCommandLineArguments, _transcodingJobType, cancellationTokenSource).ConfigureAwait(false)); }
/// <summary> /// Encodes the string to bytes and write them to pipe asynchronously. /// </summary> /// <param name="writer">The pipe writer.</param> /// <param name="value">The block of characters to encode.</param> /// <param name="context">The text encoding context.</param> /// <param name="bufferSize">The buffer size (in bytes) used for encoding.</param> /// <param name="lengthFormat">String length encoding format; or <see langword="null"/> to prevent encoding of string length.</param> /// <param name="token">The token that can be used to cancel operation.</param> /// <returns>The result of operation.</returns> /// <exception cref="OperationCanceledException">The operation has been canceled.</exception> /// <exception cref="ArgumentOutOfRangeException"><paramref name="lengthFormat"/> is invalid.</exception> /// <exception cref="EndOfStreamException">Pipe closed unexpectedly.</exception> public static async ValueTask WriteStringAsync(this PipeWriter writer, ReadOnlyMemory <char> value, EncodingContext context, int bufferSize = 0, LengthFormat?lengthFormat = null, CancellationToken token = default) { var result = await writer.WriteLengthAsync(value, context.Encoding, lengthFormat, token).ConfigureAwait(false); result.ThrowIfCancellationRequested(token); if (value.IsEmpty) { return; } var encoder = context.GetEncoder(); for (int charsLeft = value.Length, charsUsed, maxChars, bytesPerChar = context.Encoding.GetMaxByteCount(1); charsLeft > 0; value = value.Slice(charsUsed), charsLeft -= charsUsed) { if (result.IsCompleted) { throw new EndOfStreamException(); } var buffer = writer.GetMemory(bufferSize); maxChars = buffer.Length / bytesPerChar; charsUsed = Math.Min(maxChars, charsLeft); encoder.Convert(value.Span.Slice(0, charsUsed), buffer.Span, charsUsed == charsLeft, out charsUsed, out var bytesUsed, out _); writer.Advance(bytesUsed); result = await writer.FlushAsync(token).ConfigureAwait(false); result.ThrowIfCancellationRequested(token); } }
public static ValueTask <FlushResult> WriteSByteAsync(this PipeWriter writer, sbyte value, LengthFormat lengthFormat, EncodingContext context, string?format = null, IFormatProvider?provider = null, CancellationToken token = default) { writer.WriteSByte(value, lengthFormat, in context, format, provider); return(writer.FlushAsync(token)); }
public Task <ActionResult> GetVideoStreamByContainer( [FromRoute, Required] Guid itemId, [FromRoute, Required] string container, [FromQuery] bool? @static, [FromQuery] string? @params, [FromQuery] string?tag, [FromQuery] string?deviceProfileId, [FromQuery] string?playSessionId, [FromQuery] string?segmentContainer, [FromQuery] int?segmentLength, [FromQuery] int?minSegments, [FromQuery] string?mediaSourceId, [FromQuery] string?deviceId, [FromQuery] string?audioCodec, [FromQuery] bool?enableAutoStreamCopy, [FromQuery] bool?allowVideoStreamCopy, [FromQuery] bool?allowAudioStreamCopy, [FromQuery] bool?breakOnNonKeyFrames, [FromQuery] int?audioSampleRate, [FromQuery] int?maxAudioBitDepth, [FromQuery] int?audioBitRate, [FromQuery] int?audioChannels, [FromQuery] int?maxAudioChannels, [FromQuery] string?profile, [FromQuery] string?level, [FromQuery] float?framerate, [FromQuery] float?maxFramerate, [FromQuery] bool?copyTimestamps, [FromQuery] long?startTimeTicks, [FromQuery] int?width, [FromQuery] int?height, [FromQuery] int?videoBitRate, [FromQuery] int?subtitleStreamIndex, [FromQuery] SubtitleDeliveryMethod subtitleMethod, [FromQuery] int?maxRefFrames, [FromQuery] int?maxVideoBitDepth, [FromQuery] bool?requireAvc, [FromQuery] bool?deInterlace, [FromQuery] bool?requireNonAnamorphic, [FromQuery] int?transcodingMaxAudioChannels, [FromQuery] int?cpuCoreLimit, [FromQuery] string?liveStreamId, [FromQuery] bool?enableMpegtsM2TsMode, [FromQuery] string?videoCodec, [FromQuery] string?subtitleCodec, [FromQuery] string?transcodeReasons, [FromQuery] int?audioStreamIndex, [FromQuery] int?videoStreamIndex, [FromQuery] EncodingContext context, [FromQuery] Dictionary <string, string> streamOptions) { return(GetVideoStream( itemId, container, @static, @params, tag, deviceProfileId, playSessionId, segmentContainer, segmentLength, minSegments, mediaSourceId, deviceId, audioCodec, enableAutoStreamCopy, allowVideoStreamCopy, allowAudioStreamCopy, breakOnNonKeyFrames, audioSampleRate, maxAudioBitDepth, audioBitRate, audioChannels, maxAudioChannels, profile, level, framerate, maxFramerate, copyTimestamps, startTimeTicks, width, height, videoBitRate, subtitleStreamIndex, subtitleMethod, maxRefFrames, maxVideoBitDepth, requireAvc, deInterlace, requireNonAnamorphic, transcodingMaxAudioChannels, cpuCoreLimit, liveStreamId, enableMpegtsM2TsMode, videoCodec, subtitleCodec, transcodeReasons, audioStreamIndex, videoStreamIndex, context, streamOptions)); }
public static ValueTask <FlushResult> WriteGuidAsync(this PipeWriter writer, Guid value, LengthFormat lengthFormat, EncodingContext context, string?format = null, CancellationToken token = default) { writer.WriteGuid(value, lengthFormat, in context, format); return(writer.FlushAsync(token)); }