Efficient software implementation of the JBIG compression standard

Rochester Institute of Technology

RIT Scholar Works

Theses

Thesis/Dissertation Collections

1993

Efficient software implementation of the JBIG

compression standard

Craig M. Smith

Follow this and additional works at:

http://scholarworks.rit.edu/theses

This Thesis is brought to you for free and open access by the Thesis/Dissertation Collections at RIT Scholar Works. It has been accepted for inclusion in Theses by an authorized administrator of RIT Scholar Works. For more information, please [email protected].

Recommended Citation

Table

of

Contents

Abstract

ix

1

Introduction

of

Compression Concepts

1

1.1

Compression

of

Binary

Images

2

1.2

Basic Information

Theory

3

1.3

Elias

Coding

8

1.4

Arithmetic

Coding

12

2

Description

ofthe

JBIG Image Compression

Standard

1 6

2.1

Purpose

of

JBIG

16

2.2

Sequential

vs.

Progressive

Processing

18

2.3

Resolution

Reduction

20

2.4

Prediction

21

2.4.1 Differential Layer Typical Prediction 22

2.4.2 Lowest Resolution Typical Prediction 23

2.4.3 Deterministic Prediction 24

2.5

Probability

Estimation

27

2.6

Adaptive Templates

30

2.7

Arithmetic

Coding

31

3

Optimizing

JBIG

Software

32

3.

1

An Efficient Algorithm for

Building

JBIG

Contexts

33

3.1.1

Building

ColumnsofThreePixels 34

3.1.2

Building

Common Context Words 36

3.1.3

Using

TablestoBuild Reordered JBIG Contexts

39

3.2

Encoding

Both Differential Layer Lines in

One Pass

40

3.3

Moving Efficiently

through

Solid

Areas

42

3.3.2

DifferentialLayer Typical Prediction in

Solid Areas

45

3.3.3

Arithmetic

Coding

in Solid Areas

(Sequential

Mode

Only)

48

3.4

Fast Deterministic Prediction

51

3.5

Removing

the

SWTCH

from the

Probability

Estimation

52

4

Results

56

4.1

Implementation

of

Software

56

4.2

Performance

ofthe

JBIG Algorithm

58

4.3

Comparison

of

JBIG

and

CCITT

Group

3

61

4.4

Effect

of

Image Noise

on

Compression Times

63

4.5

Halftone Images

67

5

Conclusions

70

Appendices

Appendix A

Block

Diagrams

ofthe

JBIG

Compression

Algorithm

75

Appendix

B

Routines

for

Reordering

JBIG

Tables

77

B.1

Reordering

Resolution Reduction Tables

77

B.2

Reordering

Deterministic

Prediction Tables

78

Appendix

C

Test Images

81

C.

1

Original Test Images

81

C.2

Example

of

Resolution Reduction

for

Progressive

Transmission

90

C.3

Examples

of

Images

with

Random Noise

96

C.4

Examples

of

Noisy

Images

after

Filtering

103

List

of

Figures

Figure

1

Formation

of a

digital

Image

2

Figure 2

General

Information Source

4

Figure

3

Example

Pixel

context

(or neighborhood)

for

a

4th

order

Markov

Source

7

Figure 4

Example

of recursive

probability interval

subdivision

in Elias

coding.

9

Figure

5

Alignment

of

the

arithmetic

coding

registers

13

Figure 6

Four

phases of

high

resolution pixels

1 9

Figure 7

Resolution Reduction

of an

image

20

Figure

8

Context

for Resolution Reduction

21

Figure

9

Context

for

differential layer

typical prediction

22

Figure 1 0

Context for Deterministic

Prediction

25

Figure 1 1

Encoding

contexts for the

lowest

resolution

layer

27

Figure 12

Encoding

contextsfor differential

layers

28

Figure 13

Structure

of

probability

estimation

29

Figure 14

Pixels

stored as a column ofthree pixels per

byte

34

Figure

15

Code fragment for

columnizing

pixels

35

Figure 16

Code

fragment for

building

common context words

36

Figure 17

Pixel

order

for

common context words

37

Figure

18

Examplecode

fragments for

combining

high

and

low

resolution

context words

39

Figure

19

Bit

orderof

probability

estimation context

for differential layer

encoding (Phase

3)

39

Figure

20

Software

example

for

processing

two

lines in

one pass

41

Figure 21

Efficient resolution reduction

in

solid areas

44

Figure 22

Efficient

typical prediction

in

solid areas

47

Figure

24

Efficient deterministic

prediction

52

Figure 25

Improved

structureof

probability

estimation

54

Figure 26

Module Diagram for

the

JBIG Compressor

56

Figure 27

The

effect of

image

noise on

JBIG

compression speed

for

progressive and sequentialtransmission

65

List

of

Tables

Table

1

Number

of

deterministically

predictable states

in the default DP

tables

25

Table

2

JBIG

executiontimeson a

VAXstation

4000/60,

in

seconds

58

Table 3

JBIG

executiontimeson a

Sun Sparc

2,

in

seconds

59

Table 4

JBIG

execution timeson a

Sun

Sparc

1

0,

in

seconds

59

Table 5

JBIG

execution timeson an

Amiga

3000,

25MHz

68030,

in

seconds ..

.,

60

Table 6

JBIG

compression ratios

for

test

images

61

Table 7

Comparison

of compression ratios

for

binary

image

compress

algorithms

62

Table 8

Comparison

of execution times

for

binary

image

compression

algorithms on a

Sun

Sparc

2

63

Table 9

Effect

of

image

noise on

JBIG

compression

for

the

CCITT image

set.. 64

Table 1 0

Effect

of

removing

image

noise on

JBIG

compression

(CCITT Test

Set)

66

Table

1 1

JBIG halftone

execution times on a

Sun

Sparc

2,

in

seconds

67

Table 12

JBIG halftone

compression ratios 67

Table

13

Comparison

of

halftone

compression ratios

for

binary

image

compression algorithms

69

Table 14

Comparisonof

halftone

compression execution times

for

binary

Abstract

JBIG

is

a new

binary

image

compression standard that

is designed

tohandle

both

text

andhalftoned documents. It

significantly

outperformsthe

CCITT

Group

3

and

Group

4 standards_especially on

halftoned

documents.

The JBIG

standard is based on an arith

metic _encoder, and it

features

adaptive _{probability estimation,} adaptive _templates, and

three different types ofprediction. It also allows eithersequential or progressivecom pression of

image

data.

A brief discussion of

information

theory

is given as it applies to image compression. The JBIGalgorithmis

described,

and severaltechniquesaredevelopedto_{efficiently im} plementthe algorithmin software. Themost importanttechniques include an efficient

scheme for

building

the context that are _required, and

taking

advantage of large all-white or all-black regions of

images

by designing

_very efficient loops for processing

those areas. Other techniques are also

discussed,

such _as, efficient implementation of deterministicprediction,andanimprovedmethodfor

handling

theconditional exchange condition.

Timing

information is given for the final implementation on several plat

forms. The JBIG algorithm is compared with the CCITT

Group

3 and

Group

4 algo

1

Introduction

of

Compression Concepts

Within digital computer _equipment,

information is

represented as a series of symbols

that are encoded as

binary

numbers.

Almost

_{any information} can be represented this

way

including

character

based

datasuch as reports and computer_programs,

databases

of numbers _representing scientific

information

or _accounting

information,

and digital im

