public static void WriteOutput(object data, Stream output, bool closeStreams ) { if (data == output) return; XmlDocument xml = data as XmlDocument; if (xml != null) { XmlTextWriter xmlWriter = new XmlTextWriter(output, System.Text.Encoding.UTF8); xml.WriteTo(xmlWriter); xmlWriter.Flush(); } Stream stream = data as Stream; if (stream != null) { stream.Seek(0, SeekOrigin.Begin); byte[] buffer = new byte[0x5000]; int read; while ((read = stream.Read(buffer, 0, buffer.Length)) > 0) output.Write(buffer, 0, read); if ( closeStreams ) stream.Close(); } byte[] block = data as byte[]; if ( block != null && block.Length > 0 ) output.Write( block, 0, block.Length ); }
/// <summary> /// Returns the CRC32 for the specified stream, and writes the input into the /// output stream. /// </summary> /// <param name="input">The stream over which to calculate the CRC32</param> /// <param name="output">The stream into which to deflate the input</param> /// <returns>the CRC32 calculation</returns> public int GetCrc32AndCopy(Stream input, Stream?output) { if (input == null) { throw new Exception("The input stream must not be null."); } unchecked { TotalBytesRead = 0; Span <byte> buffer = stackalloc byte[4096]; int count = input.Read(buffer); output?.Write(buffer.Slice(0, count)); TotalBytesRead += count; while (count > 0) { var slice = buffer.Slice(0, count); SlurpBlock(slice); count = input.Read(buffer); output?.Write(slice); TotalBytesRead += count; } return((int)~_register); } }
public static void Write(Stream stream, byte type, Stream exportStream) { stream.WriteByte(type); stream.Write(NetworkConverter.GetBytes((int)exportStream.Length), 0, 4); byte[] buffer = null; try { buffer = _bufferManager.TakeBuffer(1024 * 4); int length = 0; while ((length = exportStream.Read(buffer, 0, buffer.Length)) > 0) { stream.Write(buffer, 0, length); } } finally { if (buffer != null) { _bufferManager.ReturnBuffer(buffer); } } }
/// <summary>Returns the CRC32 for the specified stream, and writes the input into the output stream.</summary> /// <param name="input">The stream over which to calculate the CRC32</param> /// <param name="output">The stream into which to deflate the input</param> /// <returns>the CRC32 calculation</returns> public int GetCrc32AndCopy(Stream input, Stream output) { if (input == null) { throw new Exception("The input stream must not be null."); } unchecked { var buffer = new byte[BufferSize]; var readSize = BufferSize; TotalBytesRead = 0; var count = input.Read(buffer, 0, readSize); output?.Write(buffer, 0, count); TotalBytesRead += count; while (count > 0) { SlurpBlock(buffer, 0, count); count = input.Read(buffer, 0, readSize); output?.Write(buffer, 0, count); TotalBytesRead += count; } return((int)~_register); } }
/// <summary> /// Returns the CRC32 for the specified stream, and writes the input into the /// output stream. /// </summary> /// <param name="input">The stream over which to calculate the CRC32</param> /// <param name="output">The stream into which to deflate the input</param> /// <returns>the CRC32 calculation</returns> public int GetCrc32AndCopy(Stream input, Stream?output) { if (input == null) { throw new ArgumentNullException(nameof(input), "The input stream must not be null."); } unchecked { Span <byte> buffer = stackalloc byte[BUFFER_SIZE]; //const int readSize = BUFFER_SIZE; _TotalBytesRead = 0; int count = input.Read(buffer); output?.Write(buffer.Slice(0, count)); _TotalBytesRead += count; while (count > 0) { SlurpBlock(buffer, 0, count); count = input.Read(buffer); output?.Write(buffer.Slice(0, count)); _TotalBytesRead += count; } return((int)~_register); } }
public static void CopyStream(Stream input, Stream output) { var buffer = new byte[1024]; int bytes; while ((bytes = input.Read(buffer, 0, 1024)) > 0) output.Write(buffer, 0, bytes); }
static void CompressStream(Stream from, Stream to) { byte[] src = new byte[from.Length]; // read file if (from.Read(src, 0, src.Length) == src.Length) { int dstSize = DllInterface.aP_max_packed_size(src.Length); int wrkSize = DllInterface.aP_workmem_size(src.Length); // allocate mem byte[] dst = new byte[dstSize]; byte[] wrk = new byte[wrkSize]; // compress data int packedSize = DllInterface.aPsafe_pack( src, dst, src.Length, wrk, new DllInterface.CompressionCallback(ShowProgress), 0 ); // write compressed data to.Write(dst, 0, packedSize); Console.WriteLine("compressed to {0} bytes", packedSize); } }
private void DeliverSample(ComObject requestToken, IRtspSample packet) { using (var sample = MediaFactory.CreateSample()) { using (var buffer = MediaFactory.CreateMemoryBuffer(packet.Buffer.Length)) { int max, cur; var ptr = buffer.Lock(out max, out cur); Marshal.Copy(packet.Buffer, 0, ptr, packet.Buffer.Length); buffer.CurrentLength = packet.Buffer.Length; buffer.Unlock(); sample.AddBuffer(buffer); } sample.SampleTime = packet.SampleTime; if (requestToken.NativePointer != IntPtr.Zero) { sample.Set(SampleAttributeKeys.Token, requestToken); } if (packet.IsKeyFrame) { sample.Set(SampleAttributeKeys.CleanPoint, true); } if (packet.Discontinuity) { sample.Set(SampleAttributeKeys.Discontinuity, true); } if (Type == StreamType.Video) { sample.Set(NaluAttributeKeys.LengthInformation, packet.LengthInfo.Select(BitConverter.GetBytes).SelectMany(b => b).ToArray()); } //Trace.WriteLine($"RtspMediaStream<{Type}>::DeliverSample() SampleTime={packet.SampleTime / 10000}(ms) Length={packet.Buffer.Length}"); _eventGenerator.QueueEventParamUnk(MediaEventTypes.MediaSample, Guid.Empty, Result.Ok, sample); } requestToken.Dispose(); _debugSaveStream?.Write(packet.Buffer, 0, packet.Buffer.Length); }
public override void Write(byte[] buffer, int offset, int count) { lock (this) { BaseStream?.Write(buffer, offset, count); Buffer.Write(buffer, offset, count); } }
private static void ReadResponseAsByte(WebResponse resp, CancellationToken token, Stream outputStream = null) { int bufSizeChunk = 30000; int totalBufSize = bufSizeChunk; byte[] fileBytes = new byte[totalBufSize]; int totalBytesRead = 0; var responseStream = resp.GetResponseStream(); if (responseStream != null) { using (var reader = new BinaryReader(responseStream)) { int bytesRead; while ((bytesRead = reader.Read(fileBytes, totalBytesRead, totalBufSize - totalBytesRead)) > 0) { token.ThrowIfCancellationRequested(); outputStream?.Write(fileBytes, totalBytesRead, bytesRead); totalBytesRead += bytesRead; if (totalBufSize - totalBytesRead == 0) { totalBufSize += bufSizeChunk; Array.Resize(ref fileBytes, totalBufSize); } } } } }
/// <summary> /// Reads all the bytes from the current stream and writes them to the destination stream. /// </summary> /// <param name="original">The current stream.</param> /// <param name="destination">The stream that will contain the contents of the current stream.</param> /// <exception cref="System.ArgumentNullException">Destination is null.</exception> /// <exception cref="System.NotSupportedException">The current stream does not support reading.-or-destination does not support Writing.</exception> /// <exception cref="System.ObjectDisposedException">Either the current stream or destination were closed before the System.IO.Stream.CopyTo(System.IO.Stream) method was called.</exception> /// <exception cref="System.IO.IOException">An I/O error occurred.</exception> public static void CopyTo(this Stream original, Stream destination) { if (destination == null) { throw new ArgumentNullException("destination"); } if (!original.CanRead && !original.CanWrite) { throw new ObjectDisposedException("ObjectDisposedException"); } if (!destination.CanRead && !destination.CanWrite) { throw new ObjectDisposedException("ObjectDisposedException"); } if (!original.CanRead) { throw new NotSupportedException("NotSupportedException source"); } if (!destination.CanWrite) { throw new NotSupportedException("NotSupportedException destination"); } byte[] array = new byte[4096]; int count; while ((count = original.Read(array, 0, array.Length)) != 0) { destination.Write(array, 0, count); } }
private void WriteLogLine(string text, Stream logStream, StringBuilder inMemoryLog) { var line = MakeLogLine(text); var buf = Encoding.UTF8.GetBytes(line); logStream?.Write(buf, 0, buf.Length); inMemoryLog.Append(line); }
internal void Write(byte[] data) { Stream?.Write(data, 0, data.Length); Data?.AddRange(data); DataWritten += data.Length; }
/// <inheritdoc /> public override void Write(byte[] buffer, int offset, int count) { if (_cutoff <= 0) { return; // tripped already } if (_cutoff <= count) { // write less than the whole block _streamToWrap?.Write(buffer, offset, _cutoff); _cutoff = 0; return; } _streamToWrap?.Write(buffer, offset, count); _cutoff -= count; }
private static void CopyStream(Stream source, Stream target) { const int bufSize = 0x1000; byte[] buf = new byte[bufSize]; int bytesRead = 0; while ((bytesRead = source.Read(buf, 0, bufSize)) > 0) target.Write(buf, 0, bytesRead); }
/// <summary> /// Writes the input stream to the target stream. /// </summary> /// <param name="source" this="true">The source stream to write to the target stream.</param> /// <param name="target">The target stream to write to.</param> /// <returns>The written <paramref name="target"/> stream.</returns> public static void WriteTo(this Stream source, Stream target) { var buffer = new byte[BufferSize]; var read = 0; while ((read = source.Read(buffer, 0, buffer.Length)) != 0) { target.Write(buffer, 0, read); } }
// Summary: // Reads all the bytes from the current stream and writes them to the destination // stream. // // Parameters: // destination: // The stream that will contain the contents of the current stream. // // NOTE: // This is a Stream member method in .NET 4 public static void CopyTo(this Stream source, Stream destination) { byte[] buffer = new byte[4096]; int n; while ((n = source.Read(buffer, 0, buffer.Length)) != 0) { destination.Write(buffer, 0, n); } }
static void CopyTo(Stream source, Stream destination) { var array = new byte[81920]; int count; while ((count = source.Read(array, 0, array.Length)) != 0) { destination.Write(array, 0, count); } }
/// <summary> /// Writes the given bytes into the inner (decorated) stream and handles them to update the SHA1 /// computation state. /// This can be called only if this stream is a decorator initialized in write mode. /// </summary> /// <param name="buffer"> /// An array of bytes.This method copies count bytes from buffer to the current /// stream. /// </param> /// <param name="offset"> /// The zero-based byte offset in buffer at which to begin copying bytes to the current /// stream. /// </param> /// <param name="count"> /// The number of bytes to be written to the current stream. /// </param> public override void Write(byte[] buffer, int offset, int count) { if (_reader != null) { throw new InvalidOperationException(); } _sha1.TransformBlock(buffer, offset, count, null, 0); _writer?.Write(buffer, offset, count); }
public void WriteToStream(Stream saveStream) { if (this.Deleted) { return; } saveStream?.Write(this.Data, 0, this.Data.Length); }
public static void WriteLong(long value, Stream stream, bool isLittleEndian) { byte[] buffer = BitConverter.GetBytes(value); if (BitConverter.IsLittleEndian && !isLittleEndian) { Array.Reverse(buffer); } stream.Write(buffer, 0, buffer.Length); }
public static void CopyToStream(Stream src, Stream dst, byte[] buffer, int numBytes) { while (numBytes > 0) { int req = Math.Min(buffer.Length, numBytes); int read = src.Read(buffer, 0, req); dst.Write(buffer, 0, read); numBytes -= read; } }
public static void CopyTo(this Stream from, Stream dest, byte[] buffer = null) { buffer = buffer ?? new byte[DefaultCopyBufferSize]; var bufferSize = buffer.Length; int read; while ((read = from.Read(buffer, 0, bufferSize)) > 0) { dest.Write(buffer, 0, read); } }
public void WriteZString([NotNull] string str, bool withLength, StringEncoderMode mode = StringEncoderMode.Normal) { MaybeProcessEscapeChars(ref str); var zstr = StringEncoder.Encode(str, mode); if (FinalPass && AbbreviateMode) { AbbrevFinder.AddText(str); } if (withLength) { WriteByte((byte)(zstr.Length / 2)); } position += zstr.Length; stream?.Write(zstr, 0, zstr.Length); }
public static void writedouble(Stream output, double val) { byte[] bytes = System.BitConverter.GetBytes(val); #if StandAlone #else if (System.BitConverter.IsLittleEndian) System.Array.Reverse(bytes); #endif output.Write(bytes, 0, DOUBLE_LEN); }
public int GetCrc32AndCopy(Stream input, Stream output) { byte[] array = new byte[8192]; int count = 8192; _TotalBytesRead = 0L; int num = input.Read(array, 0, count); output?.Write(array, 0, num); _TotalBytesRead += num; while (num > 0) { SlurpBlock(array, 0, num); num = input.Read(array, 0, count); output?.Write(array, 0, num); _TotalBytesRead += num; } return((int)(~_RunningCrc32Result)); }
public void connect() { try { if (connected) { throw new SocketIoClientException("already connected"); } socket = createSocket(); stream = socket.GetStream(); input = new StreamReader(stream); byte[] bytes = handshake.getHandshake(); stream.Write(bytes, 0, bytes.Length); stream.Flush(); bool handshakeComplete = false; List<string> handshakeLines = new List<string>(); string line; while(!handshakeComplete) { line = input.ReadLine().Trim(); if (line.Length>0) { handshakeLines.Add(line); } else { handshakeComplete = true; } } char[] response = new char[16]; input.ReadBlock(response, 0, response.Length); handshake.verifyServerStatusLine(handshakeLines[0]); /* Verifying handshake fails... */ //handshake.verifyServerResponse(response); handshakeLines.RemoveAt(0); Dictionary<string, string> headers = new Dictionary<string, string>(); foreach (string l in handshakeLines) { string[] keyValue = l.Split(new char[] {':'},2); headers.Add(keyValue[0].Trim(), keyValue[1].Trim()); } handshake.verifyServerHandshakeHeaders(headers); receiver = new SocketIoClientReceiver(this); connected = true; eventHandler.OnOpen(); (new Thread(receiver.run)).Start(); } catch (SocketIoClientException wse) { throw wse; } catch (IOException ioe) { throw new SocketIoClientException("error while connecting: " + ioe.StackTrace, ioe); } }
public static bool WriteBeyondEndTest(Stream s) { Console.WriteLine("Write Beyond End test on "+s.GetType().Name); FileStream fs = s as FileStream; if (fs != null) Console.WriteLine("FileStream type is: "+(fs.IsAsync ? "asynchronous" : "synchronous")); long origLength = s.Length; byte[] bytes = new byte[10]; for(int i=0; i<bytes.Length; i++) bytes[i] = (byte) i; int spanPastEnd = 5; s.Seek(spanPastEnd, SeekOrigin.End); if (s.Position != s.Length + spanPastEnd) throw new Exception("Position is incorrect! Seek(5, SeekOrigin.End) should leave us at s.Length + spanPastEnd ("+(s.Length + spanPastEnd)+"), but got: "+s.Position); Console.WriteLine("Original Length: "+origLength); s.Write(bytes, 0, bytes.Length); long pos = s.Position; if (pos != origLength + spanPastEnd + bytes.Length) throw new Exception(String.Format("After asynchronously writing beyond end of the stream, position is now incorrect! origLength: {0} pos: {1}", origLength, pos)); if (s.Length != origLength + spanPastEnd + bytes.Length) throw new Exception(String.Format("After asynchronously writing beyond end of the stream, Length is now incorrect! origLength: {0} pos: {1}", origLength, pos)); WritePastEndHelper(s, bytes, origLength, spanPastEnd, false); origLength = s.Length; s.Position = s.Length + spanPastEnd; s.WriteByte(0x42); long expected = origLength + spanPastEnd + 1; if (s.Position != expected) { iCountErrors++ ; throw new Exception("After WriteByte, Position was wrong! got: "+s.Position+" expected: "+expected); } if (s.Length != expected) { iCountErrors++ ; throw new Exception("After WriteByte, Length was wrong! got: "+s.Length+" expected: "+expected); } origLength = s.Length; s.Position = s.Length + spanPastEnd; IAsyncResult ar = s.BeginWrite(bytes, 0, bytes.Length, null, null); s.EndWrite(ar); pos = s.Position; if (pos != origLength + spanPastEnd + bytes.Length) { iCountErrors++ ; throw new Exception(String.Format("After writing beyond end of the stream, position is now incorrect! origLength: {0} pos: {1}", origLength, pos)); } if (s.Length != origLength + spanPastEnd + bytes.Length) { iCountErrors++; throw new Exception(String.Format("After writing beyond end of the stream, Length is now incorrect! origLength: {0} pos: {1}", origLength, pos)); } WritePastEndHelper(s, bytes, origLength, spanPastEnd, true); return true; }
public static void CopyStream(Stream src, Stream dst) { byte[] buff = new byte[4096]; while (true) { int read = src.Read(buff, 0, 4096); if (read == 0) break; dst.Write(buff, 0, read); } }
public static void StreamCopyTo(this Stream srcStream, Stream dstStream) { if (srcStream == null) throw new ArgumentNullException("srcStream"); if (dstStream == null) throw new ArgumentNullException("dstStream"); var buffer = new byte[BufferSize]; int readed; while ((readed = srcStream.Read(buffer, 0, BufferSize)) > 0) { dstStream.Write(buffer, 0, readed); } }
public static void CopyTo(this Stream from, Stream dest, int length, byte[] buffer = null) { buffer = buffer ?? new byte[DefaultCopyBufferSize]; var bufferSize = buffer.Length; int toRead, read, total = 0; while ((toRead = Math.Min(length - total, bufferSize)) > 0 && (read = from.Read(buffer, 0, toRead)) > 0) { dest.Write(buffer, 0, read); total += read; } }
/// <summary> /// /// </summary> /// <param name="outputStream"></param> /// <param name="sequence"></param> /// <param name="maxReaded"></param> /// <returns></returns> public long CopyUpToSequence(Stream outputStream, byte[] sequence, long maxReaded = long.MaxValue) { long totalCopied = 0; void Consume(int length) { if (length <= 0) { return; } var consumedBytes = _buffer.Consume(length); outputStream?.Write(consumedBytes, 0, consumedBytes.Length); totalCopied += consumedBytes.Length; } while (true) { var tempBufferReaded = InputStream.Read(TempBuffer, 0, (int)Math.Min(TempBuffer.Length, maxReaded - totalCopied)); if (tempBufferReaded > 0) { _buffer.Produce(TempBuffer, 0, tempBufferReaded); } if (_buffer.ConsumeRemaining <= sequence.Length) { break; } var foundIndex = _buffer.IndexOf(sequence); // Not Found if (foundIndex == -1) { Consume(_buffer.ConsumeRemaining - sequence.Length); } // Found! else { Consume(foundIndex); // Remove Sequence. _buffer.Consume(sequence.Length); return(totalCopied); } } Consume(_buffer.ConsumeRemaining); return(totalCopied); }
private static Stream CreateCryptoStreamAESWrite(string sharedSecret, Stream stream) { if (string.IsNullOrEmpty(sharedSecret)) throw new ArgumentNullException("sharedSecret"); // Генерация ключа Rfc2898DeriveBytes key = new Rfc2898DeriveBytes(sharedSecret, _salt); // Создание объекта RijndaelManaged object RijndaelManaged aesAlg = new RijndaelManaged(); aesAlg.Key = key.GetBytes(aesAlg.KeySize / 8); // Создание дешифратора для выполнения потока преобразования ICryptoTransform encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV); // Указать вначале IV stream.Write(BitConverter.GetBytes(aesAlg.IV.Length), 0, sizeof(int)); stream.Write(aesAlg.IV, 0, aesAlg.IV.Length); CryptoStream csEncrypt = new CryptoStream(stream, encryptor, CryptoStreamMode.Write); return csEncrypt; }
static public void Write(this Stream destination, LogEntry entry) { var entrySerial = entry?.SerializeToUtf8(); if (null == entrySerial) { return; } var entrySerialAndDelimiter = entrySerial.Concat(new byte[4]).ToArray(); destination?.Write(entrySerialAndDelimiter, 0, entrySerialAndDelimiter.Length); }
public override void Write(byte[] buffer, int offset, int count) { if (IsHtmlResponse()) { WebsocketScriptInjectionHelper.InjectLiveReloadScriptAsync(buffer, offset, count, _context, _baseStream) .GetAwaiter() .GetResult(); } else { _baseStream?.Write(buffer, offset, count); } }
public void Connect() { if(!IsInvoking("ParseData")){ client = new TcpClient("127.0.0.1", 13854); stream = client.GetStream(); buffer = new byte[1024]; byte[] myWriteBuffer = Encoding.ASCII.GetBytes(@"{""enableRawOutput"": true, ""format"": ""Json""}"); stream.Write(myWriteBuffer, 0, myWriteBuffer.Length); InvokeRepeating("ParseData",0.1f,0.02f); } }
public static void CopyTo(this Stream source, Stream destination, byte[] buffer, Action chunkAction) { var length = buffer.Length; while (true) { int read = source.Read(buffer, 0, length); if (read <= 0) break; destination.Write(buffer, 0, read); chunkAction(); } }
/// <summary> /// Writes the input stream to the target stream. /// </summary> /// <param name="source" this="true">The source stream to write to the target stream.</param> /// <param name="target">The target stream to write to.</param> /// <returns>The written <paramref name="target"/> stream.</returns> public static Stream WriteTo(this Stream source, Stream target) { var buffer = new byte[BufferSize]; var read = 0; while ((read = source.Read(buffer, 0, buffer.Length)) != 0) { target.Write(buffer, 0, read); } if (target.CanSeek) target.Seek(0, SeekOrigin.Begin); return target; }
public int GetCrc32AndCopy(Stream input, Stream output) { if (input == null) { throw new Exception("The input stream must not be null."); } byte[] array = new byte[8192]; int count = 8192; _TotalBytesRead = 0L; int num = input.Read(array, 0, count); output?.Write(array, 0, num); _TotalBytesRead += num; while (num > 0) { SlurpBlock(array, 0, num); num = input.Read(array, 0, count); output?.Write(array, 0, num); _TotalBytesRead += num; } return((int)(~_register)); }
public int GetCrc32AndCopy(Stream input, Stream output) { if (input == null) { throw new Exception("The input stream must not be null."); } byte[] buffer = new byte[8192]; int readSize = 8192; _TotalBytesRead = 0L; int count = input.Read(buffer, 0, readSize); output?.Write(buffer, 0, count); _TotalBytesRead += count; while (count > 0) { SlurpBlock(buffer, 0, count); count = input.Read(buffer, 0, readSize); output?.Write(buffer, 0, count); _TotalBytesRead += count; } return((int)(~_register)); }
public static void Write(Stream stream, byte type, string value) { Encoding encoding = _threadLocalEncoding.Value; byte[] buffer = null; try { buffer = _bufferManager.TakeBuffer(encoding.GetMaxByteCount(value.Length)); var length = encoding.GetBytes(value, 0, value.Length, buffer, 0); stream.WriteByte(type); stream.Write(NetworkConverter.GetBytes(length), 0, 4); stream.Write(buffer, 0, length); } finally { if (buffer != null) { _bufferManager.ReturnBuffer(buffer); } } }
public static byte[] WriteStruct <T>(T structure, Stream streamHandle = null, int writeOffset = 0) where T : struct { try { var buffer = structure.ToBytes() as byte[] ?? new byte[0]; streamHandle?.Write(buffer, writeOffset, buffer.Length); return(buffer); } catch { return(null); } }
public static void EncryptData(Stream inputStream, Stream outputStream) { byte[] buf = new byte[ENCRYPT_SIZE]; while (true) { int bytesRead = ReadBlock(inputStream, buf); if (bytesRead == 0) { break; } byte[] reversedBuffer = ShiftByteArrayRight(buf, bytesRead); outputStream.Write(reversedBuffer, 0, bytesRead); } }
private void Store(ref ZipFileEntry _zfe, Stream _source) { byte[] buffer = new byte[16384]; uint num = 0; Stream stream = (Stream)null; long position1 = this.ZipFileStream.Position; long position2 = _source.Position; if (_zfe.Method == BlueStacks.BlueStacksUI.Compression.Store) { stream = this.ZipFileStream; } else if (_zfe.Method == BlueStacks.BlueStacksUI.Compression.Deflate) { stream = (Stream) new DeflateStream(this.ZipFileStream, CompressionMode.Compress, true); } _zfe.Crc32 = uint.MaxValue; int count; do { count = _source.Read(buffer, 0, buffer.Length); num += (uint)count; if (count > 0) { stream?.Write(buffer, 0, count); for (uint index = 0; (long)index < (long)count; ++index) { _zfe.Crc32 = ZipStorer.CrcTable[((int)_zfe.Crc32 ^ (int)buffer[(int)index]) & (int)byte.MaxValue] ^ _zfe.Crc32 >> 8; } } }while (count == buffer.Length); stream.Flush(); if (_zfe.Method == BlueStacks.BlueStacksUI.Compression.Deflate) { stream.Dispose(); } _zfe.Crc32 ^= uint.MaxValue; _zfe.FileSize = num; _zfe.CompressedSize = (uint)(this.ZipFileStream.Position - position1); if (_zfe.Method != BlueStacks.BlueStacksUI.Compression.Deflate || this.ForceDeflating || (!_source.CanSeek || _zfe.CompressedSize <= _zfe.FileSize)) { return; } _zfe.Method = BlueStacks.BlueStacksUI.Compression.Store; this.ZipFileStream.Position = position1; this.ZipFileStream.SetLength(position1); _source.Position = position2; this.Store(ref _zfe, _source); }
private void ReadResponseAsByte(WebResponse resp, CancellationToken token, Stream outputStream = null) { using (Stream responseStream = resp.GetResponseStream()) { var buffer = new byte[65536]; int bytesRead; while (responseStream != null && (bytesRead = responseStream.Read(buffer, 0, buffer.Length)) > 0) { token.ThrowIfCancellationRequested(); outputStream?.Write(buffer, 0, bytesRead); } } }
/// <summary> /// CopyStream simply copies 'fromStream' to 'toStream' /// </summary> public static int CopyStream(Stream fromStream, Stream toStream) { byte[] buffer = new byte[8192]; int totalBytes = 0; for (; ; ) { int count = fromStream.Read(buffer, 0, buffer.Length); if (count == 0) break; toStream.Write(buffer, 0, count); totalBytes += count; } return totalBytes; }
void LogEntryWrite(LogEntry entry) { try { lock (logStream) { logStream?.Write(entry); logStream?.Flush(); } } catch (Exception e) { logEntryWriteException = e; } }
/// <summary> /// Encodes a single uint data point. /// </summary> /// <param name="stream">Stream used to capture encoded bytes.</param> /// <param name="value">The value to encode.</param> /// <returns>Number of bytes used for encoding.</returns> public int Encode(Stream stream, uint value) { int count = 0, index = 0; byte[] buffer = new byte[8]; do { buffer[index++] = (byte)((value & 0x7F) | 0x80); // read first 7-bits, and check for MSB set value >>= 7; // shift right 7 bits count++; // increment bytes written counter } while (value != 0); buffer[index - 1] &= 0x7F; // mark last byte MSB low since we're done // write data and return length stream.Write(buffer, 0, count); return count; }
public void Send(Packet data) { if (Stream == null || !_socket.Connected) { return; } Task.Run( // Initiate the sender thread () => { try { byte[] buffer = data.SerializePacket(); Stream?.Write(buffer, 0, buffer.Length); DataSent?.Invoke(this, data); } catch (Exception ex) { ConnectionLost?.Invoke(this, ex); } } ); }
public static void CopyTo(this Stream source, Stream destination, long start, long length, Action chunkAction) { var end = start + length; source.Seek(start, SeekOrigin.Begin); var bytesRemaining = end - source.Position; var buffer = new byte[ReadStreamBufferSize]; while (bytesRemaining > 0) { var bytesRead = source.Read(buffer, 0, bytesRemaining > ReadStreamBufferSize ? ReadStreamBufferSize : (int) bytesRemaining); if (bytesRead == 0) break; destination.Write(buffer, 0, bytesRead); chunkAction(); bytesRemaining = end - source.Position; } }
static void DecompressStream(Stream from, Stream to) { byte[] src = new byte[from.Length]; // read file if (from.Read(src, 0, src.Length) == src.Length) { int dstSize = DllInterface.aPsafe_get_orig_size(src); // allocate mem byte[] dst = new byte[dstSize]; // decompress data int depackedSize = DllInterface.aPsafe_depack(src, src.Length, dst, dstSize); // write compressed data to.Write(dst, 0, depackedSize); Console.WriteLine("decompressed to {0} bytes", depackedSize); } }
public void Write( byte[] buffer, int count) { _target?.Write(buffer, 0, count); if (_target is FileStream fs) { // force disk flush to better reflect // progress, esp across network shares // also caching here in the case of // device-to-device where the user is // likely to want to to remove the target // simply means having to wait for sync // at target dismount / eject fs.Flush(true); } else { _target?.Flush(); } }
public bool ReadResponse(Stream dataOut, out int bytesRead, ICallback callback) { callback.Dispose(); var buffer = new byte[dataOut.Length]; if (_resourceIsCached) { bytesRead = _fileReadStream.Read(buffer, 0, buffer.Length); dataOut.Write(buffer, 0, buffer.Length); return(bytesRead > 0); } bytesRead = _httpStream.Read(buffer, 0, buffer.Length); dataOut.Write(buffer, 0, buffer.Length); _fileWriteStream?.Write(buffer, 0, buffer.Length); return(bytesRead > 0); }
static int writeAmfType(Stream stream, byte b) { byte[] bytes = new byte[] { b }; stream?.Write(bytes, 0, bytes.Length); return(bytes.Length); }
private void ReadResponseAsByte(WebResponse resp, CancellationToken token, Stream outputStream = null, long contentLength = 0, OperationType operation = OperationType.None) { if (!Enum.IsDefined(typeof(OperationType), operation)) { throw new ArgumentOutOfRangeException(nameof(operation)); } if (outputStream != null && (contentLength != 0 && outputStream.Position == 0)) { //this.OnChangedProgressPercent(new ProgressChangedEventArgs( // 0, // new ProgressChangeTaskState() // { // Type = operation, // TotalBytes = new FileSize() // { // DefaultValue = contentLength // }, // BytesInProgress = new FileSize() // { // DefaultValue = 0L // } // })); } int bufSizeChunk = 30000; int totalBufSize = bufSizeChunk; byte[] fileBytes = new byte[totalBufSize]; double percentComplete = 0; int totalBytesRead = 0; using (var reader = new BinaryReader(resp.GetResponseStream())) { int bytesRead; while ((bytesRead = reader.Read(fileBytes, totalBytesRead, totalBufSize - totalBytesRead)) > 0) { token.ThrowIfCancellationRequested(); outputStream?.Write(fileBytes, totalBytesRead, bytesRead); totalBytesRead += bytesRead; if ((totalBufSize - totalBytesRead) == 0) { totalBufSize += bufSizeChunk; Array.Resize(ref fileBytes, totalBufSize); } if (outputStream != null && (contentLength != 0 && contentLength >= outputStream.Position)) { var tempPercentComplete = 100.0 * outputStream.Position / contentLength; if (tempPercentComplete - percentComplete >= 1) { //percentComplete = tempPercentComplete; //this.OnChangedProgressPercent(new ProgressChangedEventArgs( // (int)percentComplete, // new ProgressChangeTaskState() // { // Type = operation, // TotalBytes = new FileSize() // { // DefaultValue = contentLength // }, // BytesInProgress = new FileSize() // { // DefaultValue = outputStream.Position // } // })); } } } if (outputStream != null && (contentLength != 0 && outputStream.Position == contentLength)) { //this.OnChangedProgressPercent(new ProgressChangedEventArgs( // 100, // new ProgressChangeTaskState() // { // Type = operation, // TotalBytes = new FileSize() // { // DefaultValue = contentLength // }, // BytesInProgress = new FileSize() // { // DefaultValue = outputStream.Position // } // })); } } }
public IList Write(IList content) { if (Stream == null) { CreateStreams(); } if (content.Count <= 0) { return(content); } if (content[0] is PSObject) { content = content.BaseArray(); } if (content[0] is string) { if (encoder == null) { encoder = Encoding.UTF8.GetEncoder(); } foreach (string str in content) { var chars = (str + "\n").ToCharArray(); var numBytes = encoder.GetByteCount(chars, 0, chars.Length, false); var bytes = new byte[Math.Min(numBytes, ByteBufferSize)]; var convertedChars = 0; var completed = false; while (!completed) { int charsUsed; int bytesUsed; encoder.Convert(chars, convertedChars, chars.Length - convertedChars, bytes, 0, bytes.Length, false, out charsUsed, out bytesUsed, out completed); convertedChars += charsUsed; Stream?.Write(bytes, 0, bytesUsed); } } } else if (content[0] is byte) { var bytes = content as byte[] ?? content.Cast <byte>().ToArray(); var bytesWritten = 0; while (bytesWritten < bytes.Length) { var written = Math.Min(bytes.Length - bytesWritten, ByteBufferSize); Stream?.Write(bytes, bytesWritten, written); bytesWritten += written; } } else { throw new ArgumentOutOfRangeException(nameof(content)); } return(content); }
public override void Write(byte[] buffer, int offset, int count) { _stream?.Write(buffer, offset, count); }
/// <summary> /// Writes a given <seealso cref="IHtmlContent"/> instance to another stream. /// </summary> /// <param name="htmlContent"></param> /// <param name="stream"></param> public static void WriteTo(this IHtmlContent htmlContent, Stream stream) { var bytes = Encoding.UTF8.GetBytes(htmlContent.Render()); stream?.Write(bytes, 0, bytes.Length); }