Programmable variable-length decoder

Abstract

System and method for decoding variable-length codes. A variable-length decoder includes an address generator and a local memory unit. The local memory stores a variable-length code look-up table. The local memory can be programmed to include a look-up table supporting substantially any decoding algorithm. In one embodiment, a decoder memory unit and a system memory unit are employed together with the local memory to store a codeword look-up table. The shortest codes are stored in local memory, the next shortest in decoder memory, and the longest codes are stored in system memory. A multistage search algorithm is employed to search for the longest codes. The address generator generates the address of the code table to be searched by adding the value of the bits to be searched to a base address.

Description

FIELD OF THE INVENTION

[0002] The present invention relates generally to video decoding systems, and, more particularly, to variable-length decoding.

BACKGROUND OF THE INVENTION

[0003] Generally, large amounts of data being compressed and decompressed for numerous reasons, including transmission, storage, retrieval, and processing use at some stage means of variable-length coding, such as Huffman coding. Huffinan coding was originally disclosed by D. A. Huffman in an article “A Method for the Construction of Minimum Redundancy Codes” Proc. IRE, 40: 1098, 1952. Huffinan coding is a widely used technique for lossless data compression that achieves compact data representation by taking advantage of the statistical characteristics of the source. The Huffinan code is a prefix-free variable-length code that assures that a code is uniquely decodable. In Huffman code, no codeword is the prefix of any other codeword. The run-length processed data are often subsequently coded by variable-length coding for further data compression.

[0004] Variable-length encoding allocates codes of different lengths to different input data according to the probability of occurrence of the input data, so that statistically, more frequent input codes are allocated shorter codes than the less frequent codes. The less frequent input codes are allocated longer codes. The allocation of codes may be done either statically or adaptively. For the static case, the same output code is provided for a given input datum, no matter what block of data is being processed. For the adaptive case, output codes are assigned to input data based on a statistical analysis of a particular input block or set of blocks of data, and possibly changes from block to block (or from a set of blocks to a set of blocks).

[0005] The combination of run-length coding and Huffman coding has been adopted in most compression/decompression standards. However, every standard has its own Huffinan tables and run-length definitions. In principle, a programmable decoding table could be implemented by a random access memory (RAM) unit. However, it would require a 2{circumflex over ( )}16 word RAM (if the longest length of a codeword is 16 bits) which would be very wasteful. It is much more efficient to use a content addressable memory (CAM) whose sizes are determined only by the number of codebook entries. However, if it were implemented by CAM, it would result in a circuit much larger and complicated than a circuit using only a small RAM. Thus there is a need for a simple and flexible variable-length decoder that can speedily and efficiently decode variable length codes of varying standards.

[0006] Further limitations and disadvantages of conventional and traditional approaches will become apparent to one of skill in the art through comparison of such systems with the present invention, as set forth in the remainder of the present application with reference to the drawings.

SUMMARY OF THE INVENTION

[0007] One aspect of the present invention is directed to a data decoding system having a variable-length decoder (VLD) and an external memory unit. The variable-length decoder includes an address generator and a local memory unit. The address generator receives data from the data stream and generates a memory address at which to search for a codeword match in a VLD look-up table. The local memory unit stores at least a portion of the VLD look-up table. The external memory unit is external to the variable-length decoder and stores a portion of the VLD look-up table if the VLD look-up table does not fit entirely within the local memory unit.

[0008] Another aspect of the present invention is directed to a method of decoding a variable-length code data stream. Pursuant to the method, a base memory address is set equal to a start address. Then the next n bits in the data stream are retrieved. A memory location having an address equal to the sum of the base address, plus the value of the n retrieved bits, is accessed. The memory location includes status data indicating whether a codeword from the data stream is matched with its corresponding information. Each memory location that represents a codeword match includes the corresponding information. Each memory location that does not include a codeword match includes an offset value. If a codeword is matched with its corresponding information, the corresponding information is output, the base address is set equal to the start address, and the data in the data stream is shifted by a number of the retrieved bits that correspond to the outputted information. If a codeword is not matched with its corresponding information, the base address is set according to the offset value, and the data in the data stream is shifted n bits. This process, beginning with the retrieval of the next n bits in the data stream, is iteratively repeated.

[0009] Another aspect of the present invention is directed to another method of decoding a variable-length code data stream. Pursuant to this method, a first memory element is designated a memory element to be searched. Then the next n bits in the data stream are retrieved. A designated memory location in the memory element to be searched is accessed. The memory location includes status data indicating whether a codeword from the data stream is matched with its corresponding information. Each memory location that represents a codeword match includes the corresponding information. Each memory location that does not include a codeword match includes a next-search-location indicator indicating a memory element at which to perform the next search. If a codeword is matched with its corresponding information, the corresponding information is output, the first memory element is designated the memory element to be searched, and the data in the data stream is shifted by a number of the retrieved bits that correspond to the outputted information. If a codeword is not matched with its corresponding information, the memory element indicated by the next-search indicator is designated the memory element to be searched, and the data in the data stream is shifted n bits. This process, beginning with the retrieval of the next n bits in the data stream, is iteratively repeated.

[0010] It is understood that other embodiments of the present invention will become readily apparent to those skilled in the art from the following detailed description, wherein embodiments of the invention are shown and described only by way of illustration of the best modes contemplated for carrying out the invention. As will be realized, the invention is capable of other and different embodiments and its several details are capable of modification in various other respects, all without departing from the spirit and scope of the present invention. Accordingly, the drawings and detailed description are to be regarded as illustrative in nature and not as restrictive.

DESCRIPTION OF THE DRAWINGS

