Blitter

A blitter is a circuit, sometimes as a coprocessor or a logic block on a microprocessor, dedicated to the rapid movement and modification of data within a computer's memory. A blitter can copy large quantities of data from one memory area to another relatively quickly, and in parallel with the CPU, while freeing up the CPU's more complex capabilities for other operations. A typical use for a blitter is the movement of a bitmap, such as windows and icons in a graphical user interface or images and backgrounds in a 2D video game.

The name comes from the bit blit operation of the 1973 Xerox Alto,[1] which stands for bit-block transfer.[2] A blit operation is more than a memory copy, because it can involve data that's not byte aligned (hence the bit in bit blit), handling transparent pixels (pixels which should not overwrite the destination), and various ways of combining the source and destination data.

Blitters have largely been superseded by programmable graphics processing units.

## Contents

* 1 History
* 1.1 Blitters in computers and video games
* 2 Operation
* 3 Other approaches
* 4 See also
* 5 References

## History

In computers without hardware accelerated raster graphics, which includes most 1970s and 1980s home computers and IBM PC compatibles through the mid-1990s, the frame buffer is commonly stored in CPU-accessible memory. Drawing is accomplished by updating the frame buffer via software.

For fundamental graphics routines, like compositing a smaller image into a larger one (such as for a video game) or drawing a filled rectangle, large amounts of memory need to be manipulated, and many cycles are spent fetching and decoding short loops of load/store instructions. Some systems of the era had dedicated hardware to offload this task from software, mostly in the form of sprites or dedicated text drawing systems, but these largely disappeared from later machines as the market turned increasingly to business applications in the 1980s.

In order to reduce the amount of memory needed for the frame buffer, systems generally offered a variety of graphics modes that reduced the resolution or number of colors that can be displayed. For instance, a black and white display requires only one bit per pixel to define whether that pixels is black or white, and therefore can be packed with eight pixels worth of data in a single byte. This complicates updating the display; if a single pixel is being changed, the byte has to be read, the correct bit for that pixel updated, and then written back out. Manipulating packed pixels requires extra shifting and masking operations in the CPU.

Blitters were developed to offload repetitive tasks of copying data or filling blocks of memory faster than possible by the CPU. This can be done in parallel with the CPU and also handle special cases which would be significantly slower if coded by hand, such as skipping over pixels marked as transparent or handling data that isn't byte-aligned.

### Blitters in computers and video games

1973: The Xerox Alto, where the term bit blit originated, has a bit block transfer instruction implemented in microcode, making it much faster than the same operation written on the CPU.[1] The microcode was implemented by Dan Ingalls.[1]

1978: The Bally Astrocade home console has primitive blitter hardware.[3]

1982: In addition to drawing shape primitives, the NEC μPD7220 video display processor can transfer rectangular bitmaps to display memory via direct memory access and fill rectangular portions of the screen.[4][5] The design was licensed by Intel and sold as the 82720 graphics display controller.

1982: The Software:Robotron: 2084 arcade video game from Williams Electronics includes two blitter chips which allow the game to have up to 80 simultaneously moving objects.[6] Performance was measured at roughly 910 KB/second.[6] The blitter operates on 4-bit (16 color) pixels where color 0 is transparent, allowing for non-rectangular shapes.[7] Williams used the same hardware in other games from the time period, including Sinistar and Joust.[7]

1984: The MS-DOS compatible Mindset personal computer contains a custom VLSI chip to move rectangular sections of a bitmap. The hardware handles transparency and eight modes for combining the source and destination data.[8] The Mindset was claimed to have graphics up to 50x faster than IBM PC compatibles of the time,[9] but the system was not successful.

1985: One of the coprocessors in the Amiga personal computer is a blitter. The first US patent filing to use the term blitter was "Personal computer apparatus for block transfer of bit-mapped image data," assigned to Commodore-Amiga, Inc.[10] The blitter performs an arbitrary Boolean operation on three bit vectors of size 16:

`destination := op(source A, source B, source C)`