ages. Informationof this type can be stored in several _ways, but the storage space is

often costly. In_addition,theinformationcanbetransmittedfromone placeto _another,

butwhenlargeamounts ofdataare

transferred,

itcantakea

long

time.

Toovercometheproblemsofstorage andtransmission

time,

itisoften usefulto convert

the information into a more compact representation. _{The resulting data} requires less

storage andcanbetransmitted muchmore quickly. The processof_convertingthedata is often called

"data

compression."

Whenthe datarepresents a_picture, the processis

knownas "image

compression."

The purpose ofthis chapter

is

to explain the concepts ofimage compression that are

necessary to have an _{understanding} ofthe JBIG (Joint Bi-level Image experts

Group)

compression standard [1]. Before this can be _{accomplished,} it is important to under

stand_why compressionofdigital imagesisuseful.

Next,

afew basicconcepts ofinfor

mation

theory

will be introduced. Thiswillbefollowed

by

adiscussionof animpracti

cal but instructional_encodingtechniqueknown as Elias coding [2].

Lastly,

arithmetic

codingwill be introduced. Arithmetic coding is analgorithmthatsolvesthe shortcom

ings

ofEliascoding, anditistheheartoftheJBIGstandard.

1.1

Compression

of

Binary

Images

Ina great_manyapplications

it

isusefultousenumbersina computertorepresenta pic

ture orimage. This canbe

done

a number of

different

ways. In general, an original

scene ordocument

is

sampled at

discrete locations

by

an_analogsensorthatiscapable of

sensing the brightness of the image within a sample as

illustrated

in figure 1. Each

sample,or pixel(short forpicture_element)

is

thenconvertedtoa numberthatrepresents

the

brightness

ofthe image within the sample. The number ofbits used to represent

each pixelcan range anywherefrom 1 to _{16. In many} applications,thepixelsarestored

as an 8-bit quantity so thatthenumbers are intherange of0to_{255. In many business}

_c

JlIIiI&k,*.

t~ _{^ ^mmwmw}

,*

r^ W^^MMMM mm

^ ft?f:?

n

pi

Mt

M

55>

m :::;!

IB

I :^J

iHH**?*:::*::: ::

%\

ts

8Hli

:|::S JK5J MW$' ;*

^

/

/

Original Image

Sampled

Image

saHSaBWaSBBaa

Sensor

Electronics

Assigna numberbased

on averagebrightnessof

-*. thesample.

Generally

between

0

and255.

applications,where

images

are _generally comprised ofblack and white text documents

each pixel

is

storedas a 1-bitnumber. These 1-bit

images

areknownas

binary

images.

Anexample oftheuseof

binary

images

ina

business

application

is

afacsimilemachine.

Atypical FAX machine scans an

8.5

x 11 inch sheet of paper and generates a 1728 x

1

100

pixelimage. The resulting

image

contains 1,900,800pixels. SincemostFAXma

chines transmit data through a phone line at

9600

bits/second,

it would take about 3

minutes and20 secondsto transmit the entireimage. Formost

documents,

however,

it

is

possibleto compressthe image to 1/1 0th of

its

originalsize orless. This

is

accom

plished through the use of standard FAX compression algorithms.

As

a _result, most

documentscanbetransmittedin 20secondsorless.

Another application in which

binary

images are common is in

binary

printers such as

laserprinters. Sincemostlaserprintersprint300 dotsperinchormore, afullpageim

age requires 8,415,000pixels. Inotherwords, a standard

high-density

PC

floppy

could

only holdonefullpage

image,

Ifthe images arecompressed,

however,

it ispossibleto

storeas_manyas 10-20 full-page imagesona single

floppy

disk.

1

.2

Basic Information

Theory

To have anyunderstandingofthe_underlyingconcepts ofimagecompressioningeneral,

and the JBIG standard in particular, it is necessary to be aware of some of the funda

mental concepts ofinformationtheory. Inthis section, afewofthebasic conceptswill

be discussed

briefly

and informally. The foundationforthis

theory

was developed

by

Shannon

[3]

in 1948. Foramore complete introductiontoinformation

theory

as itre

lates to image compression see Rabbani and Jones [4]. For a thorough discussion of

backgroundand uses ofinformation

theory

see refs. [5-6].

A

binary

image is

one example of asource of

information.

When it

is

sentto alaser

printer, each

binary

pixel represents

information

for the printer. The pixel tells the

printerwhethertoprint ablack dot at a specificlocation or not. Anotherexample of a

sourceofinformation is Englishtext. Inthis_case,thereader examineseachcharacterin

the textand extractsinformation from it.

In general, it

is

possible to

define

an

information

_source,

5,

that generates a series of

symbols asshown in figure 2. Eachsymbol emitted

by

S ispartofafixedfinite alpha betof sizen,soS={si, ^ >

s

}

, andtheprobabilityofanysymbol,s-,inthe alpha

bet is aknown fixedvaluepis,). Ifeach symbol released

by

the source is _{statistically}

independent of allother symbols released

by

S,

thenS is knownas a Discrete

Memo-rylessSource

(DMS)

[4].

Tounderstandtheinformationcarried

by

thesesymbols,consideraperson_receivingthe

symbols from a DMS. When_{receiving symbols,} the receivermight guess that the in

coming symbol willbethe_{highest probability}symbol. Ifhereceivesthesymbolheex

pected,heisnot surprised. Inother_words,thesymbolcarriedhttle information. Onthe

other

hand,

ifthe receiver receives alow probability symbol,he is verysurprised. The

low probability symbol represents an event that was not _expected, so it carries much

more information. Ingeneral,it istrue thattheamount ofinformationcarried

by

a sym bol

is

inversely

relatedtothe_probability ofthe symbol. Iftheinformationcarried

by

a

Source S

+

s?c

*b'

symbol

^

is

encoded

by

a

binary

alphabetforusein adigital system,

it

is given

by

the

equation

I(s.)

=-log2p(5f)

(1)

Since

the

DMS

generates symbols with a

known

_probability, the average

information

per symbol canbecalculated

by

_summingtheinformationgenerated

by

eachsymbolin

the alphabet weighted

by

the_probability ofthe symbol_occurring as given

by

the equa

tion

H(S)

=

jy(Si)I(Si)

=-Yj>(Si)log p(st)

(

2

)

The quantity

H(S)

is knownasthe_entropyof sourceS. Itrepresentstheaverage amount

ofinformationthat the _source,

5,

can generate. Itis auseful _{quantity because it} repre sentsthe averagetheoreticallimitof algorithms thatencode thesymbols_using a

binary

alphabet.

According

toShannon's noiseless source_{coding theorem,}no_uniquely

decod-ablecode canhaveanaveragelength lessthatH(S).

As an example, consider a_{DMS generating bits for} a

binary

image,

S =

[ 0,

₁

}

.

Any

two symbols generated

by

the source are _{statistically}

independent,

andtheprobabilities ofthe twooutput symbols arefixed. Ifthe twosymbols are_{equallyprobable,}i.e._p(0) =

p(l)=

0.5,

_then

by

usingequation

2,

the_entropyofthesource

is

calculatedtobe

1.0

bit per pixel. Thismeans that

trying

to compressanimage generated

by

thesource would

be fruitless becausethe_entropy ofthesourceis equalto thenumber ofbits inthe sym

bol sequence without compression. Iftheprobabilities ofthe twosymbols areunequal,

however,