[0011] These and other features, aspects, and advantages of the present invention will become better understood with regard to the following description, appended claims, and accompanying drawings where:

[0012] FIG. 1 is a functional block diagram of a decoding system according to an illustrative embodiment of the present invention.

[0013] FIG. 2 is a functional block diagram representing a variable-length decoding system according to an illustrative embodiment of the present invention.

[0014] FIG. 3 is a block diagram showing stream funnel and codeword search engine elements of a variable-length decoder according to an illustrative embodiment of the present invention.

[0015] FIG. 4 is a table demonstrating the operation of a stream funnel according to an illustrative embodiment of the present invention.

[0016] FIG. 5 is a flowchart representing a method of decoding a variable-length code data stream according to an illustrative embodiment of the present invention.

[0017] FIG. 6 is an example of a code table according to the code table storage algorithm of the present invention.

DETAILED DESCRIPTION

[0018] FIG. 1 is a functional block diagram of a decoding system 100, according to an illustrative embodiment of the present invention. Decoding system 100 is illustratively part of a larger system, for which main memory unit 102 serves as the main system memory. Decoding system 100 includes decoder processor 104, variable-length decoder (VLD) 106, decoder element 108, decoder element 110, decoder memory 112, and bridge module 114. Decoder system 100 can have any number of decoder elements in addition to decoder elements 108 and 110. The decoder elements, such as decoder elements 108 and 110, can provide any of a multitude of decoding functions, such as inverse quantization and transform operations, and such as inverse discrete cosine transform (IDCT) operations, for example. Decoder processor 104 performs decoding functions and controls, coordinates and monitors other decoding modules, such as VLD 106 and decoder elements 108 and 110. VLD 106 performs variable-length decoding operations on an incoming data stream. Decoder memory 112 is used to store data that is being decoded during various stages of the decoding process. In an illustrative embodiment, decoder memory 112 also stores look-up tables that are used by VLD 106 in performing variable-length decoding, as will be described in more detail below. Bridge module 114 provides an interface between system memory 102 and decoder memory 112, as well as between the various modules within the decoding system 100. In an illustrative embodiment of the present invention, the decoding system 100 is a video decoding system. In such an embodiment, the decoder elements, such as decoder elements 108 and 110, can perform functions, such as pixel filtering, motion compensation, and de-blocking operations.

[0019] Variable-length decoder 106 is a hardware accelerator that accelerates the process of decoding variable-length codes, which might otherwise be a bottleneck for a decoding process if it were handled by the core processor 104 alone. The VLD 106 performs decoding of variable length codes (VLC) in the compressed bit stream to extract coefficients, such as DCT coefficients, from the compressed data stream. Different coding formats generally have their own special VLC tables. According to the present invention, the VLD module 106 is internally programmable to allow changes according to various processing algorithms. The VLD 106 is completely configurable in terms of the VLC tables it can process. The VLD 106 can accommodate different VLC tables on a macroblock-to-macroblock basis. In an illustrative embodiment of the present invention, the PVLD 306 includes a register that the core processor can program to guide the PVLD 306 to search for the VLC table of the appropriate encoding/decoding algorithm.

[0020] The VLD 106 is designed to support the worst-case requirement for VLD operation, such as with MPEG-2 HDTV (MP@HL) for video decoding, while retaining its full programmability. The VLD 106 includes a code table random access memory (RAM) for fastest performance. Some compression/decompression formats, such as Windows Media Technology 8 (WMT8) video, may require larger code tables that do not fit entirely within the code RAM in the VLD 106. For such cases, according to an illustrative embodiment of the present invention, the VLD 106 can make use of both the decoder memory 112 and the main memory 102, as needed. Performance of VLC decoding is reduced somewhat when codes are searched in video memory 316 and main memory 102. Therefore, for formats that require large amounts of code, the most common codes are stored in the VLD code RAM, the next most common codes are stored in decoder memory 112, and the least common codes are stored in main memory 102. Also, such codes are stored in decoder memory 316 and main memory such that, even when extended look-ups in decoder memory 316 and main memory are required, the most commonly occurring codes are found more quickly. This allows the overall performance to remain exceptionally high. The VLD 106 decodes variable length codes in as little as one clock, depending on the specific code table in use and the specific code being decoded.

[0021] In an illustrative embodiment of the present invention, the VLD 106 helps the core processor 104 to decode header information in the compressed bitstream. In an illustrative embodiment of the present invention, the VLD module 106 is architected as a coprocessor to the decoder processor 102. That is, it can operate on a single-command basis where the core processor issues a command (via a coprocessor instruction) and waits (via a Move From Coprocessor instruction) until it is executed by the VLD 106, without polling to determine completion of the command. This increases performance when a large number of VLC codes that are not DCT coefficients are parsed.

[0022] In an alternative embodiment, the VLD 106 is architected as a hardware accelerator. In this embodiment, the VLD 106 includes a status register that indicates whether the module is active or inactive. The core processor 104 polls the status register to determine whether the VLD 106 has completed its tasks. In an alternative embodiment, the VLD 106 shares a status register with other decoding elements, such as decoding elements 108 and 110.

[0023] In an illustrative embodiment of the present invention, the VLD module 306 includes two variable-length decoders. Each of the two variable-length decoders can be hardwired to efficiently perform decoding according to a particular compression standard, such as MPEG2 HD for video. In an illustrative embodiment, one or both of two VLDs can be optionally set as a programmable VLD engine, with a code RAM to hold VLC tables for other media coding formats. The two VLD engines are controlled independently by the core processor 104, and either one or both of them will be employed at any given time, depending on the application.

