InputBuffer.cs source code in C# .NET

                        
Code:
                         / Dotnetfx_Win7_3.5.1 / Dotnetfx_Win7_3.5.1 / 3.5.1 / DEVDIV / depot / DevDiv / releases / whidbey / NetFXspW7 / ndp / fx / src / Sys / System / IO / compression / InputBuffer.cs / 1 / InputBuffer.cs
                        

                        
                             
namespace System.IO.Compression
{
    using System;
    using System.Diagnostics; 

    // This class can be used to read bits from an byte array quickly. 
    // Normally we get bits from 'bitBuffer' field and bitsInBuffer stores 
    // the number of bits available in 'BitBuffer'.
    // When we used up the bits in bitBuffer, we will try to get byte from 
    // the byte array and copy the byte to appropiate position in bitBuffer.
    //
    // The byte array is not reused. We will go from 'start' to 'end'.
    // When we reach the end, most read operations will return -1, 
    // which means we are running out of input.
 
    internal class InputBuffer { 

        private byte[] buffer;           // byte array to store input 
        private int start;               // start poisition of the buffer
        private int end;                 // end position of the buffer
        private uint bitBuffer = 0;      // store the bits here, we can quickly shift in this buffer
        private int bitsInBuffer = 0;    // number of bits available in bitBuffer 

        // Total bits available in the input buffer 
        public int AvailableBits { 
            get{
                return bitsInBuffer; 
            }
        }

        // Total bytes available in the input buffer 
        public int AvailableBytes {
            get{ 
                return(end - start)  + (bitsInBuffer / 8); 
            }
        } 

        // Ensure that count bits are in the bit buffer.
        // Returns false if input is not sufficient to make this true.
        // Count can be up to 16. 
        public bool EnsureBitsAvailable(int count) {
            Debug.Assert( 0 < count && count <= 16, "count is invalid."); 
 
            // manual inlining to improve perf
            if (bitsInBuffer < count) { 
                if (NeedsInput()) {
                    return false;
                }
                // insert a byte to bitbuffer 
                bitBuffer |= (uint)buffer[start++] << bitsInBuffer;
                bitsInBuffer += 8; 
 
                if (bitsInBuffer < count) {
                    if (NeedsInput()) { 
                        return false;
                    }
                    // insert a byte to bitbuffer
                    bitBuffer |= (uint)buffer[start++] << bitsInBuffer; 
                    bitsInBuffer += 8;
                } 
            } 

            return true; 
        }

        // This function will try to load 16 or more bits into bitBuffer.
        // It returns whatever is contained in bitBuffer after loading. 
        // The main difference between this and GetBits is that this will
        // never return -1. So the caller needs to check AvailableBits to 
        // see how many bits are available. 
        public uint TryLoad16Bits() {
            if(bitsInBuffer < 8) { 
                if( start < end) {
                    bitBuffer |= (uint)buffer[start++] << bitsInBuffer;
                    bitsInBuffer += 8;
                } 

                if( start < end) { 
                    bitBuffer |= (uint)buffer[start++] << bitsInBuffer; 
                    bitsInBuffer += 8;
                } 
            }
            else if(bitsInBuffer < 16) {
                if( start < end) {
                    bitBuffer |= (uint)buffer[start++] << bitsInBuffer; 
                    bitsInBuffer += 8;
                } 
            } 

            return bitBuffer; 
        }

        private uint GetBitMask(int count) {
            return ((uint)1 << count) - 1; 
        }
 
        // Gets count bits from the input buffer. Returns -1 if not enough bits available. 
        public int GetBits(int count) {
            Debug.Assert( 0 < count && count <= 16, "count is invalid."); 

            if ( !EnsureBitsAvailable(count) ) {
                return -1;
            } 

            int result = (int)(bitBuffer & GetBitMask(count)); 
            bitBuffer >>= count; 
            bitsInBuffer -= count;
            return result; 
        }

