public SlurpBlock ( byte block, int offset, int count ) : void | ||
block | byte | block of bytes to slurp |
offset | int | starting point in the block |
count | int | how many bytes within the block to slurp |
return | void |
/// <summary> /// Read from the stream /// </summary> /// <param name="buffer">the buffer to read</param> /// <param name="offset">the offset at which to start</param> /// <param name="count">the number of bytes to read</param> /// <returns>the number of bytes actually read</returns> public override int Read(byte[] buffer, int offset, int count) { int bytesToRead = count; // Need to limit the # of bytes returned, if the stream is intended to have // a definite length. This is especially useful when returning a stream for // the uncompressed data directly to the application. The app won't // necessarily read only the UncompressedSize number of bytes. For example // wrapping the stream returned from OpenReader() into a StreadReader() and // calling ReadToEnd() on it, We can "over-read" the zip data and get a // corrupt string. The length limits that, prevents that problem. if (_lengthLimit != CrcCalculatorStream.UnsetLengthLimit) { if (_Crc32.TotalBytesRead >= _lengthLimit) { return(0); // EOF } Int64 bytesRemaining = _lengthLimit - _Crc32.TotalBytesRead; if (bytesRemaining < count) { bytesToRead = (int)bytesRemaining; } } int n = _innerStream.Read(buffer, offset, bytesToRead); if (n > 0) { _Crc32.SlurpBlock(buffer, offset, n); } return(n); }
// workitem 7813 - totally unnecessary // public override void WriteByte(byte b) // { // _buf1[0] = (byte)b; // // workitem 7159 // if (crc != null) // crc.SlurpBlock(_buf1, 0, 1); // Write(_buf1, 0, 1); // } public override void Write(System.Byte[] buffer, int offset, int count) { // workitem 7159 // calculate the CRC on the unccompressed data (before writing) if (crc != null) { crc.SlurpBlock(buffer, offset, count); } if (_streamMode == StreamMode.Undefined) { _streamMode = StreamMode.Writer; } else if (_streamMode != StreamMode.Writer) { throw new ZlibException("Cannot Write after Reading."); } if (count == 0) { return; } // first reference of z property will initialize the private var _z z.InputBuffer = buffer; _z.NextIn = offset; _z.AvailableBytesIn = count; bool done = false; do { _z.OutputBuffer = workingBuffer; _z.NextOut = 0; _z.AvailableBytesOut = _workingBuffer.Length; //int rc = (_wantCompress) // ? _z.Deflate(_flushMode) // : _z.Inflate(_flushMode); int rc = _z.Inflate(_flushMode); if (rc != ZlibConstants.Z_OK && rc != ZlibConstants.Z_STREAM_END) { throw new ZlibException("inflating: " + _z.Message); } _stream.Write(_workingBuffer, 0, _workingBuffer.Length - _z.AvailableBytesOut); done = _z.AvailableBytesIn == 0 && _z.AvailableBytesOut != 0; // If GZIP and de-compress, we're done when 8 bytes remain. if (_flavor == ZlibStreamFlavor.GZIP) { done = (_z.AvailableBytesIn == 8 && _z.AvailableBytesOut != 0); } }while (!done); }