[0024] The VLD 106 can operate on a block-command basis where the core processor 104 commands the VLD 106 to decode a complete block of VLC codes, such as DCT coefficients, and the core processor 104 continues to perform other tasks in parallel. In this case, the core processor 104 verifies the completion of the block operation by checking a status bit in the VLD 106. The PVLD produces results (tokens) that are stored in decoder memory 112.

[0025] The VLD 106 checks for invalid codes and recovers gracefully from them. Invalid codes may occur in the coded bit stream for a variety of reasons, including errors in the video encoding, errors in transmission, and discontinuities in the stream.

[0026] FIG. 2 is a functional block diagram representing a variable-length decoding system, according to an illustrative embodiment of the present invention. In FIG. 2, elements that are also shown in FIG. 1 are given like reference numbers. The VLD 106 includes decoder processor interface 200, stream funnel 202, codeword search engine 204, block buffer 206 and decoder memory interface 208.

[0027] The input 210 to the VLD 106 is a bit stream without explicit word-boundaries. The VLD 106 decodes a codeword, determines its length, and shifts the input data stream by the number of bits corresponding to the decoded code length, before decoding the next codeword. These are recursive operations that cannot be pipelined.

[0028] The VLD is implemented based on a small RAM, located in codeword search engine 204, which stores programmable Huffman coded tables. A small RAM is achieved by employing a new multistage search structure that reduces the storage requirement, enables for fast bit extraction and efficiently handles the case of a large number of code tables.

[0029] The stream funnel 202 receives data from the source (or coded buffer) and shifts the data, according to the previously-decoded code length, so as to output the correct window of bits for the symbols that are being currently decoded. In an illustrative embodiment, the stream funnel receives the incoming bitstream 210 from system memory 102.

[0030] The codeword search engine 204 mainly behaves as a symbol search engine. The codeword search engine is based on a multistage search structure. Since codewords are assigned based on the probability of appearance, the shortest codeword is assigned to the most frequent appearance. The multistage search structure is based on this concept. The codeword search engine 204 incorporates several innovations that allow fast bit extraction and reduce the sizes of code tables. For hardware architecture, a small RAM is employed for performing pattern-matching. A multistage pipelined structure is employed to handle the case of a long codeword. Additionally, the code table reduction algorithm can further reduce the storage requirement for a large number of code tables.

[0031] FIG. 3 is a block diagram showing the stream funnel 202 and codeword search engine 204 elements of VLD 106 according to an illustrative embodiment of the present invention.

[0032] Stream funnel 202 includes data stream input buffer 300, register D0 302, register D1 304, left-shifter 306, register D2 308, and accumulator 310. The input data (coded stream) are stored in input buffer 300, which, in an illustrative embodiment, is a first-in first-out (FIFO) buffer. The input buffer 300 provides the data to register D0 302. Register D1 304 also stores part of the incoming bitstream by virtue of load operations that will be discussed below and which load data from register D0 302 into register D1. The contents of registers D0 and D1 are in turn provided to left shifter 306. In an illustrative embodiment of the present invention, registers D0 and D1 comprise a number of bits equal to the maximum code length. In an embodiment wherein the maximum code length is 32 bits (such as in most video decoding standards), registers D0 302 and D1 304 each are 32-bit registers, and left-shifter 306 can hold up to 64 bits. Register D2 indicates the number of bits in register D1 304 for which the codeword search engine 204 most recently performed a codeword search. If registers D0 and D1 each hold 32 bits, the number of bits indicated by register D2 can lie between 0 and 31. This number controls the left shifter 306. After the codeword search engine 204 performs a codeword search for a group of bits in register D1, register D2 indicates the number of bits just searched. Left shifter 306 then shifts the indicated number of bits to the left so that the first un-searched bit appears at the most significant bit of the output of the left shifter 306.

[0033] Accumulator 310 accumulates the number of bits in register D1 304 that have been searched by codeword search engine 204 over multiple codeword searches. When the accumulated code length (the number of bits that have been searched) is greater than or equal to the size of register D1 304 (for example, 32 bits), a carry-out bit 312 becomes 1. This indicates that all the bits in register D1 304 have been used and that register D0 might not contain the whole next codeword. In that case, a “load” signal is generated. When the “load” signal is generated, the contents of register D0 302 are loaded into register D1 304, a new data word (32 bits in the illustrative example) from the input buffer 300 is loaded into D0, and the left shifter 306 shifts by the number of bits indicated by register D2 308 to the new position, all at substantially the same time, to prepare for the next search/decode cycle. If the accumulated code length is not greater than or equal to the size of register D1 304 (e.g., 32), the carry-out signal 312 is 0. Assuming the maximum code length is 32 bits (the size of registers D0 302 and D1 304 in the illustrative embodiment), since at least 32 bits of data in registers D0 302 and D1 304 are not used yet, there are always enough bits for the next search/decoding cycle. Registers D0 302 and D1 304 remained unchanged if the accumulated code length is not greater than or equal to the size of the registers D0 302 and D1 304.

[0034] When the accumulated code length is greater than or equal to the size of registers D0 and D1, and there is no data available in the input buffer 300, the decoding pipes are put on hold. In other words, the contents of register D0 302 are not loaded into register D1 304. The decoding processing then waits until data is available in the input buffer 300.

[0035] FIG. 4 is a table demonstrating the operation of the stream funnel 202. The following codebook (Table 1) is used in the example of FIG. 4:

TABLE 1
Codeword	Code Length	Decoded Symbol
1	1	A
010	3	B
011	3	C
0010	4	D
0011	4	E
00010	5	F
00011	5	G
0000110	7	H
00001010	8	I

