NFB(4) — UNIX Programmer’s Manual
NAME
nfb − new frame buffer device interface for NEWS
SYNOPSIS
mfb0 at iop addr ffe5d0 intr 44
cfb0 at iop addr ffe5d0 intr 44
pfbm0 at iop addr ffe5d0 intr 44
pfbc0 at iop addr ffe5d0 intr 44
qfbm[0-7] at iop addr ffe5d0 intr 44
qfbc[0-7] at iop addr ffe5d0 intr 44
/dev/mfb0
/dev/cfb0
/dev/pfbm0
/dev/pfbc0
/dev/qfbm[0-7]
/dev/qfbc[0-7]
#include <newsiop/framebuf.h>
DESCRIPTION
The nfb interface command is used to access the NEWS frame buffer device. Nfb can access several devices simultaneously using devices that are different from the fb interface.
The sizes and the display areas of the frame buffer for each device are as follows.
|buffer |display area
---------------------------+---------------+------------
<monochrome> | |
NWB-512 | 2048 x 2048 | 816 x 1024
NWS-711,PWS-1520,1550 | 1024 x 1024 | 816 x 1024
---------------------------+---------------+------------
<color> | |
NWS-721,NWB-223,225(A),251 | 2048 x 1024 | 1280 x 1024
PWS-1560 | 1024 x 1024 | 1024 x 816
---------------------------+---------------+------------
<gray scale> | |
NWB-514 | 2048 x 2048 | 1280 x 1280
This frame buffer interface enables read/write data, raster operation, and line drawing.
The operation is performed using system call ioctl(2). The ioctl call enables the user-defined (user space) bit map operations and the frame buffer operations as well.
color
The frame buffer for the color bit map display consists of 8 (or 4) planes; 256 (or 16) colors can be displayed at the same time. The three colors red, green, and blue, are displayed using 8 bits (or 4 bits). You can select the color from a color palette of 16.7 million (or 4,096) colors. The gray scale bit map display comsists of 4 planes; 16 tones out of 256 tones can be displayed at the same time.
DATA TYPE
The data structure used for the bit map operation is given below:
typedef unsigned short Word;
#define BitsPerWord 16
typedef struct {
short x, y;
} lPoint;
typedef struct {
lPoint origin;
lPoint extent;
} lRectangle;
typedef struct {
char type; /∗ BM_FB, BM_MEM BM_0, or BM_1 ∗/
char depth; /∗ number of planes of a bit map ∗/
unsigned short width; /∗ width (unit: word) ∗/
lRectangle rect; /∗ defined area ∗/
Word ∗base; /∗ used for BM_MEM ∗/
} lBitmap;
#define BM_FB 0 /∗ frame buffer ∗/
#define BM_MEM 1 /∗ bit map (XY format) in the memory ∗/
#define BM_0 2 /∗ virtual bit map for data ‘0’ ∗/
#define BM_1 3 /∗ virtual bit map for data ‘1’ ∗/
#define BM_LBP 4 /∗ LBP frame buffer ∗/
Word can be defined as any unsigned 16 bits (1 word).
The lPoint structure is used for the point.
The lRectangle structure is used to create a rectangle. The origin is located on the left upper corner and the extent indicates the vertical and horizontal length of rectangle.
The lBitmap structure is used for defining the bit map. The type field indicates whether the bit map is located in the main memory or in the frame buffer. BM_FB indicates the bit map in the frame buffer, and BM_MEM indicates the bit map in the main memory. The BM_MEM bit map stores data in the xy format. The plane 0 data is stored followed by the plane 1 data, and so on. BM_0 and BM_1 are virtual bit maps whose data are always 0 and 1, respectively. The BM_0 and BM_1 bit maps are used as the source bit map only during the raster operation. The depth field indicates the number of planes of the bit map. The number of planes for the black and white frame buffer bit map is 1, and that for the frame buffer bit map is 8 or 4. The number of planes for the main memory bit map and BM_0/BM_1 bit maps can be 1, 8, or 4 regardless of use or non-use of color display.
The width (horizonal width) field for the BM_MEM bit map indicates the number of words in the X direction. The width for the BM_FB and BM_0/BM_1 bit maps cannot be specified.
The rect field indicates the size of the bit map. The operation is enabled within this area.
The base field indicates the starting point of the data.
For the BM_MEM bit map, the data must be arranged in the word border. The first bit in the first word of the first line corresponds to the location specified by rect.origin. This means that the bit map with 1 plane requires the (width ∗ rect.extent.y) word. In this, the width is assumed to be large enough to contain the rect.extent.x bit.
IOCTL
FBIOCNSETDIM
FBIOCNGETDIM
FBIOCNSETDIM and FBIOCNGETDIM allow you to examine and select the brightness of the display. Three levels of brightness are provided for the NWB-512 and NWS-711/PWS-1520/PWS-1550. The system default, which is the brightest, is 0. The NWB-251, NWB-514, and PWS-1560 are not provided with brightness selection and you can either set the brightness to ON or OFF. The NWB-225, NWB-223, and NWS-721 are not provided with this function.
int dimmer_level;
ioctl(fildes, FBIOCNSETDIM, &dimmer_level);
ioctl(fildes, FBIOCNGETDIM, &dimmer_level);
FBIOCNBITBLT
FBIOCNBITBLT allows you to request a 2-operand raster operation (bitblt). The source and destination bit maps are stored in the main memory or frame buffer. The BM_0/BM_1 bit map can be used for the source bit map only. The number of planes for the source and destination bit maps must be equal, or the number of planes for either bit map must be 1.
/∗ the 2-operand bitblt ∗/
typedef struct {
unsigned char func; /∗ function code ∗/
char transp; /∗ transparency ∗/
int fore_color; /∗ foreground color ∗/
int aux_color; /∗ auxiliary color ∗/
int planemask; /∗ plane selection ∗/
lBitmap srcBitmap; /∗ source bit map ∗/
lRectangle srcRect; /∗ source rectangle ∗/
lBitmap destBitmap; /∗ destination bit map ∗/
lRectangle destClip; /∗ clip rectangle ∗/
lPoint destPoint; /∗ destination point ∗/
} lBitblt;
/∗ function ∗/
#define BF_0 0x0 /∗ 0 ∗/
#define BF_SDA 0x1 /∗ Src(source) & Dest(destination) ∗/
#define BF_SDIA 0x2 /∗ Src & ~Dest ∗/
#define BF_S 0x3 /∗ Src ∗/
#define BF_SIDA 0x4 /∗ ~Src & Dest ∗/
#define BF_D 0x5 /∗ Dest ∗/
#define BF_SDX 0x6 /∗ Src ^ Dest ∗/
#define BF_SDO 0x7 /∗ Src | Dest ∗/
#define BF_SDOI 0x8 /∗ ~(Src | Dest) ∗/
#define BF_SDXI 0x9 /∗ ~(Src ^ Dest) ∗/
#define BF_DI 0xa /∗ ~Dest ∗/
#define BF_SDIO 0xb /∗ Src | ~Dest ∗/
#define BF_SI 0xc /∗ ~Src ∗/
#define BF_SIDO 0xd /∗ ~Src | Dest ∗/
#define BF_SDAI 0xe /∗ ~(Src & Dest) ∗/
#define BF_1 0xf /∗ 1 ∗/
/∗ plane mask ∗/
#define FB_PLANEALL 0xff
#define FB_PLANE0 0x1
#define FB_PLANE1 0x2
#define FB_PLANE2 0x4
#define FB_PLANE3 0x8
#define FB_PLANE4 0x10
#define FB_PLANE5 0x20
#define FB_PLANE6 0x40
#define FB_PLANE7 0x80
The lBitblt structure is used for the parameter. The func field indicates the function code for the raster operation. The transp field is used for the transparency and the value will be 0 or 1. When the value is 1, a destination pixel that corresponds to a 0-value source pixel will not be affected.
The fore_color and aux_color fields are not effective when the number of planes for the source bit map is 1. The source bit with the value 1 will be treated as the bit pattern for fore_color before executing operation with the pixel of the corresponding destination bit. On the other hand, bitblt will treat the source bit with the value 0 as the pattern for aux_color during the bitblt function execution. For example, if func is BF_S (copying from source to destination), the pixel which corresponds to the source bit with value 1 is displayed using fore_color, and other pixels are displayed using aux_color.
planemask field specifies the plane to be used for the operation. The planemask 1 informs bitblt that the corresponding plane will be the target of the operation. When a planemask is 0, the corresponding plane will be ignored. The bit N corresponds to the plane N.
The srcBitmap and srcRect fields indicate the source bit map to be used for the operation.
The destBitmap and destPoint fields indicate the destination bit map to be used for the operation. The destPoint field indicates the left upper corner. The size of the rectangle used for the raster operation is equal to srcRect. The destClip field is used for specifying the clipping portion of the destination.
lBitblt bitblt;
ioctl(fildes, FBIOCNBITBLT, &bitblt);
FBIOCNBATCHBITBLT
FBIOCNBATCHBITBLT allows you to request batch processing of several bitblt operations. The source and destination bit maps must be same throughout each operation. However, the source rectangle and destination point can be different in each operation.
typedef struct {
lRectangle srcRect; /∗ source rectangle ∗/
lPoint destPoint; /∗ destination point ∗/
} lSrcDest
/∗
∗ batch bitblt
∗/
typedef struct {
unsigned char func; /∗ function code ∗/
char transp; /∗ transparency ∗/
int fore_color; /∗ foreground color ∗/
int aux_color; /∗ auxiliary color ∗/
int planemask; /∗ plane selection ∗/
lBitmap srcBitmap; /∗ source bit map ∗/
lBitmap destBitmap; /∗ destination bit map ∗/
lRectangle destClip; /∗ clip rectangle ∗/
int nSrcDest; /∗ number of src-dest
points in the list ∗/
lSrcDest ∗srcDestList; /∗ pointer specified
by src-dest ∗/
} lBatchBitblt;
#define MAX_BATCHBITBLT 1024 /∗ maximum number of src-dest lists ∗/
The lBatchBitblt structure is similar to the lBitblt structure and consists of the source and destination bit maps. The srcDestList field indicates the source rectangle list and destination point list. The number of elements is given in the nSrcDest field.
lBatchBitblt bbitblt;
ioctl(fildes, FBIOCNBATCHBITBLT, &bbitblt);
FBIOCNTILEBITBLT
FBIOCNTILEBITBLT allows you to fill in a pattern with colors during the raster operation.
/∗ tile 2-operand bitblt ∗/
typedef struct {
unsigned char func; /∗ function code ∗/
char transp; /∗ transparency ∗/
int fore_color; /∗ foreground color ∗/
int aux_color; /∗ auxiliary color ∗/
int planemask; /∗ plane selection ∗/
lBitmap ptnBitmap; /∗ pattern bit msp ∗/
lRectangle ptnRect; /∗ pattern rectangle ∗/
lPoint refPoint; /∗ reference point ∗/
lBitmap destBitmap; /∗ destination bit map ∗/
lRectangle destClip; /∗ clip rectangle ∗/
lRectangle destRect; /∗ destination rectangle ∗/
} lTileBitblt;
The lTileBitblt structure is used to transfer the parameter. The ptnBitmap and ptnRect fields specify the pattern to be used. The refPoint field indicates the point to be referred to for the coloring operation. The reference point and the left upper corner of the pattern will match on the destination bit map. The reference point can be specified on the outside of the destination rectangle or its clip rectangle.
lTileBitblt tbitblt;
ioctl(fildes, FBIOCNTILEBITBLT, &tbitblt);
FBIOCNPOLYLINE
FBIOCNPOLYLINE allows you to draw a polyline (straight line). You can specify the line’s color line pattern, and function code the raster operation.
/∗ line ∗/
typedef struct {
unsigned int lptn; /∗ line pattern ∗/
short np; /∗ number of points ∗/
lPoint ∗plist; /∗ point list ∗/
int fore_color; /∗ foreground color ∗/
int aux_color; /∗ auxiliary color ∗/
int planemask; /∗ plane selection ∗/
char transp; /∗ transparency ∗/
unsigned char func; /∗ raster operation function
code ∗/
char dlpf; /∗ last point drawing flag ∗/
lRectangle clip; /∗ clip rectangle ∗/
lBitmap drawBM; /∗ bit map to be drawn ∗/
} lPrimLine;
/∗ line pattern (example) ∗/
#define LINE_SLD (unsigned)0xffffffff /∗ solid ∗/
#define LINE_DSH (unsigned)0xfcfcfcfc /∗ dash − ∗/
#define LINE_DOT (unsigned)0xcccccccc /∗ dot . ∗/
#define LINE_DSHDOT (unsigned)0xfff18fff /∗ dashed dot −. ∗/
#define LINE_DSHDOTDOT (unsigned)0xff8c63ff /∗ dashed dot dot −.. ∗/
The lPrimLine structure is used to request the polyline. The lptn field specifies the 32-bit line pattern. The plist field is used to transfer the up point for call. The np is not the number of lines. It is the number of points. See FBIOCNBITBLT for the explanations on the fore_color, aux_color, planemask, transp, and func fields. The dlpf flag specifies whether or not the last point in the list is drawn. In other words, when the flag is 0, this point is not drawn; otherwise, it is drawn. To draw a closed diagram, 0 is assigned to this field. The drawBM and clip fields are used to specify the bit map and the clip rectangle separately.
lPrimline primline;
ioctl(fildes, FBIOCNPOLYLINE, &primline);
FBIOCNDJPOLYLINE
FBIOCNDJPOLYLINE is similar to FBIOCNPOLYLINE. FBIOCNPOLYLINE allows you to draw a line with continuity. FBIOCNDJPOLYLINE, on the other hand, allows you to draw a line in segments. The dlpf field is used to specify whether or not the last point of each line segment is drawn.
lPrimline primline;
ioctl(fildes, FBIOCNDJPOLYLINE, &primline);
FBIOCNPOLYMARKER
FBIOCNPOLYMARKER allows you to draw a polymarker. This request is used to execute the raster operation between the specified pattern and several bit maps.
/∗ marker ∗/
typedef struct {
short np; /∗ number of points ∗/
lPoint ∗plist; /∗ point list ∗/
lRectangle ptnRect; /∗ pattern rectangle ∗/
lBitmap ptnBM; /∗ pattern bit map ∗/
int fore_color; /∗ forground color ∗/
int aux_color; /∗ auxiliary color ∗/
int planemask; /∗ plane selection ∗/
char transp; /∗ trasparency ∗/
unsigned char func; /∗ raster operation function
code∗/
lRectangle clip; /∗ clip rectangle ∗/
lBitmap drawBM; /∗ bit map to be drawn ∗/
} lPrimMarker;
The lPrimMaker structure is used to draw the polymarker. The ptnBM and ptnRect fields are used to specify the pattern to be used for the raster operation. The plist field indicates the point list, and np indicates the number of points.
lPrimMarker primmarkers;
ioctl(fildes, FBIOCNPOLYMARKER, &primmaker);
FBIOCNRECTANGLE
FBIOCNRECTANGLE allows you to fill a rectangle with a specified pattern.
/∗ filling the rectangle ∗/
typedef struct {
lRectangle rect; /∗ rectangle ∗/
lPoint refPoint; /∗ reference point for
filling ∗/
lRectangle ptnRect; /∗ pattern rectangle ∗/
lBitmap ptnBM; /∗ pattern bit map ∗/
int fore_color; /∗ foreground color ∗/
int aux_color; /∗ auxiliary color ∗/
int planemask; /∗ plane selection ∗/
char transp; /∗ transparency ∗/
unsigned char func; /∗ raster operation function
code ∗/
lRectangle clip; /∗ clip rectangle ∗/
lBitmap drawBM; /∗ bit map to be draw ∗/
} lPrimRect;
The lPrimRect structure is used to fill in the rectangle with the specified pattern. The rect field specifies the rectangle. The ptnBM and ptnRect fields are used to specify the pattern with which the target rectangle is to be filled. The refPoint field contains the point to match the left upper corner of the pattern. The refPoint may be outside the rectangle or clip.
lPrimRect rect;
ioctl(fildes, FBIOCNRECTANGLE, &rect);
FBIOCNFILLSCAN
FBIOCNFILLSCAN allows you to fill in a pattern along the specified scan line.
/∗ scan line arrangement ∗/
#define SSCANL
typedef struct {
short y;
short x0, x1;
} lScanl;
/∗ filling the pattern ∗/
typedef struct {
short nscan; /∗ number of scan line ∗/
lScanl ∗scan; /∗ scan line data ∗/
lPoint refPoint; /∗ reference point for
filling ∗/
lRectangle ptnRect; /∗ pattern rectangle ∗/
lBitmap ptnBM; /∗ pattern bit map ∗/
int fore_color; /∗ foreground color ∗/
int aux_color; /∗ auxiliary color ∗/
int planemask; /∗ plane selection ∗/
char transp; /∗ transparency ∗/
unsigned char func; /∗ raster operation function
code ∗/
lRectangle clip; /∗ clip rectangle ∗/
lBitmap drawBM; /∗ bit map to be drawn ∗/
} lPrimFill;
The lScanl structure is used for the scan line. The lPrimFill structure is used to trnsfer all the parameters. The scan field contains the pointer to the scan line arrangement. The nscan field indicates the number of scan lines. The ptnBM and ptnRect fields are used to specify the pattern with which the target rectangle is to be filled. The refPoint field is the reference point to be set on the left upper corner of the pattern.
lPrimFill fill;
ioctl(fildes, FBIOCNFILLSCAN, &fill);
FBIOCNTEXT
FBIOCNTEXT allows you to write a character string using the specified font. The fonts to be used are the bit map font and ROM font.
/∗ text ∗/
typedef struct {
char type; /∗ ROM font, etc ∗/
short len; /∗ string length ∗/
unsigned char ∗str; /∗ string ∗/
lPoint p;
int dx, dy; /∗ vector(16-bit shifted
towards left) ∗/
char ex_factor; /∗ extended factor ∗/
lPoint fp; /∗ left upper corner of the
bit map front ∗/
short width, height; /∗ font width, font height ∗/
short column; /∗ number of characters in a
string ∗/
lBitmap fontBM; /∗ font bit map ∗/
int fore_color; /∗ foreground color ∗/
int aux_color; /∗ auxiliary color ∗/
char transp; /∗ transparency ∗/
unsighed char func; /∗ raster operation function
code ∗/
lRectangle clip; /∗ clip rectangle ∗/
lBitmap drawBM; /∗ bit map to be drawn ∗/
} lPrimText;
/∗ bit map font type ∗/
#define ROM_ASCII 0
#define ROM_KANJI 1
#define ASCII 2
The lPrimText structure is used to write the characters. The type field specifies the font to be used.
ROM_ASCIIROM font (1-byte code)
ROM_KANJIROM font (JIS Kanji code)
ASCIIbit map font(1-byte code)
The len field indicates the length of the character string in bytes. Note that the length of the character string in bytes doesn’t match the number of characters if Kanji is used. The str field contains the pointer to the character string. The p field should be the point that matches the left upper corner of the first character. The dx and dy fields indicate the direction in which the string will be written. For example, to write a character at a location horizontally 26 dots to the right of the previously written character, specify: dx = 26 << 16; dy=0 The ex_factor field indicates the extended factor in the horizontal direction. For example, when this value is 1, the width will be the regular width; when it is 2, the width will be double. The fp, width, and height fields define the font bit map. The left upper corner of a font bit map is determined by fp; the font width is determined by width; and the font height is determined by height. (The size of a font is fixed and the system does not support the variable font pitch.) The column field indicates the number of characters in a string. The first_chr and last_chr fields indicate the first and last characters in the front bit map.
lPrimtText text;
ioctl(fildes, FBIOCNTEXT, &text);
FBIOCNGETSCRTYPE
FBIOCNGETSCRTYPE returns the type of the bit map display.
/∗
∗ screen type
∗/
typedef struct {
short colorwidth; /∗ color width ∗/
short plane; /∗ number of planes ∗/
char type; /∗ device type ∗/
char unit; /∗ unit number ∗/
lRectangle bufferrect; /∗ frame buffer area ∗/
lRectangle visiblerect; /∗ display screen area ∗/
} lScrType;
The lScrType structure is used to transfer the parameter. The colorwidth field indicates the bit numbers to be used for each value of red, green, and blue of the color palette. The width will be 4 or 8. When the width is 4, the higher 4 bits in the byte are used; and when it is 8, the entire 8 bits are used. The plane field indicates the number of planes. When plane is 1, the display is monochrome; and when plane is 8 (or 4), the display is color or gray scale. The type field indicates the type of the bit map display. Unique values are assigned to the corresponding interface boards as shown below:
#define FB_NWB512 1
#define FB_NWB225 2
#define FB_POPM 3
#define FB_POPC 4
#define FB_NWB514 5
#define FB_NWB251 6
The unit field indicates the board number in accordance with the address sequence of the dip switch setting on the board when several interface boards of the same kind are used. The bufferrect field indicates the frame buffer size. The visiblerect field indicates the display area of the frame buffer.
lScrType scrtype;
ioctl(fildes, FBIOCNGETSCRTYPE, &scrtype);
FBIOCNGETPALETTE
FBIOCNSETPALETTE
FBIOCNGETPALETTE and FBIOCNSETPALETTE allow you to read and write the color palette data.
/∗
∗ color
∗/
typedef struct {
short index; /∗ palette number ∗/
struct {
short r, g, b;
} rgb;
} sPalette;
typedef struct {
int count;
sPalette ∗palette;
} lPalette;
The parette number can be between 0 and 255 (8 planes) or between 0 and 16 (4 planes). The palette field contains the pointer to the sPalette structure arrays whose number is indicated by count. FBIOCNGETPALETTE requests the palette number that was delivered to the index field. The rgb field is written after begin called. FBIOCNSETPALETTE allows you to set the index and rgb fields (rgb: red, green, blue).
lPalette palette;
ioctl(fildes, FBIOCNGETPALETTE, &palette);
ioctl(fildes, FBIOCNSETPALETTE, &palette);
FILES
/dev/mfb0
/dev/cfb0
/dev/pfbm0
/dev/pfbc0
/dev/qfbm[0−7]
/dev/qfbc[0−7]
SEE ALSO
BUG
When the NWS-1830/50 is accessed from different processes at the same time, system down may occur.
For requests that require the array as a parameter, such as FBIOCNBATCHBITBLT, the array size has a limit.
The LBP interface is not yet supported.
NEWS-OSRelease 3.3