        /// Copies length bytes from input buffer to output buffer starting
        /// at output[offset].  You have to make sure, that the buffer is 
        /// byte aligned.  If not enough bytes are available, copies fewer
        /// bytes. 
        /// Returns the number of bytes copied, 0 if no byte is available. 
        public int CopyTo(byte[] output, int offset, int length) {
            Debug.Assert( output != null, ""); 
            Debug.Assert( offset >=0 , "");
            Debug.Assert( length >=0 , "");
            Debug.Assert( offset <= output.Length - length, "");
            Debug.Assert( (bitsInBuffer % 8) ==0, ""); 

            // Copy the bytes in bitBuffer first. 
            int bytesFromBitBuffer = 0; 
            while (bitsInBuffer > 0 && length > 0) {
                output[offset++] = (byte) bitBuffer; 
                bitBuffer >>= 8;
                bitsInBuffer -= 8;
                length--;
                bytesFromBitBuffer++; 
            }
 
            if (length == 0) { 
                return bytesFromBitBuffer;
            } 

            int avail = end - start;
            if (length > avail) {
                length = avail; 
            }
 
            Array.Copy(buffer, start, output, offset, length); 
            start += length;
            return bytesFromBitBuffer + length; 
        }

        // Return true is all input bytes are used.
        // This means the caller can call SetInput to add more input. 
        public bool NeedsInput() {
            return start == end; 
        } 

        // Set the byte array to be processed. 
        // All the bits remained in bitBuffer will be processed before the new bytes.
        // We don't clone the byte array here since it is expensive.
        // The caller should make sure after a buffer is passed in.
        // It will not be changed before calling this function again. 

        public void SetInput(byte[] buffer, int offset, int length) { 
            Debug.Assert( buffer != null, ""); 
            Debug.Assert( offset >=0 , "");
            Debug.Assert( length >=0 , ""); 
            Debug.Assert( offset <= buffer.Length - length, "");
            Debug.Assert( start == end, "");

            this.buffer = buffer; 
            start = offset;
            end = offset + length; 
        } 

        // Skip n bits in the buffer 
        public void SkipBits(int n) {
            Debug.Assert(bitsInBuffer >= n, "No enough bits in the buffer, Did you call EnsureBitsAvailable?");
            bitBuffer >>= n;
            bitsInBuffer -= n; 
        }
 
        // Skips to the next byte boundary. 
        public void SkipToByteBoundary() {
            bitBuffer >>= (bitsInBuffer % 8); 
            bitsInBuffer = bitsInBuffer - (bitsInBuffer % 8);
        }
    }
} 


// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
 
namespace System.IO.Compression
{
    using System;
    using System.Diagnostics; 

    // This class can be used to read bits from an byte array quickly. 
    // Normally we get bits from 'bitBuffer' field and bitsInBuffer stores 
    // the number of bits available in 'BitBuffer'.
    // When we used up the bits in bitBuffer, we will try to get byte from 
    // the byte array and copy the byte to appropiate position in bitBuffer.
    //
    // The byte array is not reused. We will go from 'start' to 'end'.
    // When we reach the end, most read operations will return -1, 
    // which means we are running out of input.
 
    internal class InputBuffer { 

        private byte[] buffer;           // byte array to store input 
        private int start;               // start poisition of the buffer
        private int end;                 // end position of the buffer
        private uint bitBuffer = 0;      // store the bits here, we can quickly shift in this buffer
        private int bitsInBuffer = 0;    // number of bits available in bitBuffer 

        // Total bits available in the input buffer 
        public int AvailableBits { 
            get{
                return bitsInBuffer; 
            }
        }

        // Total bytes available in the input buffer 
        public int AvailableBytes {
            get{ 
                return(end - start)  + (bitsInBuffer / 8); 
            }
        } 