[0036] In the example of FIG. 4, registers D0 and D1 are 32-bit registers. FIG. 4 shows, for each of a plurality of search/decode stages, the contents of registers D0 302 and D1 304, the contents of register D2 308 at the beginning of the stage, the contents of the accumulator 310 at the beginning of each stage, and a symbol decoded in the stage. Also, the data in registers D0 and D1 that constitute the most significant bits of left shifter 306 are shown in bold. The non-bold data constitute data that were searched/decoded in a previous stage and was thus shifted out by the left shifter after that stage. For instance, at the beginning of stage 1, the contents of both register D2 308 and accumulator 310 are 0, and the contents of the left shifter 306 include all of the data in registers D0 302 and D1 304. In stage 1, the symbol “I” is decoded, which corresponds to the input stream 00001010.

[0037] Because eight data bits (00001010) were searched/decoded in stage 1, register D2 308, at the beginning of stage 2, indicates that the input data is to be left-shifted 8 bits prior to performing the stage 2 search. The left shifter 306 thus shifts the data 8 bits as indicated by register D2 308. Thus the bit at the most-significant position in the left-shifter 306 at the beginning of stage 2 is the ninth bit of register D1. The accumulator 310 stands at 8, the accumulated total of the number of bits in register D1 that have been searched/decoded. In stage 2, the symbol H is decoded, which corresponds to the bitstream 0000110.

[0038] Because seven data bits (0000110) were searched/decoded in stage 2, register D2 308, at the beginning of stage 3, indicates that the input data is to be left-shifted 7 bits prior to performing the stage 3 search. The left shifter 306 thus shifts the data 7 bits as indicated by register D2 308. Thus the bit at the most-significant position in the left-shifter 306 at the beginning of stage 3 is the 16th bit of register D0. The accumulator 310 stands at 15, the accumulated total of the number of bits in register D1 that have been searched/decoded. In stage 3, the symbol F is decoded, which corresponds to the bitstream 00010. Stage 4 of the process proceeds in a similar manner.

[0039] Because five data bits (00011) were searched/decoded in stage 4, register D2 308, at the beginning of stage 5, indicates that the input data is to be left-shifted 5 bits prior to performing the stage 5 search. The left shifter 306 thus shifts the data 5 bits as indicated by register D2 308. The bit at the most-significant position in the left-shifter 306 at the beginning of stage 2 is the 26th bit of register D1. The accumulator 310 stands at 25, the accumulated total of the number of bits in register D1 that have been searched/decoded. In stage 5, the symbol I is decoded, which corresponds to the bitstream 00001010.

[0040] Because eight data bits (00001010) were searched/decoded in stage 5, the accumulated code length, which stood at 25 at the beginning of stage 5, becomes 33, which is greater than the size of registers D0 and D1. Therefore, the carry-out bit 312 is set. This indicates that all the bits in register D1 304 have been used, and that register D0 might not contain the whole next codeword. Therefore, the “load” signal is generated. Thus, for stage 6, the contents of register D0 302 are loaded into register D1 304, a new data word (32 bits in the illustrative example) from the input buffer 300 is loaded into D0, and the left shifter 306 shifts by the number of bits (one) indicated by register D2 308 to the new position, all at substantially the same time, to prepare for the stage 6 search/decode. Thus, the bit at the most-significant position in the left-shifter 306 in stage 6 is the second bit of register D1, which now holds the data that was previously in register D0 302. The accumulator 310 stands at 1, the accumulated total of the number of bits in register D1 304 that have been searched/decoded. In stage 6, the symbol B is decoded, which corresponds to the codeword 010. Stage 7, and any subsequent stages, proceed in a similar manner.

[0041] Referring again to FIG. 3, codeword search engine 204 includes an address generator 312 and a local memory unit 314. Address generator 312 generates a memory address at which to perform a codeword search. In an illustrative embodiment, this address will reside in the local memory unit 314, but it may also reside in decoder memory 112 or system memory 102, as will be described below. The address generator 312 generates the address to be searched by adding the value of the bits retrieved from left shifter 306, i.e., the data for which a search is to be performed, to a base address. For the first search performed in a given code table, and for subsequent searches when the previous search yielded a code match, the base address is equal to the start address of the code table to be searched. For subsequent searches performed after a previous search did not yield a code match, the base address is equal to the sum of the start address of the code table plus an offset that was indicated by the code table entry of the previous search.

[0042] In an illustrative embodiment of the present invention, the starting address of the code table to be searched can be programmed. In this way, the appropriate code table can be selected for the encoding/decoding format of the bitstream being decoded. In an illustrative embodiment of the present invention, the VLD 106 includes a register that holds the starting address of the code table to be searched. This register can be accessed by the decoder processor 104 to point to the code table that is appropriate for the current data stream. In an embodiment wherein the incoming data stream comprises video data, the code tables can be switched on a macroblock-to-macroblock basis.

[0043] Local memory 314 holds the code look-up table that is to be used during the variable-length decoding process. The code table that starts at the indicated start address is used in decoding the incoming bitstream. In an illustrative embodiment of the present invention, local memory 314 is a random access memory (RAM) unit. In a further illustrative embodiment, the local memory is a relatively small memory unit, for example, a 512×32 single-port RAM.

[0044] In an illustrative embodiment of the present invention, if a given code look-up table does not fit within the local memory unit 314, portions of the table can be stored in decoder memory 112 and/or system memory 102. In an illustrative embodiment, if more memory is needed than the local memory unit 314 alone, first the decoder memory 112 is utilized, and if more still is needed, the system memory 302 is utilized. Where multiple memory units are utilized, the shortest, and therefore most common codes are stored in local memory 314. The next-shortest codes are stored in decoder memory 112, and if needed, the longest codes are stored in system memory 102. This architecture allows for fast bit extraction.

