CA2143633A1 - Improved vector quantization - Google Patents

Abstract

Improved method and apparatus for vector quantization (VQ) to build a codebook for the compression of data. The code-book (600) or "tree" is initialized by establishing N initial nodes (610) and creating the remainder of the codebook as a binary codebook (650). Children entries (670) are split upon determination of various attributes, such as maximum distortion, popula-tion, etc. Vectors obtained from the data are associated with the children nodes, and then representative children entries are recal-culated. This splitting/reassociation continues iteratively until a difference in error associated with the previous children and cur-rent children becomes less than a threshold. This splitting and reassociating process continues until the maximum number of terminal nodes is created in the tree, a total error or distortion threshold has been reached or some other criterion. The data may then be transmitted as a compressed bitstream comprising a codebook and indices referencing the codebook.

Description

2 1 1 3 ~ 3 ~ PCr/US93/08235 .

~IPROVED VECI'OR OUAN~ATION

~ACKGROUND OF l~IE INVEN~ON

5 1. Field of the Invention The present invention relates to video c~ l es~ion and decompression.
More specific~lly, the present invention relates to improved video cc,,.~ ;s~ion/deco,,~l,,c;s~ion using image preprocessing and vector qll~nti7~tion (VQ)-102. Back~round of Related Art Modern applications, such as m--ltimPAi~ or other applications requiring full motion video required the development of video col"l"Gssion standards for reducing the ~,ocessi~g bandwidth cons~lm~d by storing, transmitting, and 15 displaying such video inrol ll-ation. This is due to the large amount of data to n~it or store for representing high resolution full image video information.
Generally, apparatus such as shown in Figures la, I b, and Ic are employed in order to COlll~ ,SS and decom,ul~ss an input image for vector qu~nti7~tion based techniques. For instance, as shown in Figure la, an image 100 may be input to an 20 encoder 101 which applies spatial or ltlll~,olal preprocessing to an input image or sequence of images in order to reduce the redundancy or otherwise reduce the amount of information contained in the input image 100. Encoder 101 generates a cc l"~ sed image 102 which is substantially smaller than the original image 100.
In certain prior art systems, the encoder 101 uses a codebook 105 which is used 25 for ~ chil-g given pixel patterns in the input images 100, so that the pixel patterns are m~ed to alternative pixel patterns in the compressed images 102. In this 21~3&33 manner, each area in the image may be addressed by referencing an element in thecodebook by an index, instead of tr~n~ g the particular color or other graphics info~ ion. Although in some prior art applications, quality is lost in compressed images 102, substantial savings are incurred by the reduction in the image size from images 100 to CO11JI)1eSSeC3 images 102. Other compression techniques are "loss-less" wherein no quality in the decoded images is lost generally at the cost of additional col"pu~ation time or a larger bitstream.
Conversely, compressed images 102 may be applied to a decoder 131, as shown in Figure l b, in order to generate deco,l~ ssed images 13 ~ . Again, decoder 131 uses codebook 105 to det. l,lline the pixel patterns represented in images 132 from the indices contained within co"""essed images 102. Decoder 131 }~quires the use of the same codebook 105 which was used to encode the image. Generally, in prior art systems, the codebook is unique as associated with a given image or set of images which are compressed and/or decompressed for display in a colll~ul~l system.
Generally, a codebook such as 105is generated from image or training set of images 151 which is applied to a codebook generator 15~. The codebook can be gcnc. d~ed specifically from and for one or more images that are compressed, and that codebook is used for decoding the images it was generated from. The codebook can also be generated once by optimizing it for a long training sequence which is meant to be a reasonable representation of the statistics of sequences of images to be coded in the future. This training codebook is meant to be representative of a large range of image characteristics. The training codebook is often fixed at the encoder and decoder, but pieces of the codebook may also be improved adaptively. In some prior art schemes, codebook generator 15~ and 2 ~ 4 ~ 6 3 3 PCr/US93/08235 , . .

~ncaler 101 are one in the same. Encoding is perforrned cimult~neous with codebook generation, and the codebook is derived from the encoded image(s) instead of training image(s).
Figure 2 shows how an image 200 may be partitioned to discrete areas 5 known as vectors for encoding and decoding of the image. In one prior art approach, an image such as 200 is divided into a series of 2 x 2 pixel blocks such as 201 and 202 which are known as ~Ivectors.~ Each of the vectors such as 201 comprises four pixels 201a, 201b, 201c, and 201d. When an image has been broken down into such vectors, each of the vectors in the bitstream may be used 10 to: (a) encode an image which may include generating a codebook; and (b) decode an image. Each of the vectors such as 201, 202, etc. in image 200 may be used torepresent image 200. Thus, an image may be rel)Jcsellted by references to ~le.~ t~ in a codebook which each are a~ v~ aLions of the vectors contained in the image. Thus, instead of ~c~ 3e"~ g the image by using four discrete pixels 1~ such as 201a through 201d, the image may be represented by referencing a codebook index which approximates information contained in vector 201.
Depending on the number of entries in the codebook, using the codebook index to refer to an image vec~or can subst~nti~lly reduce the storage required for ~lesenting the vector because the actual pixel values 201a-201d are not used to20 l~ SWI~ the image.
Such prior art apparatus, such as discussed with reference to Figures la through lc, are implemented in a device known as a codec (coder/decoder) which generates a cc,~lJ~l~,ssed bit~caln for a sequence of images from the cc",~,s~onding codebook, and uses the codebook to decc,lnplcss the images at a 2~ later time. For example, such a codec is shown as apparatus 300 in Figure 3.

, WO 94/06099 ,~ . .. . ~ PCr/US93/08235 Codec 300 comprises two sections: enco~er 301 and decoder 351. Encoder 301 accepts as input data 310, which may be video, sound, or other data which is desired to be cc,~ ,ssed. For the purposes of the rem~inder of this application, a cciQn of video çnro1in~/decQ~ing will ensue, however, it can be appreciated 5 by one skilled in the art that similar scl.~ es may be applied to other types of data.
Such input data may be applied to a preprocessor 320 wherein certain pal~,llt~
are adjustçd to preprocess the data in order to make encoding/decoding an easiertask. ~,r lcessor 320 then feeds into a vector quantizer 330 which uses vector 4~ 1 i75.1 ion to encode the image in some manner, which equivalently reduces 10 re~llnd~nries~ Then, vector quantizer 330 outputs to a packing/coding process340 to further COl~ SS the l,i~ a,ll. A rate control mechanism 345 receives il~o,lllation a'oout the siæ of the co~ ssed bit~.~eall~ 350, and various a~ t41.7 are adjusted in ~ plvcessol 320 in order to achieve the desired datarate. Moreover, preprocessor 320 samples the encoded data stream in order to ~5 adjust quality settingc Codec 300 further includes a decoder 351 which receives and decodes the compressed biL~ 350 by using a codebook regenerator 360. The decoder in the encoder need not go through the packing 340 or unpacking 37Q process in order to decode the image. In the decoder, codebook regenerator 360 is fed into 20 an llnp~king process 370 for restoring the full bitstream. The results of this process may be passed to a postfilter 375 and then dithering 380 may be performed upon the image, and finally the image is displayed, 390.
Examples of prior art vector quantization processes may be found in the reference: Gray, R.M., "Vector Qu~n~i7~tion," 1 EEE ASSP Magazine, 4-29 25 (April 1984) ("Gray"), and Nasrabadi, N.M., "Image Coding Using Vector ~ WO 94/06099 2 1 4~ 6 3 3 PCI/US93/08235 Ql.~uL;,;~;on A Review," COM-36 ~EE Transaction on Col~munications. 957-971 (August 1988) ("Nasrabadi"). Such vector qu~nti7~tinn includes the creation of a tree sea~ hcd vector qn~n~i7er which is described in Gray at pp. 16-17, and in Nasrabadi at p. 75.
The codebook gtncl~lion process is iterative and tends to be co..ll,uL~Lionally G~ nsi~e. Thus, in some prior art methods, which require codebook per frame, the encoding tends to be slow. Also, a drawback to prior art~.y~.lt.lls which use training sequences is quality, which may not be acceptable for many sequ~n~es which may not be similar to image(s) in the training sequence.
10 Overall ~uc.ro~ ance is also a concern. Some prior art techniques require an ino.~Iil,al~ amount of processing and still do not achieve acceptable compression while not being able to p~lrOll" the colll~ .ion in real-time. Demands for fast ~ecor1ing capability are often even more stringen~ or real time playback is not possible. Most prior art systems also have a coll.~ul~tionally expensive decoder.

W O 94J06099 ' ;~ PC~r/US93/082 ~
2I~3~633 SUMMARY AND OBJECI'S OF THE INVENTION
One of the objects of the present invention is to provide an a~pa.dLu~ and method for efficiently ~ ~-e~ a~ g codebooks by vector qu~nti7~tior~ reducing spatial and ~ y~ldl re(l~ln-l~nry in images, and associated processing of images in 5 order to conserve bandwidth of the cc,~ ,ssion system.
Another of the objects of the present invention is to provide a means for effiriently partitioning and processing an image in order to reduce the errors s~csOC;-~If~ with typical prior art vector ,~ rion techniques.
Another of the objects of the present invention is to provide a means for 10 further rf~lucing the compuldtion associated with typical prior art vector qn~nti7~tiOn t~ch~ ues-Another of the objects of the present invention is to provide a means forcf~f~ and effectively controlling the res~lting datarate of a conl~lessed ~ CG in order to ~rcQ~ orl~te smooth playback over limited bandwidth 1~ ch~nn~lc.
Another of the objects of the present invention is to provide a simple decode ~L1UCIU1G which will allow real time decocling of the cc,ll,~lc;ssed data.
These and other objects of the present invention are provided for by an irnproved method and ~atus for vector ~ ri7~1 ;on (VQ) to build a codebook 20 fo~ the colll~lession of data. In one embo lim~nt, the da~a comprises image data.
The codebook "tree" is initi~li7~.d by est~hliching N initial nodes and creating the rPm~ind~ of the codebook as a binary codebook. Children entries are split upon det~ hlation of various attributes, such as maximum distortion, population, etc.Vectors ob~lod from the data are associatcd with the children nodes, and then 25 ,~Gylese.~ e children entries are rec~lcnl~t~A This spli~ting/reassociation ~WO 94/06099 2 1 ~ 3 1~ 3 ~ PCI/US93/08235 conhnlles iteratively until a dirr~.c;.~ce in error between previous children and current children becomes less than a threshold. This splitting and reassociationcontinues until the maximum number of terrninal nodes is created in the tree a total error or distortion threshold has been reached or some other criterion. The 5 data may then be tr~n~mitted as a cc.~p~ssed bitstream comprising a codebook and indices referencing said codebook.

WO 94/06099 ~ ~ ~ 3 ~ 3 3 PCI/US93/08235 BRIEF DESCRIPI ION OF THE DRAWINGS
The present invention is illustrated by way of example and not limitation of the figures of the accolnl.anying in which like references indicate like elements and in which:
S Figures la-lc show prior art encoding/decoding apparatus used for compressing/decompressing video image(s).
Figure 2 shows a prior art scheme for dividing an image into vectors comprising 2x2 pixel blocks.
Figure 3 shows a functional block diagram of a prior art codec 1(~ (coder/~lçcod~r).
Figure 4 shows a preprocessing technique which identifies no-change blocks.
Figures Sa and Sb show examples of subsampling used in the preferred embodiment.
lS Figure 6 shows a vector quantizer tree which may be created using the improved vector qll~nti7~tion provided by the ~ f~ d embodiment.
Figures 7 and 8 show an improved vector quantizer process which may be used to create the tree shown in Figure 6.
Figures 9a and 9b shows how nodes may be updated in a vector tree by elimin~ting "zero" cells and iterating on the rem~ining nodes.
Figure 10 shows a bitstream used by the preferred embodiment.
Figures 11-16 show detailed views of the data contained in the bitstream rli~cllsse~ with reference to Figure 10.

WO 94/06099 2 1 ~ 3 S~ 3 PCI/US93/08235 DETAILED DESCRI~ION
The present invention is related to improved methods of vector q~l~n~i7~hon In the following des~;liption, for the purposes of explanation, specific types of data, applications, data structures, pointers, indices, and formats 5 are set forth in order to provide a thorough understanding of the present invention.
It will be apparent, however, to one skilled in the art, that the present invention may be practiced without these specific details. In other instances, well-known structures and data are shown in block diagram form in order to not unnecessarily obscure the present invention.
The plGrGlled embodiment of the present invention is structured in a similar manner as shown in the prior art codec as 300 in Figure 3. These may be implen-f~ f d in a general purpose programmed computer system which includes a display, a processor and various static and dynamic storage devices. This also may include a special purpose video coder or decoder which is designed to provide for special purpose applications. Of course, it can be appreciated by one skilled in the art that the methods and app~dlus of the preferred embodiment maybe implemented in discrete logic devices, firmware, an application specific integrated circuit (ASIC) or a pro~,ldnlloing logic array as is suited to an application's requirements.
The plGrellGd embodiment is implemented in a high level programrning language such as the "C" pro~ld""nillg language and run in a general purpose COllll)ulf ~ system. The routines written to implement the preferred embodiment are compiled and assembled into executable object code v. hich may be loaded and runby a processor of such system during system runtime.

W O 94/06099 PC~r/US93/08235 Note that, although the discussion of the present invention has been described specifically with reference to video information, the techniques and apl,~udlllses tli~cusse~l here also have equal application to other areas which utilize vector 4~ Arion~ such as in the audio field, and the specific discussion of video 5 information in this application should not be viewed as limiting the present invention.

PREPROCESSING
The data rate at the output from the codec is used to control the amount of 10 information which is allowed to reach the vector quantization process via the preprocessor 320. This is done at two levels - global and local. Global changes to the sE~atial resolution are made by applying a lowpass input filter to the input image, which changes the bandwidth of the image. The passband width of this filter varies with the error in the required data rate. As the error decreases, the 15 bandwidth of the input filter increases allowing more information to reach the codec. Conversely as the error in desired data rate increases, the input filters bandwidth decreases, limiting the inrol-llation which reaches the codec. Global changes to the temporal resolution are made by determining the difference between current and previous frames. If the change is below a threshold, then the current 20 frame is skipped. The threshold is determined from the data rate error. Another global mtoch~nism by which the lellll~oldl bandwidth is reduced is by extending the definition of error between two frames to allow a transformation on the frame prior to the error calculation. Such transformations include but are not limited to pan and zoom compensation.

~1~3~3 OWO 94/06099 PCr/US93/08235 , ~` ,, The local control of the amount of information which is allowed to reach the vector qll~n*7~tion process includes spatial subsampling and ~ poldl blocks (or more generally, the local determination of motion compensated blocks). The system of the l~lGrcllGd embodiment implements an improved vector quantizer as S shown as 330 in Figure 3, which is very efficient at producing a small set of representative image vectors, referred to as the codebook, from a very large set of vectors, such as an image to be encoded. The image(s) reconstructed by decoder 351 from the codebook generated by such a vector quantizer will be close to the original in terms of some criterion. The performance of the overall 10 cc,n,~,~ssion/decol"~ ssion scheme is further improved in the preferred embo~1im. nt by controlling the content of the bitstream prior to vector quantizer 330 by a preprocessor 320. This preprocessing can be transparent to vector ql~ ;7~l 330. Preprocessor 320 substantially reduces the amount of information used to code the image with a minimum loss of quality. Tags are used in the 15 ~-efe~l~d embodiment to designate vectors that don't change in time instead of coding them. These are known as "no-change" blocks because they don't change according to some threshold. Blocks are also processed using spatial subsamplingin the ~ lled embodiment to achieve better compression. Further, preprocessor 320 can also change the characteristics of the image space in order to increase speed or to improve quality, such as by performing a transformation from an encoding leplesellted in red, green and blue (RGB) to an encoding represented using lllmin~nce and chrominance (YUV).

~ i WO 94/06099 ' PCr/US93/08235 2143~33 NO-CHANGE BLOCKS
In a lJlt;~,led embodiment, a series of decisions are made in order to ~t~ whether to encode an image vector or to send a "no-change" block tag.
In the case of a "no-change" block, conlp,~ssion is almost always improved 5 because an index does not have to be sent for that image block. Encoding speed is improved because there are less image vectors to create a codebook from and find an index for. Decoding time is also improved because the new block does not have to be placed on the screen over the decoded block from the previous frame.
Thus, instead of tr~n~mitting an index referring to an element in a codebook, a no-change tag is sent by preprocessor 320 and passed by vector quantizer 330 specifying that the block has not changed substantially from a previous frame's block at the same position. This is shown and discussed with reference to Figure 4. Process 400 starts at step 401 and retrieves the next block in frame N at step 402. This image block of frame N is then compared by preprocessor 320 to the image block of the same location from the decoded frame N- 1 at step 403 (the decoded frame N- 1 is extracted from the output of the encoder bitstream and decoded). If the error between the blocks is greater than some adaptive threshold ~L, as detected at step 404, then the block is passed unchanged to be coded b~
vector qn,~nti7er 330 at step 406. Otherwise, the block is tagged as a "no-change"
block for VQ 330 and no vector quantization is performed as shown at step 405.
Note that in an alternative embodiment, the no-change block can have a pixel offset associated with it which indicates which of the previous frame's blocks, within a search region, is a good enough match.
In cases where the desired datarate and quality is very high, the image block that passes ~1 as a no-change block is put through a more rigorous test WO 94/06099 2 1 ~ ~ 6 3 3 PCr/US93/08235 before being tagged as a no-change block. The number of frames over which the block has been a no-change block, referred to as the "age" of the block, is checked to make sure it has not exceeded a maximum allowable age. If it has not exceededthe maximum allowable age, the block remains a "no-change" block. If it has excee~le~ the maximum allowable age, the error between that block and the block in the same location of the previous decoded frame is compared to a tighter threshold, for example, 11/2. This is done in order to prevent no-change blocks from remaining in a given location for a long period of time, which can be noti~e~hle to the viewer. A side effect of using block aging occurs when a largenumber of blocks age and reach the maximum age together. This results in a sudden datarate increase, which can trigger subsequent large fluctuations in datarate unrelated to image content. To prevent this from occurring, each block is initi~li7.oA in the preferred embodiment with varying starting ages, which are reset periodically. This can be done randomly, but if it is done in contiguous sections of the image, aging will break up the bi~ a-ll with block headers less often. The main disadvantage of aging "no-change" blocks is a higher datarate, so it is most ~pl~,iate for use when the desired datarate does not demand very high compression, but does demand very high quality. Process 400 ends at steps 408, when a frame is completely processed, as determined at step 407.
The decision to tag a block as "no-change" can still be overturned (e.g. the block data will be tr:~ncmitted) once spatial subsampling has been performed (see discussion below). If the net gain in compression from having a "no-change"
block is lost by the blockhe~der overhead required to tell the decoder that subsequent block(s) are "no-change," then the "no-change" block is changed back 2~ to the blocktype preceding or following it. An example of when this occurs in the WO 94/06099 PCr/US93/08235 2~3~33 current embodirnent is when there is a single 4x4NC (4-2x2 no-change) block in the middle of stream of subsarnpled blocks. The single 4x4NC block requires one header preceding it and one header following it to separate it from the stream of subsampled blocks, yielding 16 bits assuming one byte per blockheader. If the S single 4x4NC block were changed to a subsampled blocli, it would only require one 8-bit index (for a 256 entry codebook), which is less costly than keeping it as a 4x4NC in terms of the number of bits transmitted.
There are a variety of error and threshold calculations that are useful for rlet.. i.. .i--g no-change block selection in process 400. The error criterion used for block co"~ on in the preferred embodiment is a squared error calculation.
SNR (signal power-to-noise power ratio) can also be used in an alternative embodiment, which is useful because it allow larger errors for areas of higher lllmin~nce. This correlates with the fact that the human eye is less sensitive to changes in intensity in regions of greater intensity (Weber's Law). The threshold ~ is initially determined in the preferred embodiment from the user's quality settings, but is allowed to vary from its initial value by adapting to rate control dern~n-ls and to a previous series of frames' mean squared error (frame_mse ).
The approach used in the preferred embodiment is to calculate the no-change threshold and ~ as follows:
ncthreshfactorn = ncthreshfactor (n l)+ ~*long_term_error(n ]) ~/~=0.001) ~ Un = ncthreshfactorn *frame_msen min mse bound < ~ < ma~; mse bound long_term_error, which will be discussed in more detail below in the discussion of the improved rate control mechanism 345, provides a benchmark for achieving 25 the required datarate over a period of time. No-change blocks will be flagged WO 94/06099 ~ ~ 4 ~ ~ 3 3 PC,/US93/08235 more fi~ u~nLly if the long_term_error indicates that the datarate is too high.
Conversely, no-change blocks will be flagged less frequently if the long_term_error indic~tes that the datarate produced is even lower than desired.Instead of reacting instantaneously, 11 is buffered by ~, which effectively controls 5 the time con~Lanl (or "delay") of the reaction time to changing the datarate. This prevents oscillatory datarates and also allows a tolerance for more complex images with a lot of variation to generate more bits, and less complex images with lessvariation to generate less bits, instead of being driven entirely by a datarate .
Rec~use of the range of quality achievable in a given sequence, the no-change 10 threshold 1~ in~; ins the quality of the most recently encoded part of the sequence by taking into accountframe_mse. Frame_rnse is also used by rate control 345 and will be discussed in more detail in the rate control section.

SPATIAL SUBSAMPLING
Another technique ~,e.ro"ned by preprocessor 320 in the preferred embodiment is that of spatial subsampling. Spatial subsampling is used to reducethe amount of information that is coded by vector quantizer ~sO. This results infaster encoding and more compression at the cost of some spatial qualit~ . The primary challenge is to maintain high quality and compression. There are two 20 approaches which can be taken by the preferred embodiment, each with different beneril~. In the first approach, the image is separated into "smooth" and "detailed"
regions by some measure, where blocks that are "smooth" are subsampled according to datarate demands. For example, "smooth" regions may be dclelll~illed by colllp~ing the mean squared error between the original block and 2~ the cc"l~,;,ponding subsampled and upsampled block. This is advantageous Wo 94/06099 PCr/US93/08235 ~143~33 because "smooth" regions that are subsampled usually produce the least noticeable ar~ifacts or error. An additional benefit to this approach occurs when two separate codebooks are generated for subsampled and 2x2C ("change") blocks, and each codebook is shared across several frames. With subsampling based entirely on 5 "smoothness", the two codebooks are able to represent the "smooth" and "detailed" areas well across many frames, because the image vectors in the "smooth" areas are usually very similar across many frames, and the same is true for "det~il~" regions. In the second approach, where zones are used, the location of the block in the image also affects the subsampling decision. The advantages of 10 the second approach include the ability to efficiently (in terms of bits) c~l.. ,.";cate to the decoder which areas of the image to postfilter, and more efficient run length blockheader coding by congregating subsample blocks together.
The subsampling process is discussed with reference to Figure 5a. For subsampling, the image is divided into 4x4 blocks such as shown in Figure Sa.
Each 4x4 block is reduced to a 2x2 block such as 510 if it is selected to be subsampled. A filtering subsampling operation performed in the preferred embodiment actually uses a weighted average of each of the four 4x4 pixel blocks (e.g. block 518, comprising pixels 1-3, 5-7, 9-1 1, and 17-23) for representing the subsampled block 516 (block of pixels 1, 2, 5, and 6 in the case of block 518). As shown, in an alternative embodiment, single pixels (e.g. l. 3, 9, and 11) can be sampled and used for the subsampled block 510, in a simpler subsampling scheme. If the entire image were subsampled using either of these techniques, the number of vectors going into improved vector quantizer 330 would be reduced by a factor of 4, and therefore, the number of codebook indices W O 94/06099 ~ 1 4 3 ~ ~ 3 PC~r/US93/08235 in the final bitstrearn would also be reduced by a factor of 4. In alternative embodi,llenl~, subsampling can also be done only in the horizontal direction, or only in vertical direction, or by more than just a factor of 2 in each direction by sampling blocks larger than 4x4 pixels into 2x2 pixel blocks. During decoding, S improved decoder 351 detects, in a header preceding the indices, that the indices contained in a block such as S 10 refer to subsampled blocks, and replicates each pixel by one in both the horizontal and the vertical directions in order to recreate a full 4x4 block such as 520 (e.g. see, block 521 comprising 4 pixels, which each are equal to pixel 1 in the simple subsampling case). Note that block 521 can also 10 be represented by four y's instead of four I 's, where ~ is a weighted average of block 518. In another alternative embodiment, the pixels between existing pixels can be interpolated from neighboring pixels in order to obtain better results. This, however, can have a detrimental effect on the speed of the decoder.
The method by which "smoothness" is determined is based on how much 15 squared error would result if a block were to be subsampled. The subsampling operation may include filtering as well, as illustrated in the following error calculation. The squared error ~ is calculated between each pixel of a 2x2 block such as 560 shown in Figure 5b (comprising pixels ao-a3) and the average yof its surrounding 4x4 block 555 (comprising pixels ao-a3 and bo-b ; bj + ~, aj~

y calculated from block 518 is used in place of the value of pixel I in 2x2 blocl;
521. If a 2x2 block such as 560 were to be subsampled. then the average of its surrounding 4x4 y (block 555), would be transmitted instead of the four 25 individual pixel values ao-a3. The average yis useful in reducing blockiness.
Thus, as shown with reference to Fi~ure S, the value y is transmitted instead of the W O 94/06099 -' PC~r/US93/08235 2~3~33 ~

four original pixel values ao-a3 of block 530. The squared error EiS then scaled by a weighting coefficient k to app,uxil"ate the human visual system's lumin~nce sensitivity (or the SNR can be used as a rough approximation instead of MSE).
Thus regions of high lllmin~nce are more easily subsampled assuming the 5 subsampling errors are the same. The four scaled errors are then added to generate the error associated with each 2x2 block such as 560:

= ~, k[Y~ *(a~
i = o Yj: quantized luminance value of pixel In order to rank a 4x4 block 500 as a candidate for subsampling, each of the subsampling errors from the four 2x2 blocks of pixels aligned at the corners within the 4x4 500 are added. Blocks are chosen for subsampling from smallest error to largest error blocks until the rate control determines that enough blocks have been subsampled to meet the desired frame size. In an alternative 15 embodiment, edges in the image may be extracted by e~ge detection methods known to those skilled in the art in order to prevent edges from being subsampled.
Basing the decision to subsample on subsampling error has a tendency to preserve most edges, because subsampling and then upsampling across edges tend to produce the largest errors. But, it is also useful in some circumstances to 20 explicitly protect edges that are found by edge detection.
Subsampling purely on the basis of error works in most cases, but there are images where subsampled blocks do not necessarily occur adjacent to each other. Consequently, the appearance of subsampled blocks next to non-subs~mpled blocks can cause a scintill~ting effect that can be visually distracting to 25 a viewer. It appears as if blocks are moving because some blocks are subsampled and others aren't. Secondly, if subsampled blocks and standard encoded blocks WO 94/06099 ~ 1 ~ 3 6 3 3 PCI/US93/0823 .' ' .

are mixed together spatially, considerable bandwidth (in bits) is consumed by having to cle1ine~te block type changes by block headers which are identified bypreprocessor 320 (block headers are discussed in more detail below with reference to the biL~ syntax). In such images, zones can be used in the encoding 5 scheme of an alternative embodiment to reduce the two ~o,elllel-tioned shol lco,l"ngs of subsampling based on error alone. The image is divided by preprocessor 320 into 32 rectangular zones (eight horizontal and four vertical),each of which has a weighting associated with them. Obviously, the number of zones and their sizes can be fairly diverse. In one embodiment, weighting the 10 border zones of the image may be performed so that it is more difficult to subsample the center zones. This assumes that the viewer will pay less attentionto the edges of the image because the camera will be roughly centered on the object of interest. Another embodiment uses fast motion to conceal some of the subs~mpling artifacts. If the motion is not 'fast', as determined by motion lS estim~tiQn algorithms known to those skilled in the art, it may be useful to make it more difficult tO subsample areas of motion. This assumes that the viewer will track objects of motion, and will notice subsampling artifacts unless the motion is fast.
In the second approach of the preferred embodiment, zones are sorted 20 according to their zonal errors, which is the average squared error :
j = ~, zone J
= j # of subsampled pixels in zone j 25 and each zone is weighted according to its location to produce zone error ZE:
ZEj = j*zone_weighr [j], zone j WO 94/06099 , PCT/US93/08235 2~43~3~

Blocks tagged for subs~mI-ling are subsampled in order of best to worst zones, in terms of zone error, until the number of subsampled blocks requested by rate control 345 is reached. Improved decoder 351 is able to determine from the input350 which zones have been subsampled and, depending on certain c,riteria (such as quality settings, etc.), may decide whether or not to postfilter (process 375) those zones during decoding in order to soften blockiness. Becausesubsampling is zonal, decoder 351 knows where to concentrate its efforts insteadof trying to postfilter the entire image. The overhead required to communicate this infonnation to the decoder is minim~l, only 32-bits for the 32 rectangular zone case.
In order to prevent the entire zone from being subsampled, only blocks which have errors less than the edge_mse are subsampled within the zone. The edge_mse value is controlled by the rate control, so more blocks are preserved from subsampling if the compressed frame size desired is large.
edge_rnsen = edge_mse(n l) + x*long_tenn_err~r In an alternative embodiment, the edge_rnse can be weighted so that edges in theimage, extracted by edge detection methods known to those skilled in the art, are preserved from subsampling.

Directional Filtering Spatial redundancy may also be reduced with minimal smearing of edges and detail by performing "directional" filtering in an alternative embodiment. This processing performs a horizontal, vertical, upward diagonal and downward diagonal filter over an area surrounding a pixel and chooses the filter producing the miniml-m error. If the filter length is 3 taps (filter coefficients), co~l~pu~ing the WO 94/06099 ~ 1 ~ 3 ~ 3 PCI/US93/08235 filtered value of pixel 6 in Figure 5a would mean applying the filter to pixels 5, 6, and 7 for a "horizontal" filter, applying the filter to pixels 2, 6, and 10 for a "vertical" filter, applying the filter to pixels 1, 6, and 11 for a "downward diagonal" filter, and applying the filter to pixels 9, 6, and 3 for an "upward 5 diagonal" filter in older to generate a filtered value for pixel 6. For example, in order to p~lru~ the "horizontal filter," the value may be represented asfh wherein f,~ is com~uled in the following manner:
fh=al pixelS+a2pixel6 +a3pL~el 7 wherein al, a2, and a3 are weighting coefficients. al, a2, and a3 may be equal to 0.25, 0.5, and .25, respectively, so that more weight is given to center pixel 6 of the 3x3 block and the resultfh may be computed using computationall~
in~A~.Isive shift operations. Note that these filters can be applied in three tlimen~ional space as well, where the additional dimension is time in yet another alternative embodiment.
Comparing the results of these directional filters also gives information about the orientation of the edges in the image. The orientation of the edge may be extracted by colllp~ing the ratio of the errors associated with orthogonal direction pairs. The first step is to select the direction which produced the minimum error, min_d~rectional_error, and compare this error with the errors associated with the 20 filter in the other three directions. Characteristics which would indicate that there is a directional edge in the direction of the minimum error f~lter include:
the direction orthogonal to that of the minimum error filter produced the maximum error WO 94/06099 ~ PCI/US93/08235 3 6 ~ 3 -22-the maximum error filter has an error significantly larger than the other three directions, particularly when co~ cd to the direction orthogonal to itself If the filtered area has directional errors which are very close to one another, then 5 the area is "non-directional." Areas of "non-directional" blocks can be filtered more heavily by applying the filter again to those areas. The minimum error filter is very adaptive since it may vary its characteristics for every pixel according to the characteristics of the area around the pixel.

YUV TRANSFORMATION
The ~lGfell~d embodiment also uses luminance and chrominance values (YUV) of the vectors for codebook generation and vector quantizer 330 to improve speed and/or quality. The YUV values can be calculated from the red, green, and blue (RGB) values of the pixels in the vectors via a simpler 15 transformation whose reconstruction is computationally inexpensive, such as the following tran~rc,lll,alion which is realizable bv bit shifts instead of multiplication:

y R + s + G

U= R-~

V = B ~ Y
Perforrning codebook generation using YUV in vector quantizer 330 can improve clustering because of the tighter dynamic range and the relative decorrelation among components. Consequently, improvement in quality is noticeable. For situations where encoding speed is important, the chrominance (U,V) values can 25 be subsampled by 2 or 4 and weighted (by shifting, for example) in the vector q~l~n~i7~tion step 330.

WO 94/06099 ~ 1 ~ 3 6 3 3 PCr/US93/08235 ~, . . . .
., .; .

In tne preferred embodiment, lllmin~nce and chrominance is passed to vector quantizer 330 by preprocessor 320 after the preprocessing of RGB values such as ~.ubsam~ling or filtering of vectors of the input image. In an alternative em'~odiment, YUV transformation may be done first and preprocessing such as S subsatnpling can be done after the YUV transformation. At any rate, the resulting preprocessed data passed to improved VQ 330 is in YUV format.

IMPROVED VECTOR QUANTIZER
Vector Qu~nti7~ion (VQ) is an efficient way for representing blocks or 10 vectors of data. A sequence of data, pixels, audio samples or sensor data is often 4u~nt;~e~ by treating each datum independently. This is referred to as scalar q~n~nti7~tion. VQ, on the other hand, quantizes blocks or vectors of data. A
primary issue with VQ is the need to find a set of representative vectors, termed a codebook, which is an acceptable approximation of the data set. Acceptability is 15 usually measured using the mean squared error between the original and reconstructed data set. A common technique for codebook generation is described in Linde, Y., Buzo, A., and Gray, R., "An Algorithm for Vector Quantizer Design," COM-28 IEEE Transactions on Communications 1 (January 1980) (known as the "LBG" algorithm). A technique which employs the LBG algorithm 20 to generate a codebook starts by sampling input vectors from an image in order to generate an initial estimate of the codebook. Then, each of the input vectors is cc"ll~al~,d with the codebook entries and associated with the closest matching codebook entry. Codebook entries are iteratively updated by calculating the mean vector associated with each codebook ently and replacing the existing entry with 25 the mean vector. Then, a determination is made whether the codebook then has WO 94/06099 . . PCr/US93/08235 .

improved signifi~ .ntly from a last iteration, and if not, the process repeats by co~ aling input vectors with codebook entries and re-associating, etc. This codebook generation may be done on a large sequence of images, the training set, or the codebook may be regenerated on each frame. In addition, this technique 5 may be applied to binary trees used in certain prior art vector quantization systems for encoding efficiency.
The improved vector quantizer 330 is organized in a tree structure. Instead of a binary tree as used in certain prior art schemes, at the root of the tree, N child nodes 610, as shown in Figure 6, are generated initially. This may be performed 10 using a variety of techniques. For example, in one embodiment, a segmenter may be used to extract representative centroids from the image to generate the N initial nodes which contain the centroid values. In another embodiment, the initial centroids may be determined from an image by extracting N vectors from the image itself. Prior art binary trees have relied simply upon the establishment of 15 two initial nodes. Binary trees suffer from the disadvantage that the errors in the two initial nodes propagate down to the rest of the nodes in the tree. In the preferred embodiment, N nodes are used wherein the value N varies depending on image characteristics. This advantage is related to the fact that more initial nodes reduce the chances of incorrect binning at the root level. Better quality and faster 20 convergence can be achieved from using N initial nodes in creating the tree, where N adapts to the image and is usually greater than two.
The improved vector quantization process 700 performed on the image is shown and discussed with reference to Figures 6, 7, and 8. The creation of the N
initial nodes is ~rolllled at step 702 shown in Figure 7. The top layer of the tree 25 610 is improved from the N initial nodes by iteratively adjusting the values of the WO 94/06099 ~ i 3 ~ Pcr/uS93/08235 = . .. .

initial nodes and associating vectors with them at step 703. This iterative process is described 'oelow with reference to Figure 8, which shows an iterative node binning/recalculation process. Then, at step 704, the node with the worst distortion is determined, where its distortion is calculated from a comparison 'oetween the node's centroid value and its associated vectors. In the preferred embodiment, mean squared error between the vectors associated with the node and the node's centroid value is used as a distortion measure. Note that the deterrnination of which node is the most distorted may be made using many measures in alternative embodiments, including population, total distortion associated with the node, average distortion associated with the node and/or peak distortion associated with the node. At any rate, once the most distorted node is determined at step 704, then this node is split into two children nodes at step 705.
Of course, even though two children nodes are described and used in the preferred embodiment, more than two children nodes may be created in an alternative embodiment. Then, an iterative process upon the children nodes is performed at step 706 in order to obtain the best representative vectors. This process is described in more detail with reference to Fi~ure 8.
The iterative process such as used at steps 703 or 706 applied to the created children nodes from the most distorted node is shown in Figure 8. This process starts at step 801. At step 80~, it then assigns representative centroids to the child nodes, such as 670 shown in Figure 6, from the group of vectors associated with its parent node. In the case of a root node, all of the vectors of the image are used to create representative centroids. Then~ each of the vectors is associated (or "binned") with the node having the closest centroid. Then, at step 804, the error between the vectors associated with each of the centroids and the WO 94/06099 PCr/US93/08235 ~43633 centroid itself is determined. The err~r c~lcul~hon may be performed using a variety of techniques, however, in the ple;ft;ll~d embodiment, a mean squared c~lcul~tion is used. Once the error calculation has been determined at step 805. it is determined whether the change in the error has become less than a certain 5 threshold value. In step 806, new centroids are calculated from the vectors associated with the nodes from step 803, and this done for all of the nodes from step 803. On a first iteration of the process shown in 706. the change in error will be very large, going from a large preset positive value to the error values calculated. However, on subsequent iterations of the loop comprising steps 803 10 through 806, the change in error will become smaller, eventually becoming less than the threshold values. If the change in total error associated with the node currently being split is not less than the threshold value as determined at step 805, then the new centroids are recalculated at step 806, and process 703 (706) continues to repeat steps 803 through 806 again, as necessary. This is done until 15 the change in error is less than the predetermined threshold value as detected at step 805. Once the change in error becomes less than the threshold value as detected at step 805, then process 703 (706) ends at step 807 and returns to process 700 of Figure 7.
Once this iterative process is complete, at step 707 in Figure 7. it is 20 determined whether the desired number of terminal nodes in the tree have been created. Each time a node is split, two or more additional child nodes are produced in VQ tree 600. Thus, in the preferred embodiment. the total number of terminal nodes desired determines how many times nodes in VQ tree 600 will be split. Process 700 continues at step 704 through 707 until the desired number of 25 terminal nodes in the hree have been created. Once the desired number of terminal WO 94/06099 ~ ~ ~ 3 ~ 3 ~ PCrtUS93/08235 ..

nodes in the tree have been created, then process 700 is complete at step 708, and the codebook may be transmitted on the output bitstrearn to packer/coder 340 shown in Figure 3.
The type construct used in the ~)rert;llc;d embodiment for a node is defined 5 in the "C" programming language as follows:
typedef struct tnode ( unsigned long *centroid; // pointer to centroid for this node unsigned long *vect_index_list;// pointer to list of vector indices associa~ed with this node unsigned long num_vect; // number of vectors ~csnci~pd with this nodc unsigned long d;sLu.liu.,; // total distortion ~o~ d with this node unsigned long avg_dist; // Average distortion associated with this node unsigned long pealc_dist; // Peac distortion ~c~oci~rpd with this node u;tsigned long percent_dist; // percentage distortion ~ccoci~lpd ~ith Ihis nodeunsigned long num_children; // num'oer of children timsigned long ic_method; // method for initi~li7ing ~his nodc struct tnode ~*children; // pointer to a list of structures for thc child nodes of this node struct tnode *parent; // pointer to the parent of this node unsigned char terminal; // flag to indicate if this is a terminal node unsigned long *childrencptrs; // pointer to an ar..ay of pointers to // centroids of children (used to // simplify and spced up distortion // calcula~ion) }

Thus, the nodes comprising a tree VQ such as 600 each have a datum such as that defined above which may m~int~in certain information associated with them such as various distortion measures, number of binned vectors, number of children~
etc. This information is useful for the tree creation process discussed above.
The vector quantization process 700 of the preferred embodiment for the creation of a VQ tree such as 600 is pc. rc" ",ed using a number of novel techniques.
First, an adaptive convergence threshold (i.e. that used in 805) is used to control the number of iterations used to generate the codebook tree. This works in one of the following two ways:

WO 94/06099 PCr/US93/08235 2143~33 1. If the complete tree is to be updated, then a looser convergence criterion is applied to the initial N nodes. The complete tree may need to be updated in a case where a scene change has occurred or the image has changed signific~ntly from the previous image.
2. If the root node from a previous tree is used in constructing the current tree then no iterations are performed on the root node.
Root nodes may be reused where a like sequence of images is encoded and no scene change has yet been detected. Thus, N
initial nodes such as 610 can be reused from a previous frame's VQ.
Second, a modified distance measure is used in the preferred embodiment to improve reconstructed image quality. Usually mean squared error (mse) between image vector and codebook entry is used to determine the closest matching codebook entry to a given vector, for example, at step 8()3 in Figure 8.
15 In the early stages of tree generation the ~ rel,~,d embodiment modifies this calculation to weight large errors more heavily than is the case with squared error.
In this manner, large errors are weighed more heavily than smaller errors.
Third, multiple criteria are used to determine which nodes should be split.
Measures which may be employed include, but are not limited to 1. Total distortion associated with a specific node, 2. Average distortion associated with a specific node.
3. Population associated with a specific node.

4. Percentage distortion associated with a specific node.

5. Maximum distortion associated with a specific node.

WO 94/06099 2 1 ~ 3 ~ 3 3 PCI/US93/08235 .

6. Ratio of maximum to lI~ illllllll distortion associated with a specific node.
Total distortion associated with a node is used in the preferred embodiment;
however, better quality results may be achieved if population is used as a measure 5 in the final stages of tree generation in an alternative embodiment. If mean squared error is used as the distortion measure, then the total distortion is the sum of the mean squared errors. The use of the other distortion measures. or combinations thereof, may be used in yet other alternative embodiments, each having certain advantages according to image content, or desired quality.
Fourth, multiple retries are attempted in order to split nodes. Occasionally, an attempt to split a specific node fails. In this case, a number of other initial conditicns are generated which will assist in leading to a successful split. For example, one way in which this may be performed is by adding noise to an initial split. For certain images characterized by flat or very smooth varying color or Illmin~nce areas, node splitting is difficult. A small amount of random noise is added to the image vectors prior to splitting. The noise is pseudorandom and has a range between zero and two least significant bits of the input image data. One manner in which the noise is generated is to use a pseudorandom noise generator.
This value is added to each of the RGB components of each pixel of each vector to be encoded. The random noise added to each of the RGB components of each pixel will differentiate them enough in order to achieve a successful split. More generally, assurning that a decision has been made on v~hich node tO split. the alg.~liLIIlll does the following:
1. Generate K candidate initial nodes by subsampling the vector list associated with the node.

WO 94/06099 PCr/US93/08235 .

2~4~33 2. Cluster the vector list using these initial nodes.
3. If the clustering fails (i.e. all the vectors cluster to one node), identify this node as having failed to cluster with this method.
4. When the next attempt is made to split this node, use a different initial estimate for the node centroids. Techniques for generating this estimate include but are not limited to:
a. Perturb the centroid in the parent node; or b. Pick the most distorted vectors in the nodes vector list as the initial centroids.
5. Further attempts are made to cluster using these initial nodes. If all the methods fail to produce a split in the vector list the node is tagged as a terminal node and no further attempts are made to split it.
Fifth, reuse first layer of the codebook tree between multiple frames. In 15 many image sequences, the major image features change slowly over time (for example, background images tend to change or move slowly). The top layer of the codebook tree 610 comprising N initial nodes captures these features.
Enhanced ~lru~mance in terms of coll~pulational speed and improved image quality can be obtained by reusing the top layer of the tree from one frame to the 20 next. This reuse may be overridden from a higher level in the codec. For example in the case of a scene change, which is detected by the encoder, higher quality mav 'De achieved if the root node is regenerated rather than being reuse~l.
Sixth, in order to best use the available entries in a codebook, it is common to remove the mean value ûf the vectors prior to coding. While this leads to better 25 reconstructed image quality, it causes additional complexity at the decoder. The ~WO 94/06099 ~! 1 4 3 6 ~ 3 PCI/US93/08235 ed embodiment utilizes a technique which gives many of the advantages of mean residual VQ without the decoder complexity. The technique works as follows. The mean value is calculated for a large image or "zone," and then thismean is subtracted from all the vectors in the large zone. The residual vectors are S encoded in the usual fashion. At the decoder, codebooks for each of the large zones are reconstructed. This is done by adding the mean values of the large zones to the residual codebook. The result is the generation of as many codebooks as there were large zones at the encoder.

VARIABLE SIZE, SHARED, AND M'~1LTIPLE CODEBOOKS FOR IMAGES
In the preferred embodiment, each image is associated with a codebook which has been adapted to the characteristics of that image, rather than a universal codebook which has been trained, though a combination of fixed codebook and adaptive codebook is also possible in altemative embodiments. In alternative 15 embodiments, each irnage need not be limited to having exactly one codebook or a codebook of some fixed size. Alternative embodiments include using codebooks of variable size, sharing codebooks among frames or sequences of frames. and multiple codebooks for the encoding of an image. In all of these alternative embodiments, the advantage is increased compression with minimal loss in 20 quality. Quality may be improved as well.

Variable Size Codebooks For a variable size codebook, the nodes in the tree are split until some criterion is met, which may occur before there are a specified number of terminal 25 nodes. In one embodiment, the number of codebook vectors increases with the W O 94/06099 PC~r/US93/08235 .

number of blocks that change from the previous frame. In other words, the greater the number of no-change blocks, the smaller the codebook. In this embodiment, codebook size is obviously related to the picture size. A more robust criterion, which is used in the preferred embodiment, depends on maintaining a 5 frame mean squared error (not including no-change blocks). If 128 2x~ codebook vectors are used instead of 256, the net savings is 768 bytes in the frame. This savings is achieved because each 2x2 block comprises a byte per pixel for ll-min~nce information and 1 byte each per 2x2 block for U and V chrominance information (in the YUV 4: 1: 1 case). Reducing the number of codebook vectors from 256 to 128 yields 128 6 = 768 bytes total savings. For images where 128 codebook vectors give adequate quality in terms of MSE, the 768 bytes saved may be better used to reduce the number of subsampled blocks, and therefore improve perceived quality to a viewer.

Shared Codebooks Another feature provided by the ~ r~-llc;d embodiment is the use of shared codebooks. Having one or more frames share a codebook can take advantage of frames with similar content in order to reduce codebook overhead. Usin~ a shared codebook can take advantage of some temporal correlation which cannot be 20 efficiently encoded using no-change blocks. An example of such a case is a panned sequence. If two frames were to share a 256 element codebook, the savings would be equivalent to having each frame use separate 128 element codebooks, but quality would be improved if the frames were not completely imil~r. Obviously, the separate 128 element codebook case could use 7 bit 25 indices instead of 8 bit indices, but the lack of byte alignment makes packing and WO 94/06099 ~ 1 4 3 ~ ~ 3 Pcr/us93/0823~
.

unpacking the biL~ eam unwieldy. Reduced codebook overhead is not the only advantage to using a shared codebook. For example, lempolal flickering can also be reduced by increasing the correlation in time among images by using the same codebook. There is also a gain in decoding speed since an entirely new codebook 5 doesn't have to be unpacked from the bitstream and converted back to RGB with each frame.
In order to make sure that the shared codebook constructed from previous frame(s) is still a good representation of the frame to be encoded, the shared codebook can either be replaced with a new codebook, or updated in pieces.
10 First, the frame is encoded using the shared codebook, and thefra~?te_mse (the mean squared error'vetween the original and decoded frame) is calculated. The shared codebook is replaced with a new codebook if theframe_mse is greater than theframe_mse from the previous frame or the averageframe mse from the previous frames by some percentage. If theframe_mse passes this test, the shared 15 codebook can still be entirely replaced if the number of blocks with an MSE over some percentage of the average MSE (i.e. the worst blocks) for the entire frame is over some number. In this case, the encoder assumes that it is too difficult to fix the worst error blocks with only an update to the codebook, and will regenerate the entire codebook. Alternatively, the encoder may chose to generate the 20 codebook update first, and then check how many worst error blocks there are, and then generate a completely new codebook if there are more than some threshold amount of bad blocks.
The ~lerell~d embodiment updates the shared codebook by reusing the structure of the tree used to generate the shared codebook, as described above in 25 the vector qll~n~7~hon section. Each image vector from the new frame is Wo 94/06099 PCr/US93/08235 associated with one of the terrninal nodes of the tree (i.e. with a codebook vector).
This is achieved by starting at the root of the tree, choosing which of the children is closer in terms of squared error, and choosing which of that child's children is a best match, and so forth. An image vector traverses down the tree from the root 5 node toward a terminal node in this fashion. Using the structure of the tree instead of an exhaustive search to match image vectors with codebook vectors improves encode time, though an exhaustive search could also be performed. Also, the tree structure is useful in generating new nodes in order to update the shared codebook.
The codebook update process takes several steps. First~ zero cells such as 901 (codebook vectors with no associated image vectors) are located and removed from the tree 900, a branch of which is shown in Figure 9a. The terminal node number (i.e. codebook index) associated with the zero cell is noted so codebook updates may replace the codebook entry that was a zero cell. The tree pointers are changed so that 902 now points to children 912 and 913. This is shown as transformed tree 920 in Figure 9a. The tree then splits nodes (Figure 9b) selected by some criterion, such as those n nodes with the worst total distortioll, with a method described above with regard to improved vector quantizer 330 and as shown in Figure 9b by transforming tree 920 as shown in Fi~ure 9b to tree 930.
20 Terrninal nodes that were discarded because they were either zero cells~ such as 901, or became parents by splitting are tagged to be overwritten with new updated codebook vectors. Finally, new children from the node splits overwrite these ~codebook vectors which are tagged to be overwrilten. The actual overwrite occurs in the decoder, which is given the overwrite information via the bitstream (~, 25 discussion below). If there are no zero cells, each node split would require 2 Wo 94/06099 ~ ~ 4 ~ PCr/US93/08235 .

codebook vector slots, one of which could be that of the nodes' parent before itwas split. The l~l,lain~lg child can be tran~mitte~l as an additional codebook vector instead of just a replacement for a discarded codebook vector.
With codebook sharing, the codebook that is entirely generated from a 5 frame or set of frames is set to a size (e.g. 50%) smaller than the maximum codebook siæ (e.g. 256) to allow for additional codebook vectors to be added by frames using the shared codebook.
An alternative splitting and replacement method does not require that a parent, which used to be terminal node, be replaced. Instead, by constraining that 10 one of the two children be equal to the parent, the parent does not have to be replaced. The other child replaces either a zero cell or gets sent as an additional codebook vector.

Multiple Codebooks In yet another embodiment, multiple codebooks can be associated with an image by generating a separate codebook for each blocktype, or by generating separate codebooks for different regions of the image. The former case is very effective in increasing quality with minimal loss of compression (none if the codebook is shared), and the latter case is very effective in increasing compression 20 ratio with minim~l loss of quality.
Using separate codebooks to encode subsampled and non-subsampled image vectors provides several advantages over prior art techniques. Independenttrees are tailored specifically to the traits of the two different types of blocks, which tend to be "smooth" for subsampled regions and more "detailed" for blocks 25 which are not s~lbs~mpled. The block types are separated by the error calculation WO 94/06099 PCr/US93/08235 ~ 3 ~ 3 3 described in the section on spatial sl~bs~mpling. The separation between "smooth"
and ''~l~ot~ileA'' regions occurs even when the compression desired requires no subsampling, because the separate codebooks work very well when the "smooth"
and "det~ A" blocks are separately encoded. Note that each index is associated 5 with a codebook via its blocktype, so the number of codebook vectors can be doubled without changing the bits per index, or increasing the VQ clustering time.
This results in a noticeable improvement in quality. Also, the subsampled blocks codebook and 2x2C blocks codebook can be shared with the previous frame's codebook of the same type. In such a case, it is even more important to keep 10 "smooth" regions and "detailed" regions separate so there is consistency within each codebook across several frames. Note that this separation into detailed and smooth areas is a special case of the more gene-ral idea of deflning separate trees for image categories. The categories can be determined with a classifier which identifies areas in an image with similar attributes. Each of these similar areas are 15 then associated with its own tree. In the simple case described above, only two categories, smooth and detailed, are used~ Other possible categorizations include edge areas, texture, and areas of similar statistics such as mean value or variance.
As mentioned briefly, multiple trees may be associated with different regions in the image. This is effective in reducing the encode time and increasing 20 the co~ ssion ratio. For example, a coarse grid (8 rectangles of equal size) is encoded with eight 1 6-element trees. The worst error rectangular regions are then split again so that each half of each rectangular region uses a 1 6-element tree. This continues until there are 16 rectangles, and therefore a total of 256 codebook vectors. Each index can be encoded using only 4 bits instead of 8, giving an 2~ additional 2:1 compression. If the image is divided into 16 fixed initial regions, WO 94/06099 ~ 1 4 3 ~ 3 3 Pcr/us93/08235 .

~, ~

with no further splitting of the regions, the encode compute time is significantly reduced. This technique is particularly well suited for lower quality, higher conl~,Gssion ratios, faster encode modes. A comp~ ~ise between using many small codebooks for small pieces of the image and one 256 entry codebook for theS entire image can be most effective in m~int~ining quality while gaining some additional compression where the quality won't suffer as much. In such a cûln~lull~ise~ much smaller codebooks are used only for portions of the image that are very homogeneous and only require a few codebook vectors, and the regular 256 entry codebook is used for the rest of the image. If the portion of the image 10 a~soci~ted with a much smaller codebook is constrained to be rectangular, it will require almost no overhead in bits to tell the decoder when to switch to the much smaller codebook, and hence the smaller indices (4-bits for 16 entry codebooks or 6 bits for 64 entry codebooks). If the region associated with each codebook is not constrained to be rectangular, the quality can be improved with segmentation 15 techniques known to those skilled in the art, which group similar pixels into a region.

RATE CONTROL
Rate control 345 is an important element of the improved video 20 compression system when the cc "~ ssed material is meant to be decoded over alimited bandwidth channel. To maintain N frames/second in a synchronous architecture, or over a network or phone line, decoder 351 must be able to read one frame of data over the limited bandwidth channel, decode the information, and display the image on the screen in l/Nth of second. Rate control 345 attempts to25 keep the ~ imulll frame size below some number, which depends on the W O 94/06099 PC~r/US93/08235 ~3~3 ~

application, so that the time taken by reading the data over the limited bandwidth channel is reduced. This is accomplished in two steps: ( 1 ) determining what the desired frame size is from a datarate point of view; and (2) using this desired frame siæ in conjunction with quality requirements (either defined by a user or in 5 some other manner) to control parameters in the encode process.
The rate control scheme determines what the desired frame size is, based on past ~lÇ~ ,allce and desired datarate. The targetfra~le_lengt11 is calculated as:

twgetframe-length = d eSs~rreddfrdata ratete The desired frame length for the current frame N is equal to the targetframe_length, dampened by an error term frame_error which may be averaged over some number of frames, such as a second's worth of video data:

desiredframe_length = targetframe_lengt/l + frame_err~7r Note that frame_error, which is the overshoot or undershoot that will be- allowed, is averaged as an IIR (infinite impulse response) filter in a recursive fashion. This may also be implemented as an FIR (finite impulse response) filter in an alternative embodiment. The value of a affects how quickly the current frame error 20 (targetframe_length - avgframe_length ) forces the long term frame error (frame_error) to respond to it. Also, the current error is defined as the difference cn the targetf rame_length and the average of the frame lengths of some number of frames (avg f rame_length ), such as a seconds worth of data. This rate control scheme maintains an average datarate over the past second that does 25 not exceed the desired datarate. Fluctuations in frame size occur at the per frame WO 94/06099 ~ 1 4 3 ~ 3 3 PCI/US93/08235 .

level, but these fluctu~tions are dampened by averaging effects. These relationships are determined as follows:
(frame_error )n = (1-)f~rame_error )n-l + o~(targetframe_length - (avg frame_lenglh )n) (avgfrarne-length) n = ~"a i*frarne_size j i=n-k n where ~,aj = I
i=n-k After the desiredframe_length is determined for frame N, it iS used to influence the encoder ~ etel~ (ncthreshfactor and edge_mse) which control how much temporal processing and spatial subsampling to apply in those embodiments where temporal filtering and spatial subsarnpling are used. These encoder parameters are set by the spatial and temporal quality preferences d~ ed by the user, but they are allowed to fluctuate about their quality settingaccording to how well the system is keeping up with its datarate demands. Ratherthan allowing these parameters to fluctuate considerably over a short period of time, they track a long terrn error calculated as follows:
(long_terrn_error) n = (1~ long_term_errnr) n l +
~ argetframe_length)- (avgframe_lengt12) n ) Thus, the only distinction between the calculations for the long_terln_errar and the frarne error is the difference between a and ~. Values u hich have been deterrnined to be effective are a=0.20 and ~=0.02 which are used in the preferred embodiment, although it can be appreciated by one skilled in the art that other weighting values of a and ~ may be used.

WO 94/06099 . PCr/US93/08235 ., ' ............. ...........! .' If long_terr~_error is not used to control the values of encoder parameters for spatial subsampling and no-change blocks, the desired frame length can still be used to keep track of how well the datarate is being maintained, given that no-change and subsampling thresholds are determined only by the user's quality 5 settings. However, this doesn't guarantee that subsampling and no-change blocks can reduce the frame si_e to the desiredframe_size. In such a case, the value longtertt._error is used to reduce the quality by changing subsampling and no-change block parameters, ncthreshfactor and edge_rr.se, and therefore reduce the datarate.

TRANSMISSION OF CODEBOOK INDICES
After an image has been associated with indices to a codebook via vector q~l~nti7~tinn by improved process 330, the biL~.LI~;alll can be packed more efficiently than prior art techniques to allow for the flexibility of future compatible 15 changes to the bitstream and to cc"l,l-lu"icate the information necessary to decode the image without creating excessive decoding overhead. The indices may each be transmitted as an index to the codebook or as offsets from a base index in the codebook. In the forrner case, 8 bits are required per image vector to indicate which of the vectors of a 256 entry codebook is the best match. In the latter case, 20 less bits may be required if there is a lot of correlation between indices, because the differences between indices are generally significantly less than 256. A
combination of the two is usually necessary since some parts of the images may have indices that are far from one another, and other parts of the images have strongly correlated indices.

~WO 94/06099 2 ~ ~ 3 6 3 3 Pcr/us93/o823s ~ , . . .

As shown with reference to Figure 10, the bitstream syntax includes a sequence header 1001, chunk header 1011, frame headers 1021, and codebook headers 1012, 1014. These are followed by the codebook indices, which are deline~tefl by block type headers which inrlic~te what blocktype the following indices refer to. 2x2 change (2x2C), 2x2 no-change (2x2NC), 4x4 no-change (4x4NC), 4x4 change (4x4C), subsampled (4x4SS), different combinations of mixed blocks, and raw pixel blocks are examples of useful blocktypes. Decoder 351 can then reconstruct the image, knowing which codebook vector to use for each image block and whether or not to u~)san~yle. The bitstream syntax will nowbe discussed.
Sequence header 1001 conveys i~ .na~ion associated with the entire sequence, such as the total number of frames, the version of the coder that the sequence was encoded with, and the image size. A sequence may comprise an entire movie, for example. A single sequence header 1001 precedes a sequence of images and specifies information about the sequence. Sequence header 1001 can be almost any length, and carries its length in one of its fields. Several fields ~;ul~enLly defined for the sequence headers are shown in Figure 1 1. Sequence header 1001 comprises a sequence header ID 1101 which allows the decoder to identify that it is at a sequence header. This is useful for applications which allow random access playback for the user. Further, sequence header l()Ol comprises a length field 1102 which specifies how long the sequence header 1()01 is. The next field in sequence header 1001 is number of frames field 1103 which defines the nllln~l of frames in the sequence. This is an integer value which is stored as an unsigned long word in the ~ d embodiment allowing sequence lengths of up to 232 frames. The next field 1 104 in the sequence header is currently reserved, WO 94/06099 PCI/US93/0823~

and the following two fields 1105 and 1106 define the width and height of the irnages in the sequence. The last field in sequence header 1001 is the version field 1107 which is an integer field defining the current version of the enco~ling/decoding apparatus being used. This is to distinguish newer sequences 5 from older sequences which may have additional features or lack certain features.
This will allow backward and upward compatibility of sequences and enc~ding/decoding schemes. The sequence header may also contain an ASCII or character string that can identify the sequence of images (not shown).
Returning to Figure 10, Chunk header 1011 carnes a chunk type which 10 conveys information about the next chunk of frames, such as whether or not they use a shared codebook. The chunk header can also specify how many codebooks are used for that chunk of frames. Chunk header 1011 precedes a "chunk" of frames in the sequence. A chunk is one or more frames which is distinguishable from another "chunk" in the ~Icrt~d embodiment by such apparatus as a scene 15 change detector algorithm. In another embodiment, groups of frames may be associated using another technique, such as the rate control mechanism.
Two codebook headers are shown in the example sequence 1000 of Figure 10 which allow the use of two codebooks per frame. An example of the use of two codebooks is the use of a fixed codebook (static for the "chunl;" of frames) 20 and an adaptive codebook (which changes for every frame). The codebook type and size are contained in codebook headers 1012 and 1014 as shown in Figure 13a. Each codebook header, such as 1012 or 1014 shown in Figure 10, contains a codebook type field 1301, which defines the codebook type--for example, whether it is fixed or adaptive. Codebook types include YUV (subsampled UV or 25 non-subsarnpled UV), RGB, and YUV update codebooks. Other types are ~WO 94/06099 ~ 1 4 3 ~ ~ 3 PCr/US93/08235 conlell,plated within the spirit and scope of the present invention. For an "update"
codebook, the updates to the codebook are transmitted following the codebook header. The size of the codebook is specified in bytes in field 1302 so that thedecoder can detect when the next field occurs. If the codebook type is an "update"
codebook (i.e. to a shared codebook), then the inforrnation 1013 (or 1015) shownin Figure 13b is expected immediately following the codebook header 1012 (or 1014). This update codebook will contain a bitrnap 1370 which identifies those codebook entries which need to be updated. This field is followed by vector updates 1371 - 1373 for each of the vectors which is being updated. In this manner, instead of the entire codebook being regenerated, only selected portionsare ~ teA, resulting in a further reduction of the datarate. If YUV with U and Vsubsampled is used, each of the update vectors 1371-1373 comprise 6 bytes, four for lllmin~nce of each of the pixels in the block and one byte each for U and V.Updates of codebooks were discussed with reference to Figures 9.t and 9b above.
In order to furtherreduce codebook overhead, codebooks such as 1013 and 101~ are transformed into YUV (luminance and chrominance) format~ where U and V are subsampled by a factor of 2 in the vertical and horizontal directions (YUV 4:1:1). Thus, the codebooks are further reduced in size by transmitting subsampled UV information reducing the codebook size by a factor of 2.
As shown with reference to Figure 12, frame header 1021 contains the image size again in width field 1201 and height field 1202. to allow for varyingframes sizes over time. Frame header 1021 also contains a frame type field 1203,whose bit pattern indicates whether it is a null frame for skipped frames, an entirely subsampled frame, a keyframe, or a frame sharing a codebook with another frame. Other types of frames are contemplated within the spirit of the WO 94/06099 ' PCr/US93/08235 21~36~3 invention. The subsampled zone field 1204 is a 32-bit bitmap pattern which shows which zones, if any, are subsampled allowing for a maximum of 32 zones in the ~l~fe-l~d embodiment.
Block headers shown in portion 1022 in Figure 14 inform decoder 351 5 what type of block is associated with a set of indices, and how many indices are in the set. This is shown with refe.e"ce to Figure 14. The first 3 bits of header 1401 indicate whether the following set of indices are 2x2C blocks (change blocks), 4x4NC blocks (no-change blocks), 4x4SS blocks (subsampled blocks), rnixed blocks, or raw pixel values. If the first three bits specify that the blocktype lO is not rnixed, the last 5 bits of header 1401 is an integer indicating how many indices 1402 follow the block header 1401. This is called a "runlength" block header. The blockheader may also specify mixed blocks, such as a mix of 2x2C
and 2x2NC blocks. In such a case, the 5 bits in the header reserved for length specifies how many 4x4s of mixed 2x2C and 2x2NC blocks are encoded.
15 ~ltçrn~tively~ one of these 5 bits may instead be used to allow for more mix possibilities. A bitmap follows, padded to the nearest byte. In the 2x2C-2x2NC
mix example, the bitmap specifies with a " l" that the blocktype is 2x2C, and with a "0" that the blocktype is 2x2NC. The blocks can be mixed on a 4x4 granularity as well. It is simple to calculate if the bitmap header will reduce the number of bits 20 over a runlength header. A sequence of alternating blocktypes like "10010110101" would 'oe coded well with a bitmap blockheader, whereas long runs of one header type (e.g. " 1 1 1 1 1 1 11 1000000000") would be betler coded with the runlength header type. The blockheader that codes the blocks more eff1ciently is chosen. The bitmap header allows the efficient coding of short run 2~ blocks which can occur frequently.

~ W O 94/06099 2 1 4 3 ~ 3 ~ PCT/US93/08235 Because of the overhead of two bytes of a block type header 1401 before and after a block which is tagged as a "no-change" block in the middle of a stream of "change" blocks, the runlength blockheaders in the preferred embodiment only disturbs the structure of the indices with headers if there at least 4 2x2 no-change blocks in a row. The runlength headers in the preferred embodiment requires that4-2x2NC (no-change) blocks must occur together to make a 4x4NC (no-change) block, in order to distinguish them in the bitstream with headers such as 1410. A
block header such as 1410 which indicates that the following N blocks are of the4x4NC (no-change) type need not waste any bytes with indices since the previous frame's blocks in the same location are going to be used instead. Decoder 351 only needs to know how many blocks to skip over for the new image. 2x2C
blocks indices such as 1402 do not need to occur in sets of 4 because actual pixel values may be used or even singular 2x2 blocks. If actual pixel values or singular 2x2C and 2x2NC blocks are not supported in some implementations, assuming lS 2x2C blocks occur in fours can increase the number of blocks associated with the 2x2C blockheader such as 1401, and consequently decrease the effective overhead due to the blockheader. For example, a block may identify eight 2x2C (change) blocks and interpret that as meaning eight groups of 4 2x2C blocks, if singular 2x2 blocks are not supported. (See an example of this in Fig 15, 1~ where 2-2x2C blocks are interpreted as two sets of 4-2x2C blocks).
Additionally, the indices 1402 in Figure 14 referring to the 2x2C blocks do not have to be from the same codebook as the indices 1421 referring to the 4x4SSblocks. This bitstream flexibility allows the support of higher quality at very little reduction in compression by having more than 256 codebook vectors without WO 94/06099 = PCr/US93/08235 .,, .. ,. . , --2~3~33 having to jump to a non-byte aligned index size (such as an unwieldy 9 bits for 512 codebook vectors).

INDEX PACKING
If image blocks are in close proximity in the codebook and are also similar in RGB color space, it is advantageous to use a base address when coding the indices, instead of just listing them in the bitstream. Because the codebook vectors are generated by splitting "worst error" nodes, similar image vectors tend to be close together in the codebook. Because like image blocks tend to occur together in space in the image (i.e. there is spatial correlation among the blocks), index values that are close together tend to occur together. Assignment of codebook indices can also be ~l ro~ ed in such a way that differences in indices over space can be minimi7ed An example of how this may be used to reduce the number of bits losslessly is shown and discussed with reference to Figures 15 and 16. This packing process is performed by 340 in encoder 301 shown in Figure 3, and unpacking is performed by process 370 in decoder 351.
In Figure 15, the codebook indices in bitstream 1500 each require 8 bits if the codebook has 256 entries. In other words, each index comprises a complete reference to an element of the codebook. As discussed above, due to spatial 20 correlation, these index values can be reduced further by using offsets from a base address. This is shown in Figure 16. In Figure 16, the codebook indices each require only 4 bits if indices are represented as offsets as being from -8 to +7 from a transmitteA base address. This is shown as 1601 in bitstream 1600. Base address 1601 is used as the starting point, and the offset value of a current block 25 such as 1604 can refer to the change in the index just preceding the current block ~WO 94~06099 ;! 1 4 3 S 3 3 PCI/US93/08235 , . c . . -1603. The base address header 1601 is required to be transmitted defining the base address, and t'hat differential coding is being used. Regions which have a large, variable set of codebook indices (from one end of the codebook to the other), are more efficiently coded using the tr~ncmicsion of complete indices such 5 as shown in Figure 15, and regions which are similar on a block level are moreefficiently coded using a bitstream such as 1600 shown in Figure 16. Using offsets from a base address, as is shown in Figure 16, is equally lossless as the technique shown in Figure 15 since the original index values can be calculated by adding offsets to the base address.
Thus, an invention for compressing and decompressing video data has been described. In the foregoing specification, the present invention has been described with reference to specific embodiments thereof in Figure I through 16.It will, however, be evident that various modifications and changes may be made thereto without departing from the broader spirit and scope of the present 15 invention as set forth in the appended claims. The specification and drawings are, accordingly, to be regarded in an illustrative rather than a restrictive sense.

C ~

Claims (77)

What is claimed is:

1. A method of vector quantization of an image comprising the following steps:
a. initializing N initial nodes in a vector quantizer tree:
b. sampling a vector from said image;
c. determining a node in said vector quantizer tree which is a best representative sample of the vector sampled from said image;
d. associating the vector with said node in said vector quantizer tree;
e. sampling a next vector from said image;
f. repeating steps c-f until there are no more vectors to be sampled from said image, said next vector becoming said vector;
g. determining which of the nodes in said tree is the most distorted node in said tree;
h. splitting said most distorted node into two children nodes:
i. associating a first portion of the vectors associated with said most distorted node with a first of said children nodes, and a second portion of the vectors associated with said most distorted node with a second of said children nodes;
j. determining a current error of the two children nodes compared to the first and second portions of the vectors:
k. if the change in error between the current error and a previous error is less than an error threshold then proceeding to step 1 otherwise determining new values of said first and second children, and proceeding to step i, said current error becoming said previous error;

1. repeating steps g through 1 until the number of terminal nodes in said vector quantizer tree has reached a desired population; and m. associating indices with each of the terminal nodes in said vector quantizer tree.

2. The method of claim 1 further comprising the step of transmitting a sequence of indices from said vector quantizer tree representative of an index of a terminal node in said vector quantizer tree associated with each said sampled vector in said input image.

3. The method of claim 1 wherein the step of determining the most distorted node comprises determining whether the average distortion of the node compared to each of vectors sampled from said input image associated with the node has exceeded a threshold.

4. The method of claim 1 wherein the step of determining the most distorted node comprises determining whether the total distortion of the node compared to each of the vectors sampled from said input image associated with the node has exceeded a threshold.

5. The method of claim 1 wherein the step of determining the most distorted node comprises determining whether the total population of sampled vectors from said input image associated with said node has exceeded a threshold.

6. The method of claim 1 wherein the step of determining the most distorted node comprises determining whether the percentage distortion of the node compared to each of the vectors sampled from said input image associated with the node has exceeded a threshold.

7. The method of claim 1 wherein the step of determining the most distorted node comprises determining whether the maximum distortion of the node compared to each of the vectors sampled from said input image associated with the node has exceeded a threshold.

8. The method of claim 1 wherein the step of determining the most distorted node comprises determining whether the ratio of maximum to minimum distortion of the node compared to each of the vectors sampled from said input image associated with the node has exceeded a threshold.

9. The method of claim 1 wherein the step of determining the node which is the best representative sample of the vector sampled from said image comprises determining the mean squared error between the sampled vector and the node.

10. The method of claim 9 wherein the step of determining the mean squared error is weighed more heavily towards large errors during an early portion of said vector quantization, and weighed less heavily towards large errors during a latter portion of said vector quantization.

11. The method of claim 1 wherein the step of creating N initial nodes comprises using N initial nodes from a previous vector quantization which has been performed on a previous image.

12. The method of claim 1 wherein further comprising the additional step of adding a pseudo-randomly generated value to the vector sample from said input image prior to splitting said most distorted node.

13. The method of claim 1 wherein the step of determining the node which is the best representative sample of the vector sampled from said image comprises determining the node which has luminance and chrominance (YUV) values closest to the sampled vector from the image.

14. The method of claim 1 further comprising the step of generating a separate vector quantizer tree for different zones in said image.

15. The method of claim 14 further comprising a step of determining different zones in said image which have variable sizes.

16. The method of claim 1 which is applied to a sequence of images, the creation of a new vector quantizer tree being performed when a scene change is detected in said sequence of images.

17. An apparatus for vector quantization of an image comprising:
a. means for initializing N initial nodes in a vector quantizer tree;
b. means for sampling a vector from said image;
c. means for determining a node in said vector quantizer tree which is a best representative sample of the vector sampled from said image;
d. means for associating the vector with said node in said vector quantizer tree;
e. means for sampling a next vector from said image;
f. means for activating components c-e until there are no more vectors remain to be sampled from said image, said next vector becoming said vector;
g. means for determining which of the nodes in said tree is the most distorted node in said tree;
h. means for splitting said most distorted node into two children nodes;
i. means for associating a first portion of the vectors associated with said most distorted node with a first of said children nodes, and a second portion of the vectors associated with said most distorted node with a second of said children nodes:
j. means for determining a current error of the two children nodes relative to the first and second portions of the vectors;
k. means for determining new values of said first and second children nodes and continuously activating components i-j if the change in error between the current error and a previous error is greater than an error threshold said current error becoming said previous error;
l. means for continuously activating components g through 1 until the number of terminal nodes in said vector quantizer tree has reached a desired population; and m. means for associating indices with each of the terminal nodes in said vector quantizer tree.

18. An apparatus for vector quantization of an image comprising:
a. means for initializing N initial nodes in a vector quantizer tree;
b. means for sampling vectors from said image;
c. means for determining nodes in said vector quantizer tree which are best representative samples of the vectors sampled from said image;
d. means for associating said vectors with said nodes in said vector quantizer tree;
e. means for iterating and creating new nodes in the vector quantizer tree by determining worst nodes in said tree, splitting said nodes and reassociating said vectors with said nodes in said vector quantizer tree until a number of terminal nodes in said tree reaches a desired population.

19. An apparatus for vector quantization of an image comprising:
a. means for initializing N initial nodes in a vector quantizer tree;
b. means for sampling vectors from said image;

c. means for determining nodes in said vector quantizer tree which are best representative samples of the vectors sampled from said image;
d. means for associating said vectors with said nodes in said vector quantizer tree;
e. means for iterating and creating new nodes in the vector quantizer tree by determining worst nodes in said tree, splitting said nodes and reassociating said vectors with said nodes in said vector quantizer tree until said tree reaches a desired distortion compared to said vectors.

20. An apparatus for vector quantization of an image comprising:
a. means for initializing N initial nodes in a vector quantizer tree;
b. means for sampling vectors from said image:
c. means for determining nodes in said vector quantizer tree which are best representative samples of the vectors sampled from said image;
d. means for associating said vectors with said nodes in said vector quantizer tree;
e. means for iterating and creating new nodes in the vector quantizer tree by determining worst nodes in said tree, splitting said nodes into more than two children nodes and reassociating said vectors with said children nodes in said vector quantizer tree until a number of terminal nodes in said tree reaches a desired population.

21. An apparatus for encoding an image comprising:
a. means for determining whether different regions of said image which should be encoded separately based upon a threshold, wherein said threshold includes whether blocks in said region are of a similar type during encoding;
b. means for encoding said separate regions of said image separately; and c. means for indicating said separate regions of said image have been encoded separately, including means for referencing separate codebooks for each of said separate regions, and further for indicating said position of said separateregions.

22. The apparatus of claim 21 wherein said similar type includes whether blocks in said regions comprise change blocks of said image.

23. The apparatus of claim 21 wherein said similar type includes whether blocks in said regions comprise no-change blocks of said image.

24. The apparatus of claim 23 wherein said no-change blocks of said image comprise spatial no-change blocks within said image.

25. The apparatus of claim 23 wherein said no-change blocks of said image comprise temporal no-change blocks from a previous image compared to said image.

26. The apparatus of claim 21 wherein said similar type includes if one of said separate regions is spatially smooth in appearance and a second of said separate regions is spatially detailed in appearance.

27. The apparatus of claim 26 wherein said means for encoding comprises a vector quantization means.

28. The apparatus of claim 21 wherein said separate regions are encoded separately in a plurality of images and wherein said separate codebooks for said regions are shared across said plurality of images.

29. An apparatus for encoding an image comprising:
a. means for determining whether different regions of said image which should be encoded separately based upon thresholds, wherein said thresholds include whether blocks in said region are of a similar type during encoding;
b. means for encoding said separate regions of said image separately; and c. means for indicating said separate regions of said image have been encoded separately, including means for referencing codebooks for each of said separate regions, and further for indicating said position of said separate regions.

30. The apparatus of claim 29 wherein said codebooks are shared for a plurality of said separate regions.

31. The apparatus of claim 29 wherein certain of said separate regions are further divided into subregions if errors for encoding said certain of said separate regions exceed said thresholds resulting in separate encoding of each of said subregions.

32. The apparatus of claim 31 wherein said error comprises a mean-squared error.

33. The apparatus of claim 29 wherein said separate regions are recursively divided into other separate regions if an error for encoding said certain of said separate regions exceeds a threshold.

34. The apparatus of claim 29 wherein said codebooks for each of said separate regions differs in size.

35. An apparatus for encoding a current image comprising:
a. means for using a previous codebook from a previous image to encode said current image as a first encoded image;
b. means for determining whether first encoded image using said previous codebook is a good approximation of said current image;
c. means for updating said previous codebook to create a current codebook for said current image responsive to said determining means determining that said first encoded image is not a good approximation of said current image;
and d. means for encoding said current image as a second encoded image using said current codebook responsive to said determining means determining that said first encoded image is not a good approximation of said current image.

36. The apparatus of claim 35 wherein said determining means that said first encoded image is not a good approximation of said current image comprises a means for determining whether a mean squared error between a decoded first image generated from said first encoded image and said current image is greater than a threshold.

37. The apparatus of claim 36 wherein said threshold comprises a mean squared error between a second decoded image generated from a previous encoded image and a previous unencoded image.

38. The apparatus of claim 36 wherein said threshold comprises an average of the mean squared errors of N encoded frames prior to said current frame and associated N
unencoded frames.

39. The apparatus of claim 36 wherein said threshold comprises a number of decoded vectors generated from said first encoded image which have a large mean squared error compared to vectors from said current image.

40. The apparatus of claim 36 wherein said updating means comprises a means for updating specific entries in said previous codebook to generate said current codebook if decoded vectors generated from said first encoded image have a large mean squared error in comparison with said current image.

41. The apparatus of claim 40 wherein said updating means further comprises a means for generating a new codebook to be used as said current codebook if said decoded vectors associated generated from said first encoded image have a large mean squared error in comparison with said current image and said means for updating entries in said previous codebook has already been operative.

42. The apparatus of claim 41 wherein said new codebook generation means is activated if said entry updating means has been operative for encoding at least N images sequentially.

43. The apparatus of claim 35 wherein said updating means comprises a means for traversing nodes in a tree representative of vectors for said previous codebook and determining best entries in said previous codebook to use in said current codebook.

44. The apparatus of claim 43 further comprising a means for removing entries in said tree which have a worst error compared with vectors in said current image.

45. The apparatus of claim 43 wherein said means for determining best entries in said tree comprises a means for determining the mean squared error between vectors insaid current image and said tree.

46. The apparatus of claim 43 further comprising a means for creating additional entries in said tree to better represent said current image.

47. The apparatus of claim 46 wherein said means for creating additional entries comprises splitting nodes in said tree to create two new entries for said current codebook.

48. The apparatus of claim 47 wherein said means for splitting node in said tree is operative upon the determination that said nodes have a greater population of vectors from the current image associated with them than a population threshold.

49. The apparatus of claim 47 wherein said means for splitting node in said tree is operative upon the determination that said nodes have a greater distortion of vectors than a distortion threshold.

50. The apparatus of claim 44 further comprising a means for removing an entry in said tree which have no vectors from the current image associated with it.

51. An apparatus for encoding N images comprising:
a. means for using a codebook generated from n images to encode said N
images as N encoded images, wherein n is less than or equal to N; and b. means for determining N based upon whether encoded images of said N
images are good approximations of each of said N images.

52. The apparatus of claim 51 wherein n equals 1.

53. The apparatus of claim 51 wherein n equals N.

54. The apparatus of claim 51 wherein said determining means comprises a means for determining whether a mean squared error between each decoded image generated from each said encoded image and its associated unencoded image is greater than a threshold.

55. The apparatus of claim 54 wherein said threshold comprises a mean squared error of a previous image and an associated unencoded image.

56. The apparatus of claim 55 wherein said previous image comprises a filtered representation of a previous unencoded image.

57. The apparatus of claim 56 wherein said filtered representation of said previous unencoded image is generated by a filtering means, said filtering means being under control of a rate control mechanism, wherein said rate control mechanism adaptively adjusts said filtering means to generate an encoded bitstream at a desired rate.

58. The apparatus of claim 55 further comprising a means for determining whether a first number of blocks for the N encoded images having a mean squared error greater than an average block mean squared error is greater than an error block threshold, and further, a means for generating a new codebook responsive to said determining means for an N+1 image.

59. The apparatus of claim 51 further comprising means for updating said codebook to create a current codebook, said means for updating comprising means for computing blocks from a current image in said N images to update entries in said codebook to create said current codebook.

60. The apparatus of claim 59 further comprising means for determining whether a decoded image generated from said encoded image of said current image using said current codebook has a mean squared error greater than a frame threshold.

61. The apparatus of claim 60 further comprising means for generating a replacement codebook from said current image responsive to an activation of said means for determining.

62. A method of encoding a sequence of images comprising:
a. receiving a codebook wherein said codebook contains vectors representative of vectors generated from an initial image;
b. retrieving a subsequent image of said sequence of images and encoding said subsequent image as a subsequent encoded image using said codebook;
c. determining whether a frame mean squared error between a subsequent decoded image generated from said subsequent encoded image and said subsequent image is greater than a previous frame mean squared error for a decoded initial image generated from an initial encoded image generated from said initial image, and if so, then generating an entire new current codebook from said subsequent image and encoding said subsequent image using said new current codebook;
d. else if a peak number of decoded blocks of said subsequent decoded image have a mean square error greater than associated unencoded blocks of said subsequent image exceeds a block threshold, then generating an entire new current codebook from said subsequent image and encoding said subsequent image using said new current codebook;
e. else determining worst entries in said codebook and generating updated codebook entries to generate a new current codebook from said subsequent image, and encoding said subsequent image using said current codebook.

63. The method of claim 62 wherein said encoding comprises associating vectors from said subsequent image with entries in said codebook.

64. The method claim 63 wherein said codebook comprises a tree containing codebook vectors which have been generated from said subsequent image.

65. The method of claim 64 wherein said updating step comprises the step of removing entries in said codebook which have no vectors from said subsequent image associated with it.

66. The method of claim 65 wherein said updating step further comprises the step of determining most distorted entries in said codebook, and for each of said most distorted entries:

a. creating children entries for said each of said distorted entries; and b. associating vectors associated with each of said most distorted entries with said children entries.

67. The method of claim 66 further comprising the step of removing each of said most distorted entries from said codebook.

68. The method of claim 67 further comprising the step of transmitting entries for said codebook which have changed to a decoding means.

69. The method of claim 62 wherein said codebook contains n entries and said current codebook which has been updated contains N entries, wherein n is less than N, and wherein n entries in said codebook are derived according to a mean squared error between said decoded subsequent image generated from encoded subsequent image and said subsequent image.

70. A method of encoding a sequence of images comprising:
a. receiving a codebook wherein said codebook contains vectors representative of a vectors generated from an image;
b. retrieving a first image of said sequence of images, generating updated codebook entries to generate a current codebook, and encoding said first image as a first encoded image using said current codebook;
c. determining whether a mean squared error between said first encoded image and said first image is greater than a previous mean squared error for a previous encoded image and associated unencoded image, and if so, then generating an entire current codebook and encoding said first image as a second encoded image using said current codebook.

71. The method of claim 70 wherein said encoding comprises associating vectors from said first image with entries in said codebook.

72. The method claim 71 wherein said codebook comprises a tree containing codebook vectors which have been generated from said image.

73. The method of claim 72 wherein said updating step comprising the step of removing entries in said codebook which have no vectors form said first image associated with it.

74. The method of claim 73 wherein said updating step further comprises the step of determining most distorted entries in said codebook, and for each of said most distorted entries:
a. creating children entries for said each of said distorted entries; and b. associating vectors associated with each of said most distorted entries with said children entries.

75. The method of claim 74 further comprising the step of removing each of said distorted entries from said codebook.

76. The method of claim 75 further comprising the steps of transmitting entries for said codebook which have changed to a decoding means.

77. The method of claim 70 wherein said codebook contains n entries and said current codebook which has been updated contains N entries, wherein n is less than N, and wherein n entries in said codebook are derived according to the mean squared error between an encoded image and said image.