the average amountofinformationper symbol would

be lower

and compres

sion wouldbepossible. Considera

binary

DMSwhere_p(0) =_0.95

andp(l)= _{0.05. In} this case, according to equation

2,

the_entropyofthe source is

0.29

bitsper pixel. This

means that _compressing an

image

generated

by

the source could

be

a useful _{step be}

cause

it

shouldbepossibletocompresstheimagetoabout athirdof

its

original size.

While

this example

is

usefulfor

illustrating

theconcept of_entropy, it

is

limited

because

typical informationsources are not _{statistically}

independent.

Imagine a person_reading

Englishtext one character atatime. If he sees the_string

'exampl',

he can_easily guess

with ahigh degreeof_accuracythat thenext character

is

an 'e'. Inthis_case, the Vcar

ries

_{very little information}

because

thereaderknowsthat the_probabilityof an

V is

un

usually high basedon knowledgeoftheprevious symbols. In a similar_manner, itcan

be shown thatpixels in animageare _{statistically}relatedto theirneighbors.

Therefore,

theDiscrete Memoryless Source isnotanaccuratemodelformostimage data.

A better model for image informationis aMarkov Source [4]. An m orderMarkov

Source is a source in which the_probability ofoccurrence of a symbol

is

_{conditionally}

dependenton m previous symbols.The probabilityof asymbol,s-_{is denoted}as

p( sAS) where i=

1,

2,

...,n and

S

isavectorof mprevioussymbols

Sinceeach ofthem previous symbolsinthe

S

vectorhasn possible_values, anm order

Markov sourcehas

nm

possible states. Withineach _state, theMarkov sourceis similar

to a DMS inthateach ofthen possible symbols hasafixedprobability.

Therefore,

the

entropyofasingle state oftheMarkov source,

SM,

isgiven

by

H(SM)

=-Yp(Si\

S)log

p(Si\

S)

(

3

)

i=l

for 1 <M<nm. Theoverall_entropyoftheMarkovsourceisthesum oftheentropies of

eachstatetimes the_probabilitythat thestatecan occur

H(S)

=

It

is important

tonotethat the_entropyof a sourcethatismodeled as aMarkovsource

is

alwaysless thanorequal to the _entropyof a sourcethat

is

modeled as a DMS. This is

because

the Markov source takes advantage of the local

information

to make an im

proved prediction ofthe emitted symbols. As a _result, on _average,the symbols _carry

less

information.

Whena

binary

image ismodeled as an m orderMarkovsource,the_probabilityofeach

pixel

is

dependenton m_previouslytransmittedpixels.

Typically,

thepixels are selected

to

be

the m pixels closestto thepixel ofinterest. _{These nearby}pixelsthat are usedto encode apixel are known as thepixel's context or thepixel's neighborhood. Figure 3

showsatypicalcontextfor a4 orderMarkovmodelinwhich thevalues ofpixels_Xq,

Xj,X2,and x? formthevector

S.

While the Markov model is a significant improvement over the Discrete Memoryless

Source,

it still has two drawbacks.

First,

_{the complexity} of the _encoding algorithm

grows _quickly as m gets larger becausethe number of possible states grows exponen

tially. Since

binary

image data has onlytwopossiblesymbolsin itsalphabet,thesizeof the context can be 10 or 12 pixels, as used

by

the JBIG _algorithm, without _unusually large memoryrequirements.

Secondly,

theimprovementsupplied

by

theMarkovmodel

is dependent on

knowing

the conditionalprobabilities to more _accurately predict each

pixel. It

is

not _generally true,

however,

that the conditional probabilities used in a

Previously

Transmitted

Pixels

Pixel

Context

Figure

3

Example Pixel

context

(or

neighborhood)

for

a 4th order

Markov

Source

Markov

model are thesame

for

all

binary

images.

In

fact,

theconditional probabilities

can change

dramatically

from

image

to

image.

To

overcome _{this problem, the} JBIG

standard uses an adaptive

probability

estimate technique that allows the algorithm to

"learn"

the conditional probabilities for each

image.

This mechanism for this will be

explainedinsection2.5.

To summarize,theinformation content of a set of symbols

has

been described interms

of entropy. It

has been

assertedthatthe_entropyof a source can

be

calculatedbasedon a

statistical model of the generated symbols. It has also been

implied

that a sequence of

symbols generated

by

aninformationsource canbeencoded_usinga

binary

alphabetinto

a

data

streamthat_{is approximately} the same size as the_entropyofthedata.

Therefore,

ifaninformationsourceismodeledtocreate anaccurate and_{biased probability}estimate

for predictingsymbolsbasedon alocalcontextofeach_symbol,the_entropy of a source

can bereduced,

thereby

reducing the size ofthe output

binary

data.

Nothing

has been

saidabouthowthe symbols are encodedtogeneratethiscompressedoutputdatastream.

In

fact,

there are severalwellknown and simple algorithms for encoding symbols such

as Huffman coding

[7]

andrun-length_coding

[8]

thatare oftenused. Thesealgorithms

usevariable length

binary

codestorepresentone ormore source symbols. While these

techniques are simpletouse,

they

are notincluded intheJBIG_standard, andwillnotbe

discussed here. Within

JBIG,

the estimated probabilities ofeach symbol are encoded

using a_relativelynewtechniqueknownas arithmetic coding. This is basedon an_older,

but impractical encodingalgorithmknownasEliascoding.

1.3

Elias

Coding

The technique known as Elias coding was introduced

by

Elias

[2]

as an algorithm for

re-quiredto encode a sequence of symbols

is

close to the _entropy ofthe sequence.

The

drawback

ofthe technique is that it

is

not

implementable

for

image

compression be

cause it requires theuseof_{extremely large}registers.

Regardless

of

its

implementation

limitations,

it

is instructional to understand ofthe

basic

concepts of_{Elias coding} as a

basis

_{for understanding}arithmetic_codingwhichwill

be discussed

insection1.4.

In Eliascoding, a_stringof symbols generated

by

a_source,

S,

isencoded as a

binary

real

numberintherange of

[0, 1)

by

_{recursively subdividing probability intervals. Figure 4}

shows agraphicalrepresentationofthis typeofsubdivision. The entire initialregionis

divided

into

two

intervals

proportionaltotheprobabilities of

0

and1. Whenasymbol

is

encoded,

its

subinterval is selected and_{proportionally} subdividedforthe nextsymbol.

Thiscontinuesuntiltheentire_{string is}encoded.

Tobemore_precise,consider aseries of

binary

symbolstobeencoded inwhich0 isthe

most probable symbol and has a _probability of occurrence equal to p. 1 is the least

probable symbolandhas a_probability of occurrence equalto_qor1 - _p. To

encode one

1.0

0.5

0.0

1

0

01

00

001

000

0001

0000

Symboltobecoded:

0

0 0

Figure

4

Example

of recursive

probability

interval subdivision

in Elias

coding.

ofthese _symbols, the real numberrange

[0, 1)

is

subdivided

into

two

intervals, [0,

p)

representing the symbol

0,

and

fp, 1)

_representing the symbol 1. If the symbol

0 is

coded,then theinterval

[0,

p)

is

subdivided again

into

regionsthatare proportionalto_p

2 1

and_q,namely

[0,

p

)

for

0,

and

[p

_{,p) for 1. If}

instead

of

transmitting

thefirst symbol

as a

0,

the

first

symbolhad beena

1,