[0045] One embodiment of the present invention is directed to a code table storage and look-up method that enables fast bit extraction and also reduces the size of the code tables. Reducing the size of the code tables further reduces the storage requirement for a large number of code tables. One embodiment of the code table storage and look-up method makes use of the multiple memory unit structure mentioned above and uses a multistage, pipelined structure to handle the case of a long codeword.

[0046] The local memory unit 314 supports multiple code tables (up to 32 in an illustrative embodiment). Each code table has the following general information which are pre-programmed by the decoder processor 104: the starting address in the local memory 314 of the code table during the first search (FSA), the searching length during the first level search (FSL), a signed bit indicator, and the size of the fixed run-length code. A high signed bit indicator indicates that the code table has a signed bit following the codeword. The size of the fixed run-length code comprises three components: a level value, a run value and last-bit indicator. The level value represents the number of bits that are used for representing the level in run-length coding. The run value represents the number of bits that are used for representing the run in run-length coding. The last-bit indicator is high when there is a “last” bit that appears in the run-length code. For example, in MPEG4 video, if the escape code is type4, the 15 bits following ESC are decoded as fixed length codes represented by 1-bit LAST, 6-bit RUN and 8-bit LEVEL.

[0047] Each address of a code table comprises a code table entry. Each entry includes a current code length (CCL) indicator, an end-of-block bit, a status indicator and an information/offset value. The status indicator indicates whether that entry represents a codeword match. If the entry does represent a codeword match, the information/offset value is the matching information, that is, the data that the just-matched codeword represents (the “meaning” of the codeword). If the entry does not represent a codeword match, the information/offset value indicates an address at which to perform the next codeword search. In an illustrative embodiment of the present invention, the offset value indicates an address at which to base the next codeword search. In an alternative embodiment, the offset value is added to another address to obtain the base address from which to perform the next search.

[0048] The status indicator can also indicate other aspects of the search status. For example, if the entry does not represent a codeword match, the status indicator indicates the memory unit in which to perform the next codeword search. Also, if the entry represents an error, i.e., no valid code would result in the entry at that memory location to be reached—the status indicator indicates as much. In an illustrative embodiment of the present invention, the status indicator is a 4-bit word having the meanings shown in Table 2.

TABLE 2
Status Code
[3:0]  Meaning
0001   Escape code followed by run length code
0010   Special Codeword 1
0011   Special Codeword 2
0100   CodeWord Found
0101   Goto Next Level Code Search @ Code
       RAM
0110   Goto Next Level Code Search @ Decoder
       Memory
0111   Error has been detected
1000   Goto Next Level Code Search @ System
       Memory
others reserved

[0049] As mentioned above, if the code table entry represents a codeword match (status=0100), the information/offset value represents the meaning of the codeword. If the code table entry does not represent a codeword match and the next search is to be performed in local memory (status=0101), the information/offset value represents the start address of the next search level at local memory 314 (code RAM). If the code table entry does not represent a codeword match, and the next search is to be performed in decoder memory (status=0110), the information/offset value represents the offset of the secondary code table at the decoder memory 112. If the entry does not represent a codeword match and the next search is to be performed in system memory (status=1000), the information/offset value represents the offset of the tertiary code table at the system memory 102.

[0050] The current code-length indicator indicates the number of bits that the input bitstream should be shifted prior to the next codeword search. If the code table entry represents a codeword match, the current code-length represents the number of bits, out of the currently searched group of bits, that correspond to the matched information represented by the information/offset value. If the code table entry does not represent a codeword match, the current code-length indicator indicates the number of bits for which a codeword search is to be performed in the next stage. If the entry represents an error, the current code-length indicator indicates that no bits in the current search have been matched.

[0051] Each code table entry that does not represent a codeword match further includes a next-search-length (NSL) indicator that indicates the number of bits to perform a codeword search for in the next stage. In an illustrative embodiment, the code table entries that do represent a codeword match do not contain a next-search-length indicator, as the search length in the next stage automatically reverts to an initial value. In an alternative embodiment, the code table entries that do represent a codeword match do contain a next-search-length indicator, which indicates the initial value.

[0052] The end-of-block bit is high if the just-decoded code is the last code in a block of codes to be decoded.

[0053] The local memory 314 and the address generator 312 work together to perform a pattern matching on the data stream. When a codeword is matched at a code table entry, the status indicator in the entry will indicate that that is the case. If an accessed code table entry is not a match, the state machine will go to the next stage to keep searching until the codeword is found. If the status indicator shows that an error has occurred, the PVLD will stop searching the next codeword, set an error status bit to “1,” report the error to the decoder processor 104 and enter an idle state.

[0054] FIG. 5 is a flowchart representing a method of decoding a variable-length code data stream, according to an illustrative embodiment of the present invention. The method implements a code table storage algorithm, and a method of traversing a code table implementing the algorithm, that reduces the storage requirement and enables fast code look-up. At step 505, the appropriate code table is loaded according to the compression/decompression standard of the data stream being decoded. The code table is illustratively loaded into local memory 314. The start address of the code table in the local memory is designated m. At step 510, a base memory address is set equal to the start address. Also, at step 510, the search length, n, i.e., the number of bits from the data stream for which a code match is sought in a given search, is initialized as a first search length (FSL) value.

