Dec 292017
Document showing structure and format of the GIFF and TIFF graphic files.
File GTIFFDOC.ZIP from The Programmer’s Corner in
Category Printer + Display Graphics
Document showing structure and format of the GIFF and TIFF graphic files.
File Name File Size Zip Size Zip Type
GIF.DOC 32472 9446 deflated
IFF.DOC 64637 21856 deflated
TIFF.DOC 55982 16130 deflated

Download File GTIFFDOC.ZIP Here

Contents of the GIF.DOC file

G I F (tm)

Graphics Interchange Format (tm)

A standard defining a mechanism

for the storage and transmission

of raster-based graphics information

June 15, 1987

(c) CompuServe Incorporated, 1987

All rights reserved

While this document is copyrighted, the information

contained within is made available for use in computer

software without royalties, or licensing restrictions.

GIF and 'Graphics Interchange Format' are trademarks of

CompuServe, Incorporated.

an H&R Block Company

5000 Arlington Centre Blvd.

Columbus, Ohio 43220

(614) 457-8600

Page 2

Graphics Interchange Format (GIF) Specification

Table of Contents

INTRODUCTION . . . . . . . . . . . . . . . . . page 3

GENERAL FILE FORMAT . . . . . . . . . . . . . page 3

GIF SIGNATURE . . . . . . . . . . . . . . . . page 4

SCREEN DESCRIPTOR . . . . . . . . . . . . . . page 4

GLOBAL COLOR MAP . . . . . . . . . . . . . . . page 5

IMAGE DESCRIPTOR . . . . . . . . . . . . . . . page 6

LOCAL COLOR MAP . . . . . . . . . . . . . . . page 7

RASTER DATA . . . . . . . . . . . . . . . . . page 7

GIF TERMINATOR . . . . . . . . . . . . . . . . page 8

GIF EXTENSION BLOCKS . . . . . . . . . . . . . page 8

APPENDIX A - GLOSSARY . . . . . . . . . . . . page 9




Graphics Interchange Format (GIF) Page 3



'GIF' (tm) is CompuServe's standard for defining generalized color

raster images. This 'Graphics Interchange Format' (tm) allows

high-quality, high-resolution graphics to be displayed on a variety of

graphics hardware and is intended as an exchange and display mechanism

for graphics images. The image format described in this document is

designed to support current and future image technology and will in

addition serve as a basis for future CompuServe graphics products.

The main focus of this document is to provide the technical

information necessary for a programmer to implement GIF encoders and

decoders. As such, some assumptions are made as to terminology relavent

to graphics and programming in general.

The first section of this document describes the GIF data format

and its components and applies to all GIF decoders, either as standalone

programs or as part of a communications package. Appendix B is a

section relavent to decoders that are part of a communications software

package and describes the protocol requirements for entering and exiting

GIF mode, and responding to host interrogations. A glossary in Appendix

A defines some of the terminology used in this document. Appendix C

gives a detailed explanation of how the graphics image itself is

packaged as a series of data bytes.

Graphics Interchange Format Data Definition



| +-------------------+ |

| | GIF Signature | |

| +-------------------+ |

| +-------------------+ |

| | Screen Descriptor | |

| +-------------------+ |

| +-------------------+ |

| | Global Color Map | |

| +-------------------+ |

. . . . . .

| +-------------------+ | ---+

| | Image Descriptor | | |

| +-------------------+ | |

| +-------------------+ | |

| | Local Color Map | | |- Repeated 1 to n times

| +-------------------+ | |

| +-------------------+ | |

| | Raster Data | | |

| +-------------------+ | ---+

. . . . . .

|- GIF Terminator -|


Graphics Interchange Format (GIF) Page 4



The following GIF Signature identifies the data following as a

valid GIF image stream. It consists of the following six characters:

G I F 8 7 a

The last three characters '87a' may be viewed as a version number

for this particular GIF definition and will be used in general as a

reference in documents regarding GIF that address any version



The Screen Descriptor describes the overall parameters for all GIF

images following. It defines the overall dimensions of the image space

or logical screen required, the existance of color mapping information,

background screen color, and color depth information. This information

is stored in a series of 8-bit bytes as described below.


7 6 5 4 3 2 1 0 Byte #


| | 1

+-Screen Width -+ Raster width in pixels (LSB first)

| | 2


| | 3

