Bitstream

A bitstream (or bit stream), also known as binary sequence, is a sequence of bits.

For other uses, see Bitstream (disambiguation).

A bytestream is a sequence of bytes. Typically, each byte is an 8-bit quantity, and so the term octet stream is sometimes used interchangeably. An octet may be encoded as a sequence of 8 bits in multiple different ways (see bit numbering) so there is no unique and direct translation between bytestreams and bitstreams.

Bitstreams and bytestreams are used extensively in telecommunications and computing. For example, synchronous bitstreams are carried by SONET, and Transmission Control Protocol transports an asynchronous bytestream.

Relationship between bitstreams and bytestreams

In practice, bitstreams are not used directly to encode bytestreams; a communication channel may use a signalling method that does not directly translate to bits (for instance, by transmitting signals of multiple frequencies) and typically also encodes other information such as framing and error correction together with its data.

Examples

The term bitstream is frequently used to describe the configuration data to be loaded into a field-programmable gate array (FPGA). Although most FPGAs also support a byte-parallel loading method as well, this usage may have originated based on the common method of configuring the FPGA from a serial bit stream, typically from a serial PROM or flash memory chip. The detailed format of the bitstream for a particular FPGA is typically proprietary to the FPGA vendor.

In mathematics, several specific infinite sequences of bits have been studied for their mathematical properties; these include the Baum–Sweet sequence, Ehrenfeucht–Mycielski sequence, Fibonacci word, Kolakoski sequence, regular paperfolding sequence, Rudin–Shapiro sequence, and Thue–Morse sequence.

On most operating systems, including Unix-like and Windows, standard I/O libraries convert lower-level paged or buffered file access to a bytestream paradigm. In particular in Unix-like operating systems, each process has three standard streams, that are examples of unidirectional bytestreams. The Unix pipe mechanism provides bytestream communications between different processes.

Compression algorithms often code in bitstreams, as the 8 bits offered by a byte (the smallest addressable unit of memory) may be wasteful. Although typically implemented in low-level languages, some high-level languages such as Python[1] and Java[2] offer native interfaces for bitstream I/O.

One well-known example of a communication protocol which provides a byte-stream service to its clients is the Transmission Control Protocol (TCP) of the Internet protocol suite, which provides a bidirectional bytestream.

The Internet media type for an arbitrary bytestream is application/octet-stream. Other media types are defined for bytestreams in well-known formats.

Flow control

Often the contents of a bytestream are dynamically created, such as the data from the keyboard and other peripherals (/dev/tty), data from the pseudorandom number generator (/dev/urandom), etc.

In those cases, when the destination of a bytestream (the consumer) uses bytes faster than they can be generated, the system uses process synchronization to make the destination wait until the next byte is available.

When bytes are generated faster than the destination can use them, there are several techniques to deal with the situation:

  • When the producer is a software algorithm, the system pauses the producer with the same process synchronization techniques.
  • When the producer supports flow control, the system only sends the ready signal when the consumer is ready for the next byte.
  • When the producer can't be paused—it is a keyboard or some hardware that doesn't support flow control—the system typically attempts to temporarily store the data until the consumer is ready for it, typically using a queue. Often the receiver can empty the buffer before it gets completely full. A producer that continues to produce data faster than it can be consumed, even after the buffer is full, leads to unwanted buffer overflow, packet loss, network congestion, and denial of service.
gollark: ```fsharpprintfn "Hacked with %s" "F#"```
gollark: ```pythonprint("Hacked with python 3")```
gollark: ```print "Hacked with Python 2 or Lua"```
gollark: (produced by the common Unix tool `haxxdump`)
gollark: 011d3b0 ecda fe42 f33d d112 2b8c 7e1d 24d2 11e5011d3c0 2475 ae6a bb0f 0c59 592b 3e75 6074 5f61011d3d0 ff42 a907 c773 c81f 3095 97ba 7fe2 5270011d3e0 c021 d886 1dfc 01eb f22a 0174 38cb ab3e011d3f0 2476 6efa 2bb0 6dde cd92 0222 5467 7221011d400 bb13 2647 77f7 8c51 6206 e40d 3c85 117c011d410 86bb 928f 2234 bb31 298e dd89 7209 6a00011d420 49b1 182b 52fc 6659 f720 c14c 7064 213c011d430 be13 5b7f 36db 9228 232a be39 1c9e 4065011d440 3e92 3fa8 a538 8a60 c599 7c88 9f72 9748011d450 8a5d fc83 b21b e48d 666a 8670 3d61 0225

See also

References
  1. "Bitstream". Python Software Foundation. Archived from the original on 2016-09-08.
  2. "Class BitSet". Oracle. Archived from the original on 2016-11-30.
This article is issued from Wikipedia. The text is licensed under Creative Commons - Attribution - Sharealike. Additional terms may apply for the media files.