[0055] At step 515, the next n bits in the data stream are retrieved. In an illustrative embodiment, these bits are retrieved from the n most significant bits of left shifter 306. At step 520, the address at which to search for a code match is generated by adding the value of the n bits retrieved from the bitstream to the base address. This step is illustratively performed by address generator 312. At step 525, the memory location having the address generated in step 520 is accessed and the status indicator at that memory location is examined. Decision box 530 asks whether the status indicator indicates that a codeword match is found. If the answer is yes, the corresponding information, indicated by the information/offset value of the memory location, is output.

[0056] If the status indicator indicates that a codeword match is not found, decision box 540 asks whether the status indicator indicates that an error has occurred. Such an error would arise, for example, if the memory location arrived at does not correspond to a valid code. If there is an error, an error indication is given, as indicated at step 545. If the status indicator indicates that either a codeword match is found or an error has occurred, the base address is set equal to the start address, as indicated by step 555, and the search length, n, is set equal to the first search length (FSL), as shown at step 560. If the status indicator indicates that the memory location does not represent a codeword match, and an error has not occurred, the base address is set according to the offset value indicated by the information/offset value, as indicated at step 550, and the search length, n, is set equal to the next-search-length value held in the memory location. In an illustrative embodiment, the search length remains constant throughout the decoding process. In that case, steps 560 and 565 of FIG. 5 can be eliminated.

[0057] At step 570, the incoming bitstream is shifted by an amount indicated by the current code-length indicator of the memory location. Step 570 is illustratively performed by left shifter 306. In an illustrative embodiment, if the memory location represents a codeword match, the current code-length indicator indicates the number of the retrieved bits that correspond to the outputted information (the meaning of the codeword). In a further illustrative embodiment, if the memory location represents a non-match, the value of the current code-length indicator is equal to n bits (the number of bits for which the current search was performed). In another embodiment, if the status indicator indicates an error, the value of the current code-length indicator is zero. After step 570, the next n bits in the data stream are accessed, as indicated by step 515, and the above-described process is repeated starting at that point. In an exemplary embodiment, this process is iteratively repeated as long as there is data in the data stream to decode.

[0058] FIG. 6 is an example of a code table according to the code table storage algorithm of the present invention. In an illustrative embodiment of the present invention, the code table of FIG. 6 is stored in local memory 314. The following codebook (Table 3) is used in the exemplary code table of FIG. 6:

TABLE 3
Codeword	Code Length	Decoded Symbol
1	1	A
010	3	B
011	3	C
. . .
00010	5	X
000110	6	Y
000111	6	Z

[0059] Each of the addresses 600 in the code table of FIG. 6 represents a codebook entry. The other columns 610, 620, 630, 640 and 650 represent elements of each codebook entry. These elements include current code-length indicator 610, next-search-length indicator 620, end-of-block bit 630, status indicator 640 and information/offset value 650. The illustrative code table of FIG. 6 has a first search length (FSL) of 3 and a starting address (FSA) of 0.

[0060] To demonstrate how the code table of FIG. 6 is structured and to demonstrate how it is traversed in order to decode a variable-length bitstream, assume the bits in the most-significant position of left shifter 306 are the bits 1010 (which we know, from referring to the codebook of Table 3, represent symbols A and B). The codeword search engine decodes these bits as follows. Because the first search length is 3, the first three bits of the data stream (101) are pulled from the data stream, that is, from the left shifter 306. The address generator 312 adds the value of these bits (5) to the starting address (0) to get a search address of 5. The code table entry at address 5 has a status indicator=0100, which indicates that the entry represents a codeword match (see table 2). Therefore, the information/offset value (A) of the entry is outputted as a decoded value. In an illustrative embodiment of the present invention, this output value is provided to decoder memory 112 and stored there. The current-code-length indicator of the entry at address 5 is a 1. This value is provided to accumulator 310 and register D2, indicating that one bit (the first 1, corresponding to the outputted A) was decoded in this stage.

[0061] Therefore, in the next stage, prior to performing the next search, the left shifter 306 shifts its contents one bit, putting the bits 010 at the three most-significant positions of left shifter 306. The search length is three (the first search length) because the previous search resulted in a codeword match. Thus, the bits 010 are provided to the address generator 312, which adds the value of these bits (2) to the starting address (0) to get a search address of 2 (the starting address is used as the base address because the previous search yielded a match). The code table entry at address 2 has a status indicator=0100, which indicates that the entry represents a codeword match. Therefore the information/offset value (B) is outputted as a decoded value. Hence, the input string 1010 has been decoded as AB. The current-code-length indicator of the entry at address 2 is a 3. This value is provided to accumulator 310 and register D2, indicating that three bits (010, corresponding to the outputted B) were decoded in this stage.

[0062] Say, for example, the next bits in the data stream (after the bits1010) are 00010010 (which represent symbols X and B). Because the value stored in register D2 from the previous search is 3, prior to performing the next search, the left shifter 306 shifts its contents three bits, putting the bits 000 at the three most-significant positions of left shifter 306. The search length is three (the first search length) because the previous search resulted in a codeword match. Thus, the bits 000 are provided to the address generator 312, which adds the value of these bits (0) to the starting address (0) to get a search address of 0 (the starting address is used as the base address because the previous search yielded a match). The code table entry at address 0 has a status indicator=0101, which indicates that the entry does not represent a codeword match. Therefore, the information/offset value (8) is provided to address generator 312 to be used in calculating the base address of the next search. The code table entry at address 0 has a next search-length indicator of 3. This value is provided to address generator 312 to indicate the number of bits to be retrieved from the left shifter 306 for the next search. The current-code-length indicator of the entry at address 0 is a 3. This value is provided to accumulator 310 and register D2, indicating that the left shifter 306 should shift its contents three bits prior to the next codeword search.