        // Ensure that count bits are in the bit buffer.
        // Returns false if input is not sufficient to make this true.
        // Count can be up to 16. 
        public bool EnsureBitsAvailable(int count) {
            Debug.Assert( 0 < count && count <= 16, "count is invalid."); 
 
            // manual inlining to improve perf
            if (bitsInBuffer < count) { 
                if (NeedsInput()) {
                    return false;
                }
                // insert a byte to bitbuffer 
                bitBuffer |= (uint)buffer[start++] << bitsInBuffer;
                bitsInBuffer += 8; 
 
                if (bitsInBuffer < count) {
                    if (NeedsInput()) { 
                        return false;
                    }
                    // insert a byte to bitbuffer
                    bitBuffer |= (uint)buffer[start++] << bitsInBuffer; 
                    bitsInBuffer += 8;
                } 
            } 

            return true; 
        }

        // This function will try to load 16 or more bits into bitBuffer.
        // It returns whatever is contained in bitBuffer after loading. 
        // The main difference between this and GetBits is that this will
        // never return -1. So the caller needs to check AvailableBits to 
        // see how many bits are available. 
        public uint TryLoad16Bits() {
            if(bitsInBuffer < 8) { 
                if( start < end) {
                    bitBuffer |= (uint)buffer[start++] << bitsInBuffer;
                    bitsInBuffer += 8;
                } 

                if( start < end) { 
                    bitBuffer |= (uint)buffer[start++] << bitsInBuffer; 
                    bitsInBuffer += 8;
                } 
            }
            else if(bitsInBuffer < 16) {
                if( start < end) {
                    bitBuffer |= (uint)buffer[start++] << bitsInBuffer; 
                    bitsInBuffer += 8;
                } 
            } 

            return bitBuffer; 
        }

        private uint GetBitMask(int count) {
            return ((uint)1 << count) - 1; 
        }
 
        // Gets count bits from the input buffer. Returns -1 if not enough bits available. 
        public int GetBits(int count) {
            Debug.Assert( 0 < count && count <= 16, "count is invalid."); 

            if ( !EnsureBitsAvailable(count) ) {
                return -1;
            } 

            int result = (int)(bitBuffer & GetBitMask(count)); 
            bitBuffer >>= count; 
            bitsInBuffer -= count;
            return result; 
        }

        /// Copies length bytes from input buffer to output buffer starting
        /// at output[offset].  You have to make sure, that the buffer is 
        /// byte aligned.  If not enough bytes are available, copies fewer
        /// bytes. 
        /// Returns the number of bytes copied, 0 if no byte is available. 
        public int CopyTo(byte[] output, int offset, int length) {
            Debug.Assert( output != null, ""); 
            Debug.Assert( offset >=0 , "");
            Debug.Assert( length >=0 , "");
            Debug.Assert( offset <= output.Length - length, "");
            Debug.Assert( (bitsInBuffer % 8) ==0, ""); 

            // Copy the bytes in bitBuffer first. 
            int bytesFromBitBuffer = 0; 
            while (bitsInBuffer > 0 && length > 0) {
                output[offset++] = (byte) bitBuffer; 
                bitBuffer >>= 8;
                bitsInBuffer -= 8;
                length--;
                bytesFromBitBuffer++; 
            }
 
            if (length == 0) { 
                return bytesFromBitBuffer;
            } 

            int avail = end - start;
            if (length > avail) {
                length = avail; 
            }
 
            Array.Copy(buffer, start, output, offset, length); 
            start += length;
            return bytesFromBitBuffer + length; 
        }

        // Return true is all input bytes are used.
        // This means the caller can call SetInput to add more input. 
        public bool NeedsInput() {
            return start == end; 
        } 

        // Set the byte array to be processed. 
        // All the bits remained in bitBuffer will be processed before the new bytes.
        // We don't clone the byte array here since it is expensive.
        // The caller should make sure after a buffer is passed in.
        // It will not be changed before calling this function again. 

        public void SetInput(byte[] buffer, int offset, int length) { 
            Debug.Assert( buffer != null, ""); 
            Debug.Assert( offset >=0 , "");
            Debug.Assert( length >=0 , ""); 
            Debug.Assert( offset <= buffer.Length - length, "");
            Debug.Assert( start == end, "");

            this.buffer = buffer; 
            start = offset;
            end = offset + length; 
        } 