then thenewintervalwould

have

been

[p,

1),

andit

would have been subdivided into regions proportionalto_p and _q,

[p,

_p+qp) for

0,

and

[p+qp,

1)

for 1. Thisprocedure of_recursively

dividing

a subinterval intotwonew

sub-intervalsthatareproportionalto theprobabilities ofthesymbols

being

transmitted

is

re

peated for each symbol that is to be transmitted until the the entire message is sent.

Fromtheabove_example,the

following

characteristics canbeseen:

After

transmitting

two _symbols,the interval

[0.0,

1.0)

could have been subdivided

into one offourpossible intervals. In general, after

transmitting

n symbols the in

itial intervalcouldhave beensubdividedintooneof 2n

possibleintervals.

Noneofthepossibleintervalsoverlaps _anyotherintervalat_anypoint.

Thesubintervals covertheentire original rangeof

[0.0,

1.0).

For ninput symbols are

being

transmitted,the originalintervalof

[0.0, 1.0)

will be

subdividedin suchaway,that_everypointintheoriginalintervalwillbe associated

with_exacdyone ofthefinalpossible subintervals.

After_encoding n symbols, a finalsubintervalis selected. This subintervalcanbe de

scribed

by

the value ofthe first point inthe interval and the width ofthe interval (the

distance to the firstpoint in the next interval). The width ofthis final

interval,

_w, is

given

by

theequation

v =

f[p(Si)

(

5

)

th Wherep(s-

)

is

_the

probability of the i symbol in the string. The reasonthat this

is

important is

thatw

is

_exacdyequalto the

joint

_probabilitythatthe entire_stringwill oc

cur. Basedon the discussion in section

1.2,

it

should

be

clear that the _entropy ofthe

entire_stringgenerated

by

source5 is

/5=-log2w

(6)

Once the final subinterval is selected, it can _{be uniquely identified}

by

_{encoding any}

point withinthesubinterval as a

binary

fraction. This

is

done

by

_creatinga

binary

num--1 -2

ber,

b-ibj-.- that is interpretedasferx2 +bj^2 + .... A decoderthatreceives this

faction can

identify

the subinterval that contains this point, and _{therefore, completely}

decodetheentirestring.

To determinethe bestchoice ofpointstoencode,thevalue ofthe

beginning

oftheinter

valisencodedandthe first

|7e 1

bitsofthe

binary

fractionare_used,where

11

represents

the _{ceiling function.} The resulting fractionrepresents the shortest possible

binary

code

to transmit theinformationofthe_stringandmustbewithinthefinalsubintervalbecause

w^lM

(7)

So

far inthis discussionofEliascoding,it has beenassumedthat theprobabilities_p and

qare fixedand_{globally known}

by

boththeencoderanddecoder. Asseenintheexam

pleof aMarkov source in section 1.2,

however,

theentropyofa set ofdatacanbe low

ered

by

_using alocal contexttomake betterpredictions of eachnewsymbol. Ifthe in

formation source is modeled as a Markov source, the probabilities that are used to

subdivide each interval must change from symbol to symbol

depending

on the current

Markov state. This added complication does not change _{anything in}the previous dis

cussion. In general, as

long

as the probabilities used for each symbol are _causally

known

by

boththeencoderand

decoder,

the

Elias

_codingalgorithmcould_optimallyen

code and_uniquely

decode

anystring.

The majordrawback of theElias algorithmisthat _encodinga _stringof_{arbitrary length}

requires

infinite

precision registers. _{When encoding} a

binary

image consisting of mil

lions of_pixels,registers that are severalmillionbits

long

couldberequiredto storethe

locationofthe

beginning

oftheintervalandthecurrentwidthoftheinterval. Thisprob

lem and others related to it are overcome

by

a compression technique known as

arithmetic coding.

1.4

Arithmetic

Coding

Arithmetic coding

[9-13]

is a_relatively new_encodingtechnique that isthecentral cod

ing

algorithmfortheJBIGcompression standard. While it is similarinconcept toElias

coding, it overcomesthe infiniteprecision problems. This is accomplished

by

_using a

rescalingprocedurethat slides afixedprecision windowonthe infiniteprecisionregis

tersofEliascoding.

Inthis section,abriefdescriptionoftheJBIGarithmetic_encoding algorithmisgivento

introducethebasicconcepts andpropertiesofthealgorithm. Fora moreprecisedefini

tionofthealgorithm seetheJBIGspecification[1]. Formorebackgroundontheimple

mentation of arithmetic_coding algorithms,itisusefulto _study awelldocumentedarith

metic_encoding algorithmdeveloped IBM knownastheQ-coder [14-16].

Foran arithmeticcoder, afixednumber ofbits is allocatedfor encodingthe_probability

of asymbol. In

JBIG,

16 bits are allocated. Two registers ofthis depth are required,

one to

keep

track ofthewidthofthe current subinterval

(

A

),

and oneto

keep

trackof

the bottomof the subinterval

(

C

). Theseregisters define the current subinterval ex

A

_register)

falls

belowone

half,

bothregisters are

doubled

_repeatedlyuntiltheAregister

is

abovethe onehalflevel. This scalingprocessis knownasrenormalizationandit ef

fectively

slidesbothregistersdownthearithmetic axis ofthetwoEliasvalues as shown

in

figure 5 untilthe first 1 bit inthefractionalrepresentation oftheElias interval

is

the

highorderbit inthe arithmeticAregister. The bits shifted out oftheC register arethe

bits

that aretransmittedas part oftheencodeddatastreamwithoneexception whichis

knownasthe_carrypropagation problem.

The carry propagation problem iscaused

by

the factthat the value ofthe

beginning

of

theElias subinterval will always_staythesameorincrease. When it

increases,

thevalue

ofthe arithmeticCregister can overflow. Theresult ofthe

binary

overflow willbethat

all l'sabovetheCregister willbe flippedtoO'sand thefirst 0 beforetheCregisterwill

be flipped to a 1. In general, this _carry problemcan be handleda couple ofdifferent

ways. The JBIG algorithmkeepsthelast outputbytethatcontained azero andacount

ofthenumber of"all

1"