[0063] Shifting the contents of left shifter 306 by the indicated three bits puts the bits 010 at the three most-significant positions of left shifter 306. The search length is three, as indicated to the address generator 312 by the next-search-length indicator from the previous stage. Thus, the bits 100 are provided to the address generator 312, which adds the value of these bits (4) to the base address to get the search address. The base address is equal to the start address (0) plus the offset value (8) indicated by the information/offset value from the previous stage. Thus the search address=0+8+4=12. The code table entry at address 12 has a status indicator 0100, which indicates that the entry represents a codeword match. Therefore the information/offset value (X) is outputted as a decoded value. The current-code-length indicator of the entry at address 12 is a 2. This value is provided to accumulator 310 and register D2, indicating that two bits (01, which are the first two bits of the just-searched bits, and which are also the last two bits of the just-decoded codeword) were decoded in this stage.

[0064] Therefore, in the next stage, prior to performing the next search, the left shifter 306 shifts its contents two bits, putting the bits 010 at the three most-significant positions of left shifter 306. The search length is three (the first search length) because the previous search resulted in a codeword match. Thus, the bits 010 are provided to the address generator 312, which adds the value of these bits (2) to the starting address (0) to get a search address of 2 (the starting address is used as the base address because the previous search yielded a match). The symbol B is decoded at the code table entry at address 2, as was described above.

[0065] In an illustrative embodiment of the present invention, multiple memory units are used to store the codeword look-up table. For example, in one embodiment, part of the codeword look-up table is stored in local memory 314, part is stored in decoder memory 112, and part is stored in system memory 102. The shortest, and therefore most common codes, are stored in local memory 314, enabling the majority of codeword searches to be performed quickly and efficiently. The next shortest codes are stored in decoder memory 112, and the longest codes are stored in system memory. In this embodiment, the status indicator of each code table entry indicates the memory unit at which to perform the next search if the current search did not result in a codeword match. If the current search did produce a codeword match, the status indicator indicates that condition, and the next search will be performed in local memory unit 314. The first search for a data stream, and each search following a codeword match are performed in the local memory unit 314.

[0066] In the case of block decoding, the VLD 106 will continue decoding the bitstream as long as there is space available in the block buffer 206. In order to simplify the design, in an illustrative embodiment of the present invention, the VLD 106 checks the buffer availability before starting to decode a block. When the VLD 106 is finished decoding a block, the VLD 106 transfers the data to the block buffer 206. This processing continues until a block count is reached. In an illustrative embodiment wherein the VLD 106 is part of a video decoder, a double buffer scheme is used in order to support High Definition (HD) performance.

[0067] Although a preferred embodiment of the present invention has been described, it should not be construed to limit the scope of the appended claims. For example, the present invention is applicable to any type of data utilizing variable-length code, including any media data, such as audio data and graphics data, in addition to the video data illustratively described herein. Those skilled in the art will understand that various modifications may be made to the described embodiment. Moreover, to those skilled in the various arts, the invention itself herein will suggest solutions to other tasks and adaptations for other applications. It is therefore desired that the present embodiments be considered in all respects as illustrative and not restrictive, reference being made to the appended claims rather than the foregoing description to indicate the scope of the invention.

Claims

1. A method of decoding a variable-length code data stream, comprising steps of: (a) setting a base memory address equal to a start address; (b) retrieving the next n bits in the data stream; (c) accessing a memory location having an address equal to the sum of the base address plus the value of the n retrieved bits, which memory location includes status data indicating whether a codeword is found, wherein, if a codeword is found, the memory location includes corresponding information, and wherein if a codeword not found, the memory location includes an offset value; (d) if a codeword has been identified: (d)(i) outputting the decoded information corresponding to the codeword; (d)(ii) setting the base address equal to the start address; and (d)(iii) shifting the data in the data stream by a number of the retrieved bits that correspond to the decoded information; (e) if a codeword has not been identified: (e)(i) setting the base address according to the offset value; and (e)(ii) shifting the data in the data stream n bits; and (f) iteratively repeating steps (b)-(e).

2. The method of claim 1 wherein the memory location includes current code-length data indicating the number of bits by which to shift the data in the data steam in shifting steps (d)(iii) and (e)(ii).

3. The method of claim 2 wherein, if a codeword has been identified, the current code-length data indicates the number of the retrieved bits that correspond to the decoded information.

4. The method of claim 2 wherein, if a codeword has not been identified, the current code-length data indicates the number, n, of bits retrieved in step (b).

5. The method of claim 1 wherein shifting steps (d)(iii) and (e)(ii) comprise left-shifting the data in the data stream.

6. The method of claim 1 wherein if a codeword has not been identified, the memory location includes next-search-length data indicating a number, n, of bits to be retrieved in the next stage and wherein step (e) further comprises a sub-step (e)(iii) of setting the number of bits, n, to be retrieved in the next stage equal to the value of the next-search-length data.

7. The method of claim 1 wherein step (f) comprises iteratively repeating steps (b)-(e) as long as there is data in the data stream to decode.

8. The method of claim 1 wherein the variable-length code data stream is a media data stream.

9. The method of claim 8 wherein the variable-length code data stream is a video data stream.

10. The method of claim 9 wherein if a codeword is identified, the memory location includes a discrete cosine transform coefficient corresponding to the found codeword.

11. The method of claim 1 wherein step (e)(i) comprises setting the base address equal to the offset value.

12. The method of claim 1 wherein step (e)(i) comprises setting the base address equal to the sum of the offset value plus the start address.