+-Screen Height-+ Raster height in pixels (LSB first)

| | 4

+-+-----+-+-----+ M = 1, Global color map follows Descriptor

|M| cr |0|pixel| 5 cr+1 = # bits of color resolution

+-+-----+-+-----+ pixel+1 = # bits/pixel in image

| background | 6 background=Color index of screen background

+---------------+ (color is defined from the Global color

|0 0 0 0 0 0 0 0| 7 map or default map if none specified)


The logical screen width and height can both be larger than the

physical display. How images larger than the physical display are

handled is implementation dependent and can take advantage of hardware

characteristics (e.g. Macintosh scrolling windows). Otherwise images

can be clipped to the edges of the display.

The value of 'pixel' also defines the maximum number of colors

within an image. The range of values for 'pixel' is 0 to 7 which

represents 1 to 8 bits. This translates to a range of 2 (B & W) to 256

colors. Bit 3 of word 5 is reserved for future definition and must be


Graphics Interchange Format (GIF) Page 5



The Global Color Map is optional but recommended for images where

accurate color rendition is desired. The existence of this color map is

indicated in the 'M' field of byte 5 of the Screen Descriptor. A color

map can also be associated with each image in a GIF file as described

later. However this global map will normally be used because of

hardware restrictions in equipment available today. In the individual

Image Descriptors the 'M' flag will normally be zero. If the Global

Color Map is present, it's definition immediately follows the Screen

Descriptor. The number of color map entries following a Screen