bytes (255

's)

thathaveoccurred since. When anoverflowoc

curs,thelast_{byte containing}azerois incrementedandtransmittedand the255 bytesare

transmittedas0 bytes.

EliasIntervalWidth: 0000 ... 0000

A- Register

0000

lxxxxxxxxxxxxxxx

EliasIntervalStart: xxxx ... xxxx

C- Register

0000

XXX XX XXXX XX XX XXX

Figure

5

Alignment ofthe arithmetic

coding

registers

Another important

concept tounderstand aboutthe arithmetic coder

is

the factthat

it is

computationallyefficient. When encodinga

binary

_symbol, themostprobable symbol

will be encoded ahighpercentage ofthe time. Whenthis occurs, theA registerisre

duced

by

the size ofthe

least

probable subinterval. The exactsize oftheleastprobable

subinterval

is

theproduct ofthe currentinterval _size,

A,

andthe_probability oftheleast

probable _symbol,q.

Since

the_multiply

is

undesirable,

it is

avoided

by

_{replacing A}with

the statistical average of

A,

which

is

a constant.

By

_usingthe statistical average of

A,

the

following

approximationismadetocalculatean estimate oftheleastprobableinter

val,for everypossible valueof_q

qXA~qXa =

qe

(8)

whereais theaverage overthe_probability

density

of

A,

and

qg

istheresultingestimate

of the least probable subinterval size. Sincethe normalizedvalue ofA is bounded be

tween0.5 and

1,

thevalue ofAcanbereplaced

by

awithout

introducing

alarge error.

Since q is known for everyvalue of_q,it canbestoredinatable andfoundwithoutthe

need for a multiply. As a _result, the _only required operation when _encoding a most

probable symbolistheupdatefortheAregistergiven

by

A<-A-qe

(9)

Whentheleastprobable symbol isencodedtheAand

C

registers are changed asfollows

C+-C+A-qe

A

-qe

Eventhoughtheapproximationofthe_{q interval}can_simplifythearithmeticcalculations

without

imposing

alarge coding

inefficiency,

itdoescauseone anomaly.

Since

theesti

mationofthe _q intervalis independentofthecurrent interval size,whenthe

interval, A,

larger

than the most probable subinterval.

This

can cause a

fairly

large

inefficiency.

Since

this condition canbe causally detected

by

a

decoder,

itcanbe corrected

by

both

the encoder and decoder

by

_using the least probable subinterval to encode the most

probable symbol and_using the most probable subintervalto encode the leastprobable

symbol. This strategy

is

knownas conditional exchange and

it is

used

in

theJBIGarith

metic encoder.

2

Description

of

the

JBIG Image

Compression

Standard

In this chapter, a general description of the JBIG compression standard will be given.

This is not intendedto be a complete definition ofthe standard.

Instead,

each ofthe

components ofthealgorithmwillbe discussedsothat thereader

has

an_{understanding}of

theissues and complexities relatedto the algorithm. With_{this understanding, the}reader

should be aware ofthe need to

develop

efficient techniques for

implementing

the full

algorithm.

This discussionisprovidedas an introductionto the optimization stepsdiscussed in the

next chapter. Sincetheseoptimizations_{only deal}withissues in aJBIGcompressor,the

details ofthedecompressorare notdiscussed here. For information abouttheJBIG de

compressor and a more detailed description ofthe JBIG compressor, the reader is re

ferredto theJBIGspecification[1].

2.1

Purpose

of

JBIG

WorkonJBIG (Joint Bi-level Image Experts

Group)

began in 1988. Itspurpose wasto

define a_standard,CCITT T.82andISO

11544,

for compressing

binary

image data fora

wide rangeofapplications. These applicationsincludesuch areas as

facsimile,

audiog-raphicteleconferencing,andimage databases. To fulfilltherequirements ofthese appli

cations and_{many more,}thealgorithmneededtobe flexibleenoughtoperform well over

awide range ofimagetypes and

imaging

systems.

Prior to

JBIG,

the_primary

binary

image compression standards in the world were the

CCITT

Group

3

[17]

and

Group

4

[18]

standards. These standards are reviewed and

one

dimensionally

encoderuns of consecutive white and blackpixels on_everyk line

ofthe

image.

Betweentheone

dimensionally

encoded

lines,

the

lines

are processed

by

encoding differences between twoconsecutive

lines

_using atechniqueknown asModi

fied

READ (Relative Element

Address

Designate).

Since

the Huffman codes used

by

these standards were designed specifically for textbusiness

documents,

the algorithms

perform wellonthat typeofdocument. Halftoned

images, however,

have

distinctly

dif

ferentcharacteristics fromtextdocuments. Asaresult, halftoned images are not com

pressedwell

by

CCITT

Group

3

and

Group

4. In

fact,

the result of_using

Group

3 or

Group

4 on ahalftoned image is normallya larger filethan the original, becausethese

algorithms cannot adaptto thelocalstatistics ofahalftoned image.

They

often expand

thedocumentinsteadof_{compressing it.}

JBIGwas developedtobeasignificant improvementover

Group

3 and

Group

4. Spe

cifically, it was desired that the JBIG algorithm provide the

following

improvements

overtheprevious standards:

1. provideimprovedcompressionfortextandlineartdocuments (seesection

4.3),

2. providesignificant compressionofhalftoneddocuments (seesection

4.3),

and

3. providethe _abilityto transmitimages_{progressively}aswellas _{sequentially (see} sec

tion2.2).

To accomplish these goals, it was _necessary to

develop

an algorithm thatwas signifi

cantly more complex than

Group

3

or

Group

4. This extra _{complexity is}possible be

cause of advancesin integratedcircuit

technology

andmicroprocessorperformance.

2.2

Sequential

vs.

Progressive

Processing

In many

image

_{processingapplications,}an

image is

processed atfullresolutionfrom left

to right and from

top

to bottom in a single pass.

This

type of_processing

is

knownas

sequential processing. CCiTT

Group

3

and

Group

4 are examples of sequential com

pression algorithms. Sequential applications are _normally simpler and_{relatively inex}

pensive to implement because it is not _necessary to store an entire image in a page

buffer. The disadvantageof sequential compression algorithms isthat image datamust

beprocessed atfull resolution

before

auser can viewthe image. Sincethis can take a

significant amountof_{time, it is}notoptimalfor many applications.

Inother _{applications,}it can beuseful to transmitalow resolution version of an image

that can be displayed to the user almost immediately.

Increasingly

higher resolution

versions ofthe image aretransmitted sothat the image displayedtothe user is steadily

improved. This type of _{processing is known} as progressive processing. Progressive

transmissionofimages isusefulfortworeasons:

1. Improved userinteraction: Since arepresentationofthefull image ispresentedto

auser_veryquickly,ittakesmuchlesstimefortheusertorecognize andtherespond

to the image. If the user

is

interested inthe

image,

the user can wait for the full

imagetobetransmitted. Ontheother

hand,

iftheuser

is

notinterested inthe

image,

it would be possible to terminate thetransmissionwithout waiting. This

feature is

very important in image

browsing

applications where a user

is

searching though a

long

listof availableimages.

2.

Supporting

peripherals with

differing

resolutions: Images can be compressed

andstored in animage database and still used on a_variety of peripherals at several

different resolutions. For

instance,

animage couldbe extractedfroma

database

for

ver-sion ofthe

image. The

same

image

could

be

printed at appropriate resolutions on a

300

DPIprinterora600 DPIprinter.

The disadvantage

of progressivealgorithms

is

that

they

require a pagebuffertostorethe

entireimage. This addsto thecost and_complexityofthesystem.

Thealgorithm

defined

by

theJBIG standard can operate _{both sequentially}and progres

sively. In addition, JBIGprovides a mode

known

as progressive-compatible sequential

mode. In _{this mode,} an

image

is

divided

into horizontal sections called stripes. The

stripe is

decomposed

into therequired resolutionlayers and compressed as inprogres

sivemode. Theadvantageofthismodeisthat_{it only}requiresenough_memorytobuffer

a stripe instead of the entire image. The compressed data for progressive and

progressive-compatible sequentialmodes_{is exactly}the_{same; it is simply}storedinadif

ferentorder. As a_result,

images

canbe storedinanimage database andtransmittedin

progressive mode to a CRT or in progressive-compatible sequential mode to a

binary

printer.

Thechoice of progressive orsequential_{processing is dependent}ontheneeds ofthe _ap

plication. It usually has very little effect on the overall compression rate ofan

image,

although progressive_{processing does}requiremore_processingtime

because

each ofthe

resolutionlayersmustbecompressed.

Whenprogressive_processing is used, anew low resolutionpixel is created for each 4

high resolution pixels. Figure 6 shows how this _{is normally} represented notationally.

Figure

6

Four

phases of

high

resolution pixels

The

circle represents alowresolution pixel andthefour squares representthefourhigh

resolution pixels associatedwith it. Thepositionofthehighresolution pixel relativeto

thelowresolution pixelis knownasthespatial phase of thehighresolution pixel.

2.3

Resolution Reduction

Forthe JBIG algorithmto compress_{progressively, it is first necessary}tocreate each of

thelowresolution images.

To

create alow resolution

image,

ahighresolutionimage is

processed

by

an algorithmthat creates anewimagethat is halftheheight andhalfthe

width ofthe high resolution image. This process is repeated for each new resolution

that isneeded. Figure 7 illustratesthisprocess fortworeductions. Eachoftheseimages

is

thencompressed. A decompressor begins

by

decoding

thelowresolutionimage and

builds upto thedesired highresolutionimage.

The JBIG specification defines a default resolution reduction _algorithm, although it is

possibletouse acustom algorithmtodothereduction..

Half

Resolution

Quarter

Resolution

Full

Resolution

The defaultresolution reduction algorithm uses atable to generate new low resolution

pixels so that theimplementation

is

efficient. It

is based

on a filterthat

is

designedto

preservethe average

density

of_anyarea.

Some

exceptionsto the filter designare made

to the table to improve the_quality ofthe

resulting

low resolution images. The excep

tionsaremadeto

improve

the_abilityofthe algorithmtopreserves_edges,

lines,

periodic

patterns andditherpatterns. Pixels intheneighborhood ofthenewlowresolution pixel

are usedto indextheresolution reductiontable. Theorder ofthepixelsisshownin

fig

ure 8. Examplesoflowresolutionimagesareshownin Appendix C.2.

(>

r* 7

T

6

/^

5

V

1

3

9)-

-w-\

1

2

iyo

Figure

8

Context for

Resolution Reduction

2.4

Prediction

The JBIGstandard usesthree differentalgorithms topredict pixels. One forthelowest

resolutionlayerand twofordifferential layers (all layers butthelowestresolution). If

one or moreofthese algorithmsdetermines that apixelispredictable, thenitisnoten

coded because itcan bepredicted

by

the decoder. Each of thesepredictionalgorithms

canbeenabledordisabled

depending

onthe_{desired complexity}ofanimplementation.

Two oftheseprediction _algorithms,one forthelowest resolution

layer,

and one for all

other

layers,

are known as typical predictors.

They

are called

"typical"

because

they

predict eventsthatare

typically

true, butnotalwaystrue. Atthe

beginning

of each

line,

apseudo-pixelisencodedto tell thedecoderwhether or nottheconditionistrue forthe

entireline. Ifthe conditionis

true,

then the algorithmcan predict_{pixels; otherwise,}the

algorithm

is inactive

forthatline.

The

third prediction algorithm is known as

deterministic

prediction. This algorithm

uses aknowledgeof the resolution reductionto

determine

when_onlyone value

is

possi

ble forapixel.

2.4.1

Differential

Layer Typical Prediction

Thepurpose ofdifferential layertypicalprediction

(DTP)

is

to predict solid areas of an

image. The algorithm works on the assumption that if all ofthe pixels in a three

by

three neighborhood of a low resolution image are the same _color, then the four high

resolutionpixels associatedwith the centerlow resolution pixel are the same color as

the neighborhood. Figure

9

illustrates thepixelsusedinthis assumption. Whilethisis

not always_{true, it is}valid most ofthetime. When differential layertypicalpredictionis

enabledtheassumptionistestedfortwolinesat atime todetermine if itisvalidforthat

pairoflines(two linesareusedbecauseallfour highresolutionpixelsaretested). Ifthe

assumptionis true,then thelines are saidtobetypical. Apseudo-pixelisthenencoded

at the

beginning

ofthe

first line

to tell the

decoder

whether or not the assumption

is

valid.

Whena pair ofimage

lines

is foundto be

typical,

itmeansthat this is a solidarea, and

all ofthepixels can

be

skipped. The decoderwillknow howtogeneratethepixelsjust

by

readingthevalue ofthepseudo-pixel. Sincemostdocumentscontain alarge amount

of solid area

(especially

white

background),

_many ofthepixels inthedocument canbe

skipped. As a result, software

implementations

ofthe algorithmwill run muchfaster.

Thisistheentirepurpose oftheDTP algorithm.

Ingeneral, differential layertypicalprediction_{has very little} effect onthe compression

performance oftheJBIG algorithm. In

fact,

_enablingthisfeatureoften reducesthecom

pression ratio slighdy. The reason forthis is thatthepixels that are skipped _carry al

mostno information (which is whythe DTP assumptionis normally valid).

Removing

these pixels has almostno effect ontheoverall _entropyofthedocument.

However,

for

eachpairoflines anewpseudopixelis encoded. Theprobabilities associated withthis

pseudo-pixelare muchlessbiasedthan theskipped_pixels, and_{therefore, carry}more in

formation. Asa_result,the total_entropyofthedocumentdoesnot change significantiy.

2.4.2

Lowest Resolution Typical Prediction

The algorithm usedfortypicalprediction inthe differentiallayer assumesthepresence

ofalowerresolution image. Whenthe lowestresolution layer

is

encoded (orthe _only

resolutionlayerforsequential_processing), aseparate algorithmisneeded. Inthis_case,

JBIG defines alowest resolutionlayertypicalpredictionalgorithm (also knownas

base

layertypical prediction or

BTP)

that _simplytests two consecutive

lines

to

determine

if

they are _exactly the same. Ifthe lines are found tobe the _same, a pseudo-pixel

is

en

codedtotransmitthe

information,

andtheentireline

is

skipped with nofurther

ing. Ifthe

lines

are not_{the same,}thenthe pseudo-pixel

is

encoded

differently,

andthe

rest ofthe

line is

processed normally.

Typicalprediction

is

most useful for

processing

blank

lines

within the image. Forthis

reason ahighpercentage ofthepixelsinmost simple

business

documents donot needto

be

processed. As with differential layer typical _prediction, this _{greatly improves} the

speedof asoftware

implementation,

but is has

little

effectonthe compressionratiosof

thealgorithm.

2.4.3

Deterministic Prediction

Thepurpose of

deterministic

prediction

(DP)

istoremove the_necessityof_encodingre

dundant information betweenalowresolutionimageand ahighresolutionimage. Since

the low resolution image must be similar in appearance to the high resolution

image,

there are cases wherehigh resolution pixelscanbe

identified

as

having

_onlyonepossi

ble value. This canbe done becauseaknownalgorithmisusedtodotheresolution re

duction. As an example of_whythis is_valid, consider a simple resolutionreduction al

gorithm that will create a black low resolution dot whenever two or more high

resolution dots areblack. Ifin a given_area, thelowresolutionpixel iswhite, and one

black highresolution pixelis

decoded,

thenall oftherestofthepixelsmustbewhite. If

anyoftheother pixels were

black,

then thelowresolution pixel wouldhave been black.

Whilethisexampleassumesa_verysimpleresolutionreduction_algorithm,thebasiccon

ceptcanbeappliedfor anyreduction algorithm. In

fact,

forthedefaultresolution reduc

tion algorithm, most images contain a significant number ofpixels that are predictable

by

thedeterministicprediction algorithm.

The deterministicprediction algorithmistabledrivensothatitcanbe

implemented

effi

ciently. Separate tables areused for eachofthe four high resolution pixels associated

Figure

10

Context

for

Deterministic

Prediction

thatwere used

by

theresolution algorithm. Infigure

10,

thepixelsthatareusedtobuild

the

index

are shown _alongwiththeorderinwhichthebitsare placedinthe index. The

pixels numbered

8, 9, 11,

and12arethepixels

being

predicted. Foreach_pixel,onlythe

previouslytransmittedpixels areused.

Specifically,

forpixel

8,

theindex isconstructed

frompixels

0-7,

forpixel

9,

the index is constructed from pixels

0-8,

forpixel

11,

the

index is constructed from pixels

0-10,

and forpixel

12,

the index is constructed from

pixels 0-11. The JBIGstandarddefinesthefour deterministicpredictiontables thatwill

work withthedefault resolution reductionalgorithm. Inthese

tables,

alargenumber of

theentriesareforpredictable pixels. Table1

defines

thenumberof context states possi

ble foreachpixelandhow manyofthesestates represent predictablepixels.

Target

Pixel

Number

of

Context

States

Number

of

States

with

Predictable Pixels

8 256 20

9 512 108

11 2048 526

12 4096 1044

Table

1 Numberof

deterministically

predictable states

in

the

default

DP tables

It

is

also possibleto transmit a set of custom DPtables as a part of the image header

defined

by

the standard. This is required ifa non-standard resolution reduction algo

rithm is

used.

The

main purpose of

deterministic

prediction

is

to

improve

the compressionperform

ance ofthe algorithm. Even though DPpredicts _only a_{very few} pixelsrelative to the

large

number predicted

by

typical_prediction, it

has

a muchlargereffect on theoverall

compressionratio. To understand_whythisisthecase, considerthepixels that are pre

dicted

by

thedeterministicpredictionalgorithm.

Many

ofthepixelspredicted

by

DPdo

nothave

highly

skewedprobabilities. Inother_words,the pixels predicted

by

DP carry

more informationthan the TP_pixels, so more bitswould be required to encode them.

Sincethesebits nolongerneedto _{be transmitted,} and no extrainformationneeds tobe

encoded as in the typical prediction _algorithm, the compression ratio improves. The

2.5

Probability

Estimation

Within the

JBIG

standard probabilities are _{conditionally}estimatedbased on a_group of

pixels in the neighborhood ofthe current pixel.

This is

similarto the Markov model discussed insection 1.2. One ofthe problemswith aMarkov model

is

that the condi tionalprobabilitiesthatare usedarenotconsistentfrom imageto image. To overcome this_problem,theJBIG standard

defines

a method ofadaptive_probabilityestimation so thatitcanlearnthecorrectprobabilities asitprocessesanimage

Within

JBIG,

a neighborhood of 10pixels is defined around the pixel

being

encoded.

These 10pixels aredesignedtobethe 10pixels most correlatedwiththecurrent pixel. There are sixdifferent _encoding contextsdefined in JBIG for different encoding condi tions. Thesecontexts are_graphicallyrepresentedin

figures

11 and 12. Ineach_context, there isapixel markA. Thepurpose ofthispixel willbe discussed insection2.6.

X

X

X

X

X

X

X

X

X

Two Line Context

X

X

X

X

X

X

X

A

X

X

7

Three

Line

Context

Figure

1

1

Encoding

contexts

for the lowest

resolution

layer.

When

encoding

thebase

layer,

therearetwopossible_{encodingcontexts,} atwolinecon

text,

and athreeline context. The JBIG standard suggeststhatthetwolinecontextwill

allow softwareto runsomewhatfasterwhilethe three linecontext will improvetheen

coding

by

about5%.

When encoding the differential resolution

layers,

there arefour different contexts that

areused. Thechoice of context

is

dependentontheposition(orphase)ofthehighreso lutionpixel

being

encodedrelativeto_{its corresponding low}resolution pixel. Thevalues

X

J

IX

J

\x

)