13. A method of decoding a variable-length code data stream, comprising steps of: (a) designating a first memory element as a memory element to be searched; (b) retrieving the next n bits in the data stream; (c) accessing a designated memory location in the memory element to be searched, which memory location includes status data indicating whether a codeword from the data stream has been identified, wherein if a codeword has been identified, the memory location includes decoded information corresponding to the identified codeword, and wherein if a codeword has not been identified, the memory location includes a next-search-location indicator indicating a memory element at which to perform the next search; (d) if a codeword has been identified: (d)(i) outputting the decoded information corresponding to the codeword; (d)(ii) designating the first memory element as the memory element to be searched; and (d)(iii) shifting the data in the data stream by a number of the retrieved bits that correspond to the decoded information; (e) if a codeword has not been identified: (e)(i) designating the memory element indicated by the next-search indicator as the memory element to be searched; and (e)(ii) shifting the data in the data stream n bits; and (f) iteratively repeating steps (b)-(e).

14. The method of claim 13 wherein step (a) further comprises setting a base memory address equal to a start address, wherein the designated memory location of step (c) has an address equal to the sum of the base address plus the value of the n retrieved bits, wherein the memory location of step (c) includes an offset value, wherein step (d) further comprises a sub-step (d)(iv) of setting the base address equal to the start address, and wherein step (e) further comprises a sub-step (e)(iii) of setting the base address according to the offset value.

15. The method of claim 14 wherein step (e)(iii) comprises setting the base address equal to the offset value.

16. The method of claim 14 wherein step (e)(iii) comprises setting the base address equal to the sum of the offset value plus a starting address of the memory element indicated by the next-search-location indicator.

17. The method of claim 13 wherein the memory location includes current code-length data indicating the number of bits by which to shift the data in the data steam in shifting steps (d)(iii) and (e)(ii).

18. The method of claim 17 wherein, if a codeword is identified, the current code-length data indicates the number of the retrieved bits that correspond to the decoded information.

19. The method of claim 17 wherein, if a codeword is not identified, the current code-length data indicates the number, n, of bits retrieved in step (b).

20. The method of claim 13 wherein shifting steps (d)(iii) and (e)(ii) comprise left-shifting the data in the data stream.

21. The method of claim 13 wherein if a codeword is not identified, the memory location includes next-search-length data indicating a number, n, of bits to be retrieved in the next stage and wherein step (e) further comprises a sub-step (e)(iii) of setting the number of bits, n, to be retrieved in the next stage equal to the value of the next-search-length data.

22. The method of claim 13 wherein step (f) comprises iteratively repeating steps (b)-(e) as long as there is data in the data stream to decode.

23. The method of claim 13 wherein the variable-length code data stream is a media data stream.

24. The method of claim 23 wherein the variable-length code data stream is a video data stream.

25. The method of claim 24 wherein if a codeword has been identified, the memory location includes a discrete cosine transform coefficient corresponding to the identified codeword.

26. A data decoding system comprising: a variable-length decoder (VLD) comprising: an address generator adapted to receive data from the data stream and to generate a memory address at which to search for a codeword match in a VLD look-up table; and a local memory unit adapted to store at least a portion of the VLD look-up table; and a first external memory unit external to the variable-length decoder and adapted to store a portion of the VLD look-up table if the VLD look-up table is larger than an amount of memory allotted for the VLD look-up table in the local memory unit.

27. The system of claim 26 wherein the first external memory unit is internal to the data decoding system.

28. The system of claim 27 wherein the first external memory unit is a static random access memory (SRAM) unit.

29. The system of claim 26 further comprising a second external memory unit external to the variable-length decoder and adapted to store a portion of the VLD look-up table if the VLD look-up table is larger than a combined amount of memory allotted for the VLD table in the local memory unit and the first external memory unit.

30. The system of claim 29 wherein the second external memory unit is external to the data decoding system.

31. The system of claim 30 wherein the second external memory unit is a main memory unit for a communications system that the data decoding system is a component of.

32. The system of claim 31 wherein the second external memory unit is a dynamic random access memory (DRAM) unit.

33. The system of claim 26 wherein the variable-length decoder further comprises: a shift register adapted to store data from the data stream and to shift the data an indicated number of bits after a codeword search is completed and to provide an indicated number of the most significant bits in the shift register after a shift to the address generator.

34. The system of claim 33 wherein the VLD look-up table includes a plurality of entries, each entry comprising a status indicator indicating whether the entry contains the information corresponding to a block of data stream data for which a match is sought and a current-code-length indicator indicating the number of bits by which to shift the data in the shift register.

35. The system of claim 34 wherein each entry in the VLD look-up table that does not contain a code match further comprises a next-search-length indicator indicating the number of most significant bits the shift register is to provide to the address generator.

36. The system of claim 35 wherein each entry in the VLD look-up table that does not contain a code match further comprises a next-search-location indicator indicating the memory unit at which to next search the VLD table for a match.

37. The system of claim 36 wherein the address generator generates the memory address at which to search for a codeword match in a VLD look-up table by adding a starting address of the VLD look-up table in the memory unit indicated by the next-search-location indicator plus the value of the bits provided by the shift register.

38. The system of claim 37 wherein each entry in the VLD look-up table that does not contain a code match further comprises an offset value indicating an address at which to next search the VLD table in one of the memory units for a match.

39. The system of claim 38 wherein the address generator generates the memory address at which to search for a codeword match in a VLD look-up table by further adding the offset value to the sum of the starting address of the VLD look-up table in the memory unit indicated by the next-search-location indicator and the value of the bits provided by the shift register.