        // Skip n bits in the buffer 
        public void SkipBits(int n) {
            Debug.Assert(bitsInBuffer >= n, "No enough bits in the buffer, Did you call EnsureBitsAvailable?");
            bitBuffer >>= n;
            bitsInBuffer -= n; 
        }
 
        // Skips to the next byte boundary. 
        public void SkipToByteBoundary() {
            bitBuffer >>= (bitsInBuffer % 8); 
            bitsInBuffer = bitsInBuffer - (bitsInBuffer % 8);
        }
    }
} 


// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.

                        

                        

                        
                        

Link Menu

This book is available now!
Buy at Amazon US or
Buy at Amazon UK

• RestrictedTransactionalPackage.cs
• ControlBuilder.cs
• CrossContextChannel.cs
• SimpleWorkerRequest.cs
• MaterialGroup.cs
• Icon.cs
• ResolvedKeyFrameEntry.cs
• NavigationHelper.cs
• CompositeControl.cs
• TransactionManager.cs
• ListView.cs
• WebControlsSection.cs
• CfgSemanticTag.cs
• DbDataSourceEnumerator.cs
• FileDataSourceCache.cs
• OSFeature.cs
• DBConnectionString.cs
• LinearKeyFrames.cs
• LockRecursionException.cs
• DesignerForm.cs
• BaseAsyncResult.cs
• UpdatePanelControlTrigger.cs
• RangeBase.cs
• IResourceProvider.cs
• Padding.cs
• SqlCommandBuilder.cs
• WebPart.cs
• MessageSmuggler.cs
• EntityContainerEmitter.cs
• FrameworkContentElement.cs
• AuthorizationSection.cs
• FileRecordSequence.cs
• MdiWindowListStrip.cs
• WebPartUserCapability.cs
• SynchronizationHandlesCodeDomSerializer.cs
• CategoryGridEntry.cs
• SeekStoryboard.cs
• UniqueConstraint.cs
• SerializationStore.cs
• CodeTypeReferenceExpression.cs
• ToolStripItemClickedEventArgs.cs
• XsdBuildProvider.cs
• GridViewColumnCollectionChangedEventArgs.cs
• RunWorkerCompletedEventArgs.cs
• HTMLTextWriter.cs
• DispatchWrapper.cs
• InputLanguageManager.cs
• MissingMethodException.cs
• MessageAction.cs
• SystemUdpStatistics.cs
• FragmentNavigationEventArgs.cs
• TabPageDesigner.cs
• UserNameSecurityTokenAuthenticator.cs
• StreamInfo.cs
• ExtendLockAsyncResult.cs
• TextTrailingWordEllipsis.cs
• FixedHyperLink.cs
• OutOfProcStateClientManager.cs
• WebPartEditorCancelVerb.cs
• WebBrowserDocumentCompletedEventHandler.cs
• PlaceHolder.cs
• TogglePatternIdentifiers.cs
• ObjectTypeMapping.cs
• UnionExpr.cs
• BrowserCapabilitiesCompiler.cs
• UpdateException.cs
• Int32Collection.cs
• SrgsOneOf.cs
• DataGridViewCellLinkedList.cs
• FlowLayoutSettings.cs
• OdbcParameterCollection.cs
• SystemWebSectionGroup.cs
• WebResponse.cs
• TextWriter.cs
• FileEnumerator.cs
• RepeaterItem.cs
• DataListItemEventArgs.cs
• AssemblyCache.cs
• CodeEntryPointMethod.cs
• DependencyObjectPropertyDescriptor.cs
• ArgumentNullException.cs
• IpcManager.cs
• ObsoleteAttribute.cs
• HttpHandlerActionCollection.cs
• DoubleCollectionValueSerializer.cs
• InputEventArgs.cs
• ComponentManagerBroker.cs
• AspNetSynchronizationContext.cs
• ParentControlDesigner.cs
• ConcurrentStack.cs
• FactoryMaker.cs
• UrlPath.cs
• CommonDialog.cs
• FontDialog.cs
• dataobject.cs
• JsonUriDataContract.cs
• TextTreeText.cs
• WsatConfiguration.cs
• ErrorEventArgs.cs
• DesignerTextWriter.cs