Graphics Processing Unit (GPU)

Drawing processor and display controller of the PlayStation.

This is an old revision of this page, as edited by RemmyLee at 02:43, 23 October 2026. Edit this revision | Latest revision

Overview

In the PlayStation there is the GPU (the graphics drawing processor) and the GTE (the geometry transform engine). The GPU is equipped with a CRTC function for screen display and a high-speed polygon and sprite drawing function for the frame buffer, while the GTE carries out high-speed calculation of coordinate data and light source data as the CPU coprocessor.¹ The GPU and the GTE connect to the CPU as shown in System Architecture.

The basic principle of the graphics system is that the CPU transfers texture images and color palettes (CLUTs) to the frame buffer and then causes the GPU to draw polygons from the coordinates and colors that the GTE computes.² The GPU draws by executing strings of instructions (primitives) stored in main memory, and the data structures of the libgpu library correspond closely to the primitives that the GPU hardware recognizes.³

The GPU has the following drawing functions:⁴

Reference Pages

The GPU is described in detail on the following pages:

I/O Ports

The CPU controls the GPU through two 32-bit ports. GP0 receives drawing commands and VRAM data, and GP1 receives display control commands; reading GP0 returns the results of VRAM reads and register reads, and reading GP1 returns the status register.⁵

psx-spx describes the connection between the CPU and the GPU as a 32-bit data-only bus that it calls the VBUS. Apart from address line 2, which selects between the two ports, no address lines run between the two chips, so the GPU acts as a device that executes 32-bit commands.⁵

DMA

High-speed DMA transfer may be performed between the frame buffer and main memory.¹ Two DMA channels serve the GPU:⁶

DMA2 is equivalent to software access to the GP0 port, and the DMA direction must be set with GP1(04h) before it is used. DMA6 only writes main RAM and is not connected to the GPU.⁶ Libgpu uses DMA6 in ClearOTagR(), which is why a reverse ordering table is initialized faster than a normal one.⁷⁸

Frame Buffer

The GPU has 1 MB of video memory (VRAM). The frame buffer is dual ported, and may be accessed for drawing while display takes place.¹ It is 1024 pixels wide by 512 pixels tall with 16 bits per pixel, and it holds the display area, the drawing area, texture patterns and CLUTs.³ The frame buffer page describes its layout.

The GPU displays the content of rectangular areas of the frame buffer on the CRT display, and these areas are called display areas.¹ Drawing coordinates are signed 11-bit values from -1024 to 1023. Since the frame buffer is 1024 x 512, coordinates outside it wrap around. The drawing origin can be placed anywhere in the frame buffer by the coordinate offset, and the GPU clips all drawing to the current drawing area.⁴

Screen Modes

The GPU supports the following screen modes:⁹

Sony gives the width of modes 8 and 9 as 384 in PlayStation Hardware and lists a width of 360 for DISPENV in the Run-Time Library Overview. psx-spx gives this width as 368 pixels and derives it from a dot clock divider of 7.^9101112

Display Colors

The GPU supports 2 modes for color display: 15-bit direct (32,768 colors) and 24-bit direct (full color).⁹

15-bit direct mode can display up to 32,768 colors. The number of colors is limited compared with 24-bit mode, but color computation in the GPU is done in 24 bits; because of this and the dither feature, quasi-full color display is possible.⁹

24-bit direct mode can display up to 16,777,216 colors. However, it can only display image data transferred to the frame buffer, because the GPU assumes 16 bits per pixel and cannot draw in this mode. Coordinates and display locations stay in 16-bit units, so a 640 x 480 24-bit image is treated as 960 x 480 in the frame buffer. The display start X (DBX) must also be a multiple of 8, which makes the minimum screen size in this mode 8 x 2 pixels.⁹

Sprites and Texture Pages

The GPU supports sprites of up to 256 x 256 pixels, and width and height can vary up to this value. The image data of a sprite is placed in a non-display area of the frame buffer and must be transferred there before the sprite drawing command is executed.⁴

Sprite patterns are placed in 256 x 256 pixel areas of the frame buffer called texture pages. The size of a texture page in the frame buffer varies with the texture mode, and the TSB parameter of the drawing command gives its page number. The page number of a page with upper left corner (tx, ty) is tpage = ty/16 + tx/64, although the actual tpage value also contains data such as the CLUT mode and the semi-transparency rate.¹³

There are three sprite color modes: 4-bit CLUT, 8-bit CLUT and 15-bit direct. A CLUT (color lookup table) is a table of RGB values, with 16 entries for a 4-bit sprite and 256 for an 8-bit sprite, and each pixel of the sprite pattern gives its color by an index into the table. A CLUT can be selected for each sprite, and one entry has the same structure as a 15-bit pixel. The CBA parameter of the drawing command gives the left coordinate of the CLUT in the frame buffer.¹³

Polygons

The polygons that the GPU handles are triangles and quadrilaterals, and each is drawn from the screen coordinates of its vertices. With Gouraud shading a different color may be specified for each vertex, and the GPU interpolates the colors across the polygon. Texture mapping applies a 2-dimensional image to a polygon; its texture patterns are placed in non-display areas of the frame buffer and handled the same way as sprite patterns.¹⁴

Texture Cache

The texture cache (T-cache) is a 2K-byte high-speed buffer memory between the GPU and the frame buffer. Because each texel of a texture pattern is likely to be read more than once while each pixel of the polygon is drawn only once, reading texels through the T-cache speeds up texture mapping. Its size in pixels depends on the pixel mode:¹⁴¹⁵

For frame buffer access timing Sony refers to the libgpu overview, which the texture cache page follows.¹⁵

GPU Versions

psx-spx distinguishes three GPU versions:¹⁶

The v1 GPU appears only on some arcade boards and seems to use different drawing commands. Another arcade-only revision, the CXD8654Q (v2b), seems to use the same commands as the v2.¹⁶ PSX games should not use the flip feature of the v2 GPU, because older consoles do not have it.¹⁷

Library

Libgpu, the Basic Graphics library, is a low-level library for primitives such as triangles, rectangles and sprites. It provides system functions that control the whole graphics system, frame buffer access functions, primitive functions and ordering table functions. Its synchronization functions wait for the vertical blank and for the end of drawing.¹⁸ The libgpu primitives and the GPU commands they produce are listed in GP0 Drawing Commands.

References