1986: The TMS34010 is a general purpose 32-bit processor with built-in instructions, including `PIXBLT` (Pixel Block Transfer), for manipulating bitmap data. It is optimized for cases that would take extra processing if implemented in software, such as handling transparent pixels, working with non-byte aligned data, and converting between bit depths. `PIXBLT` provides 22 ways of combining the source and destination data.[11] The TMS34010 serves as both CPU and GPU for a number of arcade games starting in 1988 with Narc and including Hard Drivin', Smash TV, Mortal Kombat, and NBA Jam,[12] It was also used in graphics accelerator boards in the 1990s.

1987: The IBM 8514/A display adapter, introduced with the IBM Personal System/2 computers in April 1987, includes bit block transfer hardware.[13]

Atari ST BLiTTER chip

1987: The Atari Mega ST 2 ships with a blitter chip.[14] Officially called the "Atari ST Bit-Block Transfer Processor", stylized as BLiTTER, it provides 16 options for merging source and destination data.[15] The blitter is supported on most subsequent ST machines.

1989: The short-lived Atari Transputer Workstation contains blitter hardware as part of its (Mega ST-based) "Blossom" video system.[16]

1989: The Atari Lynx color handheld game system has a custom blitter with scaling and distortion effects.

1993: The Atari Jaguar game console has blitter hardware as part of the custom "Tom" chip.[17]

1996: The VESA Group introduced a standardized way to access features like hardware Bit Block transfers with VBE/accelerator functions (VBE/AF) on IBM PC compatibles.

## Operation

Sprites (left) and associated masks

Typically, a computer program puts information into certain hardware registers describing what memory transfer needs to be completed and the logical operations to perform on the data. The CPU then triggers the blitter to begin operating. The CPU is free for other processing while the blitter is working, though the blit running in parallel uses memory bandwidth.

To copy data with fully transparent pixels—such as sprites—some hardware allows a specific pixel value to be ignored, such as color 0, during the blit. Those pixels are not written to the destination.

Another approach on some systems is to have a second 1 bit per pixel image used as a mask to indicate which pixels to transfer and which to leave untouched. The mask operates like a stencil. The logical operation is:

`destination := (background AND NOT mask) OR sprite`

## Other approaches

Main article: Sprite (computer graphics)

Hardware sprites are small bitmaps which can be positioned independently and are composited together with the background on-the-fly by the video chip. The frame buffer is not modified.[18] The downside of sprites is a limit of moving graphics per scanline, which can range from three (Atari 2600) to eight (Commodore 64 and Atari 8-bit computers) to significantly higher for 16-bit consoles and arcade hardware (the Neo Geo can display 96 sprites per line). The inability to update a permanent bitmap makes them unsuitable for general desktop GUI acceleration.

## See also

* Direct memory access (DMA)

## References