[

X

Phase

2

Phase

3

ofthe 10pixelsintheneighborhood arecombinedwiththetwobitvalue ofthephaseof

thepixeltoforma 12bitcontext. Withineach resolutionlayer (andalsowithineachbit

planeformultibit

images),

the algorithmkeeps trackofthecurrentmostprobable sym

bol

(MPS)

andthecurrent_probabilitystate

(ST)

for everycontext.

The

standard

defines

a_probabilityestimation statetablewith

113

possible states. Foreachstate inthe

table,

an estimationoftheleast probable symbol subintervalwidth

(LSZ)

isstored. LSZ is a

16 bitrepresentation ofthevalue_q defined inequation

8

on page 14. Alsoincluded in

the state tableisthe next_probability estimation stateto beused fora contextwhenthe

encoded valueisthemost probablesymbol

(NMPS),

andthestate tousenext whenthe

least probable symbol is encoded (NLPS). _{The probability} estimation state changes

eachtime a renormalization

is

performed. The last value in the state table also is the

value, SWTCH that is used to indicate that the value of MPS should be inverted if

NLPS occurs.

Figure 13 represents theflowofdata inthe_probability estimationprocessforone reso

lution layerorbitplane. Priorto_encodingan

image,

eachcontext,foreachlayerandbit

plane, is initialized so that themost probable symbol is

0,

buttheprobabilities forthe

two possible symbols are_nearlyequal. Whena pixelis _encoded, thevalueofthepixel

Pixel

Compare

^ r

M An

PS

^

Valueof

MPS^

MPS Pixel

Arithmetic

Encoder

rayj

i L

bits

Context SWTCH

r

>

State Table

out

Next State (NMPSor_NLPS) Renorm

i ' LSZ

(

s

7

1

Current State__

^Ar]ray

J

Figure 13

Structure

of

probability

estimation

and

it's

context word

(10

or 12

bits)

are usedto

determine

the_{probability interval}to

be

encoded

by

an arithmetic encoder. Thecontextisused as anindex

into

arraysthat

hold

the current state and most probable symbolforthatcontext. The state

is

used as an

in

dex into

thestatetable tofindthe leastprobable subinterval

(LSZ),

andthepixel value

is

comparedwiththeMPS. Thesevalues are passedtoan arithmetic encoderthatgener

ates an output streamofbits. Whenever a renormalization occurs in the arithmeticen

coder, the _probability state for that context is updated. The value ofthe current state

indexes thestatetable to_{look up} eitherNMPS orNLPS

depending

on whetheranMPS

was encoded or not. When the next state is

NLPS,

the value of SWTCH is also ac

cessed. If SWTCH is 1 then the valueofthe_{MPS array for}the current context

is

in

verted. Thisprocessisrepeated foreach pixelinthe image. Inthis_waythe algorithm

learnsthecorrect probabilitiesforeachpossible context.

2.6

Adaptive

Templates

The JBIG standard allows for a small amount of _{adaptivity in} the contexts used for

probability estimation. This

feature is

knownas adaptivetemplates_{(AT). The primary}

motivation forthisfeature istoimprovethe_abilityofthealgorithmtoencodehalftoned

images. Halftonedimagesare the resultof_usinga

binary

_printingprocess torepresent

gray scale images.

They

occur often in compression applications as a result of either

scanning a_{previously halftoned image} or from capturing a continuous tone image and

thresholding

itwith a periodicpatternto simulate _{gray levels [20]. The important fea}

ture ofhalftoned images is that

they

usually involve aperiodic pattern. In terms of a

Markovcontext for compressinganimage it meansthatthepixelsmostcorrelatedwith

thecurrent pixel canbeseveralpixels away.

In each ofthecontexts used for_probabilityestimation shown in figures 1 1 and

12,

one

only.

The

standard allows an encodertomovethispixel to anotherlocation

if

the en

coderbelievesthat

doing

sowill improvethe compression. It shouldbenoted thatthis

feature

shouldbeused with_care,

because

eachtimetheATpixelismoved,theprobabil

ity

estimation arrays are resettotheirinitialvalues.

They

mustreleamtheprobabilities

forthenewcontexts.

When anATmovementis specified,it onlyapplies to thecurrent resolutionlayer (and

bit plane).

According

to the _standard, the ATpixel can be moved to _{any previously}

transmittedpixel position within 127pixels inthehorizontal

direction,

and 255 lines

vertically.

However,

in_practice, it is suggestedthatencoders limitthe ATpixelmove

menttothecurrentline andthepreviouseight pixels.

An algorithmto determine when and wherethe ATpixel should move is suggested in

thestandard,although_anyalgorithm canbeused. Itis also possibletouseno algorithm

at all.

2.7

Arithmetic

Coding

The heartoftheJBIGalgorithmisanarithmetic_entropy coder. Itencodesthesymbols

andprobabilities thatweredescribed insection 2.5 forall oftheunpredictablepixels as

well as the pseudo-pixel generated

by

the typicalprediction algorithm. The output of

thearithmeticencoderisastream ofbitsthatmake_upthecompressedimagethatcanbe

stored or transmitted

depending

ontheapplication.

The algorithm used for arithmetic _encoding is the same as the algorithm described in

section 1.4.

3

Optimizing

JBIG

Software

The

goals ofthe

JBIG

committee wereto

develop

an algorithmthatwould provide im

proved compression over a wide range of

documents

as _{previously discussed.} This

could not be done without _creating an algorithm that was _significandy more complex

than thepreviousCCITT_standards,becausethesestandardswere_relativelysimple algo

rithms.

However,

the new JBIG standard would not

be

effective if it could notbe im

plementedinan_extremelyefficientmanner.

A considerable amount ofwork went _{into creating} an algorithm that could be imple

mentedineither software orhardwareefficiently. Theresultisanelegant algorithmthat

uses a seriesoftables toperformcomplicatedfunctionssuch asresolution_reduction,de

terministic _prediction, and_probability estimation. Since few calculations are _required,

the_resultingalgorithmshouldbeabletoprocesspixelsat_{relatively high}speeds.

WhiletheJBIG algorithmiscapable ofhighspeeds,litdeor_{nothing has been}writtento

document software-specific techniques for

improving

the_processing speedofthe algo

rithm. As a result, software developers who don't have experience with compression

algorithms could _easily miss significant opportunities for

implementing

_{extremely fast}

software.

Thepurposeofthischapteristodocumentseveraltechniques thathave beenusedinan

implementation ofthe JBIG algorithm to _{significantly} improve execution time of the

software. Throughoutthisworkthe

following

assumptionshave beenmade:

All software is written in ANSI C. No assembly language is used because the re

All optimizations are algorithmic in nature. The goal, in _general,

is

to reduce the

number of operations needed to perform atask.

While it is

possible to write soft

ware that takes advantage ofthe features of one specific platform, the final algo

rithm would_only

be

usefultoa_relativelysmall audience.

All changes are compatible withthe_{existing JBIG} standard. Eventhough otherin

compatiblechanges mightbe

interesting,

they

would notbe extremelyuseful.

Memory

is

cheap. Thismeansthat it isvalidtouse_significandymore_memorythan

might _{normally be} required, if

doing

so will reduce the number ofrequired opera

tions. The limittothis_{strategy is}that the techniquesdevelopedshouldbeusefulfor

applicationsthatrunin PCenvironmentswitha640K memory limitation.

Image datawill enterthe algorithm in aone pixel perbyte format. This should be

validforgeneralpurpose software sincesome applications will _{already have data in}

this format. Applications with a packed

binary

formatwill haveto unpackthe im

age

data,

butthisisnot considered part ofthecompression algorithm.

3.1

An Efficient Algorithm for

Building

JBIG

Contexts

The largestobstacle to an efficient implementation ofJBIG is theneedto gather_many

pixelstogethertobuild largecontexts foreachpart ofJBIG. From

looking

atfigures

8,

9, 10, 11,

and

12,

it canbe seen thatthere are _{many different}contextpatternsthat_may

berequiredfor anypixel. In

fact,

for anyspecific_pixel, it may berequiredtobuildcon

texts forresolution reduction, typicalprediction,deterministic prediction, and probabil

ity

estimation, each ofwhich requires the use ofdifferent neighboring pixels. This is

especiallytrue when encoding differential

layers,

althoughthe techniques discussed in

this sectionarealsousefulwhen_encodingthelowestresolutionlayer.

It

is important

torealizethateventhough each algorithm uses a

different

neighborhood,

thereare_manypixelsthatarecommontoseveral neighborhoods. In

fact,

the totalnum

berof pixels neededto build all possible contexts

is

fairly

small. This can be seen

by

forming

the union of all possible context bits. When

doing

this the adaptive pixel

should be ignored because it must be handled separately, and the two line base layer

templateshouldbeignoredaswillbeexplainedlater. It

is

_easytoseethat the_resulting

union

is

threepixelshigh for boththelowresolutiondataandthehighresolutiondata.

3.1.1

Building

Columns

of

Three Pixels

To facilitate

building

a context_word, it is useful to _group the pixels into columns of

three pixels. Figure 14 shows how the three pixel values are arranged within a byte.

Partofthereasonfor

doing

thisis because itcanbe done very quickly andeasily. The

main_reason,

however,

is thatonceit is donethesecolumns can

be

_veryuseful in build

ing

context wordsforboththehighandlowresolutionpixelsas showninthenext sec

tion. Thecodefragment in figure 15 shows anexample ofhowthiscanbe done. Inthis

example,it isassumedthatpixel_data is originallyatwo_{dimensional array}ofpixel

values stored as one pixel perbyte

holding

allthepixeldata forone stripeofone

resolu-Bits

3-7

Bit 2

Bitl

BitO

0

Unused

(0)

Pixel

from

the current

line

-

2

Pixel

from

thecurrent

line

-

1

Pixel

from

thecurrent

line

Figure 14

Pixels

stored as a column ofthree

unsigned char pixels

[STRIPE_HEIGHT]

[LINE_WIDTH]

_; int

line;

register int

i;

register

long

*current_line;

register

long

*previous_line;

previous_line =

(long)

(last_{line of}theprevious_stripe)

for

(

line = ₀

; line < STRIPE_HEIGHT ; line++

)

{

current_line =

(long

*)pixels[

line

];

for

(

i = _{(layer_width}

-l)/4 ; i >= _{0 / i}

)

current_line[i] |= (previous_line

[i]

1)

&

0x06060606;

previous_line =

current_line;

}

Figure

15

Code

fragment for

columnizing

pixels

tionlayer. Afterthe

loop

is

completed, eachbyteof thepixels _array willholdthree

pixelsintheformatshownin figure 14.

Initially,

previous_line points the the last line ofthe previous stripe which is al

ready in the threepixel format (at the