Descriptor is equal to 2**(# bits per pixel), where each entry consists

of three byte values representing the relative intensities of red, green

and blue respectively. The structure of the Color Map block is:


7 6 5 4 3 2 1 0 Byte #


| red intensity | 1 Red value for color index 0


|green intensity| 2 Green value for color index 0


| blue intensity| 3 Blue value for color index 0


| red intensity | 4 Red value for color index 1


|green intensity| 5 Green value for color index 1


| blue intensity| 6 Blue value for color index 1


: : (Continues for remaining colors)

Each image pixel value received will be displayed according to its

closest match with an available color of the display based on this color

map. The color components represent a fractional intensity value from

none (0) to full (255). White would be represented as (255,255,255),

black as (0,0,0) and medium yellow as (180,180,0). For display, if the

device supports fewer than 8 bits per color component, the higher order

bits of each component are used. In the creation of a GIF color map

entry with hardware supporting fewer than 8 bits per component, the

component values for the hardware should be converted to the 8-bit

format with the following calculation:

= *255/(2** -1)

This assures accurate translation of colors for all displays. In

the cases of creating GIF images from hardware without color palette

capability, a fixed palette should be created based on the available

display colors for that hardware. If no Global Color Map is indicated,

a default color map is generated internally which maps each possible

incoming color index to the same hardware color index modulo where

is the number of available hardware colors.

Graphics Interchange Format (GIF) Page 6



The Image Descriptor defines the actual placement and extents of

the following image within the space defined in the Screen Descriptor.

Also defined are flags to indicate the presence of a local color lookup

map, and to define the pixel display sequence. Each Image Descriptor is

introduced by an image separator character. The role of the Image

Separator is simply to provide a synchronization character to introduce

an Image Descriptor. This is desirable if a GIF file happens to contain

more than one image. This character is defined as 0x2C hex or ','

(comma). When this character is encountered between images, the Image

Descriptor will follow immediately.

Any characters encountered between the end of a previous image and

the image separator character are to be ignored. This allows future GIF

enhancements to be present in newer image formats and yet ignored safely

by older software decoders.


7 6 5 4 3 2 1 0 Byte #


|0 0 1 0 1 1 0 0| 1 ',' - Image separator character


| | 2 Start of image in pixels from the

+- Image Left -+ left side of the screen (LSB first)

| | 3


| | 4

+- Image Top -+ Start of image in pixels from the

| | 5 top of the screen (LSB first)


| | 6

+- Image Width -+ Width of the image in pixels (LSB first)

| | 7


| | 8

+- Image Height-+ Height of the image in pixels (LSB first)

| | 9

+-+-+-+-+-+-----+ M=0 - Use global color map, ignore 'pixel'

|M|I|0|0|0|pixel| 10 M=1 - Local color map follows, use 'pixel'

+-+-+-+-+-+-----+ I=0 - Image formatted in Sequential order

I=1 - Image formatted in Interlaced order

pixel+1 - # bits per pixel for this image

The specifications for the image position and size must be confined

to the dimensions defined by the Screen Descriptor. On the other hand

it is not necessary that the image fill the entire screen defined.


Graphics Interchange Format (GIF) Page 7


A Local Color Map is optional and defined here for future use. If

the 'M' bit of byte 10 of the Image Descriptor is set, then a color map

follows the Image Descriptor that applies only to the following image.

At the end of the image, the color map will revert to that defined after

the Screen Descriptor. Note that the 'pixel' field of byte 10 of the

Image Descriptor is used only if a Local Color Map is indicated. This

defines the parameters not only for the image pixel size, but determines

the number of color map entries that follow. The bits per pixel value

will also revert to the value specified in the Screen Descriptor when

processing of the image is complete.


The format of the actual image is defined as the series of pixel

color index values that make up the image. The pixels are stored left

to right sequentially for an image row. By default each image row is

written sequentially, top to bottom. In the case that the Interlace or

'I' bit is set in byte 10 of the Image Descriptor then the row order of

the image display follows a four-pass process in which the image is

filled in by widely spaced rows. The first pass writes every 8th row,

starting with the top row of the image window. The second pass writes

every 8th row starting at the fifth row from the top. The third pass

writes every 4th row starting at the third row from the top. The fourth

pass completes the image, writing every other row, starting at the

second row from the top. A graphic description of this process follows:


Row Pass 1 Pass 2 Pass 3 Pass 4 Result


0 **1a** **1a**

1 **4a** **4a**

2 **3a** **3a**

3 **4b** **4b**

4 **2a** **2a**

5 **4c** **4c**

6 **3b** **3b**

7 **4d** **4d**

8 **1b** **1b**

9 **4e** **4e**

10 **3c** **3c**

11 **4f** **4f**

12 **2b** **2b**

. . .

The image pixel values are processed as a series of color indices

which map into the existing color map. The resulting color value from

the map is what is actually displayed. This series of pixel indices,

the number of which is equal to image-width*image-height pixels, are

passed to the GIF image data stream one value per pixel, compressed and

packaged according to a version of the LZW compression algorithm as

defined in Appendix C.

Graphics Interchange Format (GIF) Page 8



In order to provide a synchronization for the termination of a GIF

image file, a GIF decoder will process the end of GIF mode when the

character 0x3B hex or ';' is found after an image has been processed.

By convention the decoding software will pause and wait for an action

indicating that the user is ready to continue. This may be a carriage

return entered at the keyboard or a mouse click. For interactive

applications this user action must be passed on to the host as a

carriage return character so that the host application can continue.

The decoding software will then typically leave graphics mode and resume

any previous process.


To provide for orderly extension of the GIF definition, a mechanism

for defining the packaging of extensions within a GIF data stream is

necessary. Specific GIF extensions are to be defined and documented by

CompuServe in order to provide a controlled enhancement path.

GIF Extension Blocks are packaged in a manner similar to that used

by the raster data though not compressed. The basic structure is:

7 6 5 4 3 2 1 0 Byte #


|0 0 1 0 0 0 0 1| 1 '!' - GIF Extension Block Introducer


| function code | 2 Extension function code (0 to 255)

+---------------+ ---+

| byte count | |

+---------------+ |

: : +-- Repeated as many times as necessary

|func data bytes| |

: : |

+---------------+ ---+

. . . . . .


|0 0 0 0 0 0 0 0| zero byte count (terminates block)


A GIF Extension Block may immediately preceed any Image Descriptor

or occur before the GIF Terminator.

All GIF decoders must be able to recognize the existence of GIF

Extension Blocks and read past them if unable to process the function

code. This ensures that older decoders will be able to process extended

GIF image files in the future, though without the additional


Graphics Interchange Format (GIF) Page 9

Appendix A - Glossary


Pixel - The smallest picture element of a graphics image. This usually

corresponds to a single dot on a graphics screen. Image resolution is

typically given in units of pixels. For example a fairly standard

graphics screen format is one 320 pixels across and 200 pixels high.

Each pixel can appear as one of several colors depending on the

capabilities of the graphics hardware.

Raster - A horizontal row of pixels representing one line of an image. A

typical method of working with images since most hardware is oriented to

work most efficiently in this manner.

LSB - Least Significant Byte. Refers to a convention for two byte numeric

values in which the less significant byte of the value preceeds the more

significant byte. This convention is typical on many microcomputers.

Color Map - The list of definitions of each color used in a GIF image.

These desired colors are converted to available colors through a table

which is derived by assigning an incoming color index (from the image)

to an output color index (of the hardware). While the color map

definitons are specified in a GIF image, the output pixel colors will

vary based on the hardware used and its ability to match the defined


Interlace - The method of displaying a GIF image in which multiple passes

are made, outputting raster lines spaced apart to provide a way of

visualizing the general content of an entire image before all of the

data has been processed.

B Protocol - A CompuServe-developed error-correcting file transfer protocol

available in the public domain and implemented in CompuServe VIDTEX

products. This error checking mechanism will be used in transfers of

GIF images for interactive applications.

LZW - A sophisticated data compression algorithm based on work done by

Lempel-Ziv & Welch which has the feature of very efficient one-pass

encoding and decoding. This allows the image to be decompressed and

displayed at the same time. The original article from which this

technique was adapted is:

Terry A. Welch, "A Technique for High Performance Data

Compression", IEEE Computer, vol 17 no 6 (June 1984)

This basic algorithm is also used in the public domain ARC file

compression utilities. The CompuServe adaptation of LZW for GIF is

described in Appendix C.

Graphics Interchange Format (GIF) Page 10

Appendix B - Interactive Sequences

GIF Sequence Exchanges for an Interactive Environment

The following sequences are defined for use in mediating control

between a GIF sender and GIF receiver over an interactive communications

line. These sequences do not apply to applications that involve

downloading of static GIF files and are not considered part of a GIF



The GCE sequence is issued from a host and requests an interactive

GIF decoder to return a response message that defines the graphics

parameters for the decoder. This involves returning information about

available screen sizes, number of bits/color supported and the amount of

color detail supported. The escape sequence for the GCE is defined as:

ESC [ > 0 g (g is lower case, spaces inserted for clarity)

(0x1B 0x5B 0x3E 0x30 0x67)


The GIF Capabilities Response message is returned by an interactive

GIF decoder and defines the decoder's display capabilities for all

graphics modes that are supported by the software. Note that this can

also include graphics printers as well as a monitor screen. The general

format of this message is:

#version;protocol{;dev, width, height, color-bits, color-res}...

'#' - GCR identifier character (Number Sign)

version - GIF format version number; initially '87a'

protocol='0' - No end-to-end protocol supported by decoder

Transfer as direct 8-bit data stream.

protocol='1' - Can use an error correction protocol to transfer GIF data

interactively from the host directly to the display.

dev = '0' - Screen parameter set follows

dev = '1' - Printer parameter set follows

width - Maximum supported display width in pixels

height - Maximum supported display height in pixels

color-bits - Number of bits per pixel supported. The number of

supported colors is therefore 2**color-bits.

color-res - Number of bits per color component supported in the

hardware color palette. If color-res is '0' then no

hardware palette table is available.

Note that all values in the GCR are returned as ASCII decimal

numbers and the message is terminated by a Carriage Return character.

Graphics Interchange Format (GIF) Page 11

Appendix B - Interactive Sequences

The following GCR message describes three standard EGA

configurations with no printer; the GIF data stream can be processed

within an error correcting protocol:

#87a;1 ;0,320,200,4,0 ;0,640,200,2,2 ;0,640,350,4,2


Two sequences are currently defined to invoke an interactive GIF

decoder into action. The only difference between them is that different

output media are selected. These sequences are:

ESC [ > 1 g Display GIF image on screen

(0x1B 0x5B 0x3E 0x31 0x67)

ESC [ > 2 g Display image directly to an attached graphics printer.

The image may optionally be displayed on the screen as


(0x1B 0x5B 0x3E 0x32 0x67)

Note that the 'g' character terminating each sequence is in lower



The assumed environment for the transmission of GIF image data from

an interactive application is a full 8-bit data stream from host to

micro. All 256 character codes must be transferrable. The establishing

of an 8-bit data path for communications will normally be taken care of

by the host application programs. It is however up to the receiving

communications programs supporting GIF to be able to receive and pass on

all 256 8-bit codes to the GIF decoder software.

Graphics Interchange Format (GIF) Page 12

Appendix C - Image Packaging & Compression

The Raster Data stream that represents the actual output image can

be represented as:

7 6 5 4 3 2 1 0


| code size |

+---------------+ ---+

|blok byte count| |

+---------------+ |

: : +-- Repeated as many times as necessary

| data bytes | |

: : |

+---------------+ ---+

. . . . . .


|0 0 0 0 0 0 0 0| zero byte count (terminates data stream)


The conversion of the image from a series of pixel values to a

transmitted or stored character stream involves several steps. In brief

these steps are:

1. Establish the Code Size - Define the number of bits needed to

represent the actual data.

2. Compress the Data - Compress the series of image pixels to a series

of compression codes.

3. Build a Series of Bytes - Take the set of compression codes and

convert to a string of 8-bit bytes.

4. Package the Bytes - Package sets of bytes into blocks preceeded by

character counts and output.


The first byte of the GIF Raster Data stream is a value indicating

the minimum number of bits required to represent the set of actual pixel

values. Normally this will be the same as the number of color bits.

Because of some algorithmic constraints however, black & white images

which have one color bit must be indicated as having a code size of 2.

This code size value also implies that the compression codes must start

out one bit longer.


The LZW algorithm converts a series of data values into a series of

codes which may be raw values or a code designating a series of values.

Using text characters as an analogy, the output code consists of a

character or a code representing a string of characters.

Graphics Interchange Format (GIF) Page 13

Appendix C - Image Packaging & Compression

The LZW algorithm used in GIF matches algorithmically with the

standard LZW algorithm with the following differences:

1. A special Clear code is defined which resets all

compression/decompression parameters and tables to a start-up state.

The value of this code is 2**. For example if the code

size indicated was 4 (image was 4 bits/pixel) the Clear code value

would be 16 (10000 binary). The Clear code can appear at any point

in the image data stream and therefore requires the LZW algorithm to

process succeeding codes as if a new data stream was starting.

Encoders should output a Clear code as the first code of each image

data stream.

2. An End of Information code is defined that explicitly indicates the

end of the image data stream. LZW processing terminates when this

code is encountered. It must be the last code output by the encoder

for an image. The value of this code is +1.

3. The first available compression code value is +2.

4. The output codes are of variable length, starting at +1

bits per code, up to 12 bits per code. This defines a maximum code

value of 4095 (hex FFF). Whenever the LZW code value would exceed

the current code length, the code length is increased by one. The

packing/unpacking of these codes must then be altered to reflect the

new code length.


Because the LZW compression used for GIF creates a series of

variable length codes, of between 3 and 12 bits each, these codes must

be reformed into a series of 8-bit bytes that will be the characters

actually stored or transmitted. This provides additional compression of

the image. The codes are formed into a stream of bits as if they were

packed right to left and then picked off 8 bits at a time to be output.

Assuming a character array of 8 bits per character and using 5 bit codes

to be packed, an example layout would be similar to:

byte n byte 5 byte 4 byte 3 byte 2 byte 1


| and so on |hhhhhggg|ggfffffe|eeeedddd|dcccccbb|bbbaaaaa|


Note that the physical packing arrangement will change as the

number of bits per compression code change but the concept remains the



Once the bytes have been created, they are grouped into blocks for

output by preceeding each block of 0 to 255 bytes with a character count

byte. A block with a zero byte count terminates the Raster Data stream

for a given image. These blocks are what are actually output for the

Graphics Interchange Format (GIF) Page 14

Appendix C - Image Packaging & Compression

GIF image. This block format has the side effect of allowing a decoding

program the ability to read past the actual image data if necessary by

reading block counts and then skipping over the data.

Graphics Interchange Format (GIF) Page 15

Appendix D - Multiple Image Processing

Since a GIF data stream can contain multiple images, it is

necessary to describe processing and display of such a file. Because

the image descriptor allows for placement of the image within the

logical screen, it is possible to define a sequence of images that may

each be a partial screen, but in total fill the entire screen. The

guidelines for handling the multiple image situation are:

1. There is no pause between images. Each is processed immediately as

seen by the decoder.

2. Each image explicitly overwrites any image already on the screen

inside of its window. The only screen clears are at the beginning

and end of the GIF image process. See discussion on the GIF


 December 29, 2017  Add comments

 Leave a Reply

You may use these HTML tags and attributes: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <s> <strike> <strong>