1. ↑ 1.0 1.1 1.2 Shirriff, Ken. "Restoring YCombinator's Xerox Alto day 5: Microcode tracing with a logic analyzer". http://www.righto.com/2016/09/xerox-alto-restoration-day-5-smoke-and.html.
2. ↑ "BitBlt function". Microsoft. https://msdn.microsoft.com/en-us/library/windows/desktop/dd183370(v=vs.85).aspx.
3. ↑ Squire, Lance. "Bally's Blitter". https://ballyalley.com/ballyalley/articles/bally_blitter.txt.
4. ↑ Peddie, Jon (18 July 2018). "Famous Graphics Chips: NEC μPD7220 Graphics Display Controller". https://www.computer.org/publications/tech-news/chasing-pixels/famous-graphics-chips.
5. ↑ "User's Manual: NEC μPD7220/7220A". NEC Electronics. December 1985. http://bitsavers.org/pdf/nec/uPD7220-uPD7220A_User_Manual_Dec85.pdf.
6. ↑ 6.0 6.1 Wolf, Mark J.P. (June 2012). Before the Crash: Early Video Game History. Wayne State University Press. p. 185. ISBN 9780814334508. https://books.google.com/books?id=oK3D4i5ldKgC&q=early+blitter+hardware&pg=PA185.
7. ↑ 7.0 7.1 Riddle, Sean. "Blitter Information". http://seanriddle.com/blitter.html.
8. ↑ Williams, Gregg (April 1984). "Product Preview: The Mindset Personal Computer". Byte Magazine 9 (4): 278–280. https://archive.org/stream/byte-magazine-1984-04/1984_04_BYTE_09-04_Real-World_Interfacing#page/n270/mode/2up.
9. ↑ Anderson, John J. (February 1985). "Mindset Micro: Pushing the envelope, or whatever happened to innovation?". Creative Computing 11 (2): 50. http://www.atarimagazines.com/creative/v11n2/50_Mindset_micro_pushing_th.php.
10. ↑ "US Patent 4874164 "Personal computer apparatus for block transfer of bit-mapped image data"". https://patents.google.com/patent/US4874164.
11. ↑ Killebrew Jr., Carrell R. (December 1986). "The TMS34010 Graphics System Processor". Byte 11 (13): 204. https://archive.org/details/byte-magazine-1986-12/page/n199/mode/2up.
12. ↑ "Game listing for games running on the TMS34010 processor". http://www.mamedb.com/cpu/TMS34010?start=0.
13. ↑ Necasek, Michael. "The 8514/A Graphics Accelerator". http://www.os2museum.com/wp/the-8514a-graphics-accelerator/.
14. ↑ "Atari Mega ST 2". http://www.computinghistory.org.uk/det/28563/Atari-Mega-ST-2/.
15. ↑ "User Manual for the Atari ST Bit Block Transfer Processor". Atari Corporation. June 17, 1987. https://archive.org/details/User_Manual_for_the_Atari_ST_Bit-Block_Transfer_Processor_BLiTTER_Jun_17_1987/mode/2up.
16. ↑ Rosenthal, Marshal M. (November 1989). "The Transputer Connection: An Exclusive Interview with Perihelion's Dr. Tim King". STart 4 (4). http://www.atarimagazines.com/startv4n4/transputer.html.
17. ↑ "Technical Reference Manual Tom & Jerry". February 2001. pp. 4–5. https://www.hillsoftware.com/files/atari/jaguar/jag_v8.pdf.
18. ↑ Hague, James. "Why Do Dedicated Game Consoles Exist?". https://prog21.dadgum.com/181.html.

* v
* t
* e

Graphics processing unit

GPU|

| Desktop|

* Intel
* GT
* Nvidia
* GeForce
* Quadro
* Tesla
* AMD
* Radeon
* Pro
* Instinct
* Matrox
* InfiniteReality
* µPD7220
* Voodoo

|

Mobile|

* Adreno
* Apple
* Mali
* PowerVR
* VideoCore

Architecture|

* Compute kernel
* Fabrication
* CMOS
* FinFET
* MOSFET
* Graphics pipeline
* Geometry
* Vertex
* HDR rendering
* MAC
* Rasterisation
* Shading
* Ray-tracing
* SIMD
* SIMT
* Tessellation
* T&L
* Tiled rendering
* Unified shader model

Components|

* Blitter
* Geometry processor
* Input–output memory management unit
* Render output unit
* Shader unit
* Stream processor
* Tensor unit
* Texture mapping unit
* Video display controller
* Video processing unit

Memory|

* DMA
* Framebuffer
* SGRAM
* GDDR
* GDDR3
* GDDR4
* GDDR5
* GDDR6
* HBM
* Memory bandwidth
* Memory controller
* Shared graphics memory
* Texture memory
* VRAM

Form factor|

* IP core
* Discrete graphics
* Clustering
* Switching
* External graphics
* Integrated graphics
* System on a chip

Performance|

* Clock rate
* Display resolution
* Fillrate
* Pixel/s
* Texel/s
* FLOP/s
* Frame rate
* Performance per watt
* Transistor count

Misc|

* 2D
* Scrolling
* Sprite
* Tile
* 3D
* GI
* Texture
* ASIC
* GPGPU
* Graphics library
* Hardware acceleration
* Image processing
* Compression
* Parallel computing
* Vector processor
* Video coding
* Codec
* VLIW

0.00

(0 votes)

Original source: https://en.wikipedia.org/wiki/Blitter. Read more

|

Retrieved from "https://handwiki.org/wiki/index.php?title=Engineering:Blitter&oldid=4228691"
*[v]: View this template
*[t]: Discuss this template
*[e]: Edit this template