TWI903348B - Apparatus and method for encoding and decoding bayer pattern images - Google Patents

Abstract

A video encoding apparatus for Bayer pattern images is disclosed, comprising: a quantizer, a variable-length coder and a predictor. The quantizer is configured to perform quantization over a difference value D of an input pixel and a current predicted pixel to generate a quantized value D in a quantization sequence based on a quantization parameter Q and the following equation:

Description

Device and method for encoding and decoding Bayer imagery

This invention relates to a video codec, and more particularly to an apparatus and method for encoding and decoding Bayer pattern images.

In digital cameras, smartphones, and other imaging systems, the image signal processor (ISP) is a specialized component whose primary function is to process the raw output data from the Bayer color filter array (CFA) and convert it into a high-quality image. Before the demosaicing step, the ISP acquires a low/standard dynamic range (LSDR) image (each pixel containing only one color) associated with the Bayer image. At this stage, by merging a series of LSDR images with different exposure times, the ISP can generate a high dynamic range (HDR) image. Because these LSDR images were captured at different times, they are sequentially compressed and stored in Dynamic Random Access Memory (DRAM). Subsequently, this compressed data is read back from DRAM, decompressed, and merged to produce HDR images. Therefore, the industry urgently needs a lossless compression solution that occupies less memory space and ensures users do not experience any image quality distortion.

In view of the above problems, one of the purposes of this invention is to provide a video encoding device for Bayer image processing that allows compressed data to occupy less memory space and does not cause any image quality distortion to be perceived by the user.

According to one embodiment of the present invention, a video encoding apparatus for Bayer image processing is provided, comprising: a quantizer, a predictor, and a variable length encoder. The quantizer is used to quantize the difference D between an input pixel and a currently predicted pixel according to a quantization parameter Q and an equation, to generate a quantized value in a quantization sequence. The equation is: The predictor, coupled to the quantizer, performs a set of first operations, including: providing the current predicted pixel based on the position of a current segment in a current Bayer image. The variable length encoder, coupled to the quantizer, performs a set of second operations, including: (1) calculating the number of consecutive zeros ZR, wherein ZR consecutive zeros are located before the next non-zero integer in the quantization sequence or at the end of the quantization sequence; (2) encoding the ZR consecutive zeros into a first codeword using a first codeword group; (3) encoding the next non-zero integer into a second codeword using a second codeword group; and (4) repeating the second operations (1) to (3) until all quantized values in the quantization sequence have been processed to generate an encoded byte. Wherein, A satisfies the following equation: (Q A + 1) = N, and where N = 2 ^{d 2n} , where n represents the bit width of the input pixel and d is an integer.

Another embodiment of the present invention provides a video encoding method for Bayer imagery, comprising the following steps: quantizing the difference D between an input pixel and a currently predicted pixel according to a quantization parameter Q and an equation to generate a quantized value in a quantization sequence. The equation is: Based on the position of a current segment in a current Bayer image, provide the current predicted pixel; calculate the number of consecutive zeros ZR, where ZR consecutive zeros are located before the next non-zero integer in the quantization sequence or at the end of the quantization sequence; encode the ZR consecutive zeros into a first codeword using a first codeword group; encode the next non-zero integer into a second codeword using a second codeword group; and repeat the calculation steps, the steps of encoding the ZR consecutive zeros into the first codeword, and the steps of encoding the next non-zero integer into the second codeword, until all quantization values in the quantization sequence have been processed to generate an encoded byte; wherein A satisfies the following equation: (Q A + 1) = N; and, where N = 2 ^{d 2n} , where n represents the bit width of the input pixel and d is an integer.

Another embodiment of the present invention provides a video decoding apparatus for Bayer imagery, comprising: a variable-length decoder and a predictor. The variable-length decoder performs a first set of operations, including: alternately comparing the leading bit pattern of an encoded byte with all codewords in a first codeword group and a second codeword group to generate a decoded value, which may be a sequence of consecutive zeros or a non-zero integer. The predictor, coupled to the variable-length decoder, performs a second set of operations, including: providing a currently predicted pixel based on the position of a currently reconstructed segment in a currently reconstructed Bayer imagery.

Another embodiment of the present invention provides a video decoding method for Bayer imagery, comprising the following steps: alternately comparing the leading bit pattern of an encoded byte with all codewords in a first codeword group and a second codeword group to generate a decoded value, which may be a set of consecutive zeros or a non-zero integer; and providing a currently predicted pixel based on the position of a currently reconstructed segment relative to a currently reconstructed Bayer imagery.

The above and other objectives and advantages of this invention are described in detail below with reference to the following figures, detailed descriptions of embodiments, and the scope of the patent application.

The following definitions apply to terms used throughout this specification and in subsequent requests, unless otherwise specified in this specification: the singular forms of "a" and "the" have both singular and plural meanings; the slash "/" has the meanings of "or" and "and". Throughout this specification, circuit components with the same function use the same reference symbols.

Please note that the encoding/decoding system 100 embedded in the ISP 120 is merely an example and not a limitation of the invention. In actual implementation, the encoding/decoding system 100 may adopt any other configuration, such as being embedded in other image processing devices, which also falls within the scope of the invention.

Figure 1 illustrates an example of an encoding/decoding system 100 according to an embodiment of the present invention. Referring to Figure 1, the encoding/decoding system 100 is embedded in an imaging system (such as a digital camera) ISP 120. The ISP 120 receives a Bayer image from an image sensor 110 (such as a Bayer CFA) and, before performing a demosaic step, selectively performs zero or more steps in denoising, white balancing, color transform, exposure correction, and gamma correction to generate an LSDR image. In the LSDR image, each pixel has only one color and is represented by 8, 10, 12, 14, or 16 bits of data (i.e., bit width). Because these LSDR images were captured at different times, the encoding/decoding system 100 sequentially compresses these LSDR images and stores them in the DRAM 130. Then, the encoding/decoding system 100 reads back the compressed and decompressed data from the DRAM 130. Next, the ISP 120 merges the images to generate an HDR image. In the embodiment of Figure 1, the encoding/decoding system 100 includes the segment encoder 200 of Figure 2 and the segment decoder 500 of Figure 5. Both the segment encoder 200 and the segment decoder 500 are located within the ISP 120. In another embodiment, the segment encoder 200 and the segment decoder 500 are located in two different imaging devices/systems.

Figure 2 is a schematic diagram of a Bayer image segment encoder 200 according to an embodiment of the present invention. Referring to Figure 2, the segment encoder 200 of the present invention includes a subtractor 210, a quantizer 220, a variable length coder (VLC) 230, a clipper 240, a predictor 230, an adder 260, and a multiplier 270. Generally, each LSDR image is divided into multiple segments and fed to the segment encoder 200 in a segment-by-segment and pixel-by-pixel manner. The operation of the segment encoder 200 and the segment decoder 500 is described in detail below, assuming that the width W of each segment is 32 pixels and that each pixel has only one color and is represented by 8 bits (n=8) of data, where n represents the bit width of the input pixel s[k].

An input pixel s[k] of a current segment of a current LSDR image is fed into subtractor 210. Subtractor 210 then subtracts the value of the currently predicted pixel p[k] from the value of the input pixel s[k] to obtain a difference D, where k = 0~31. Next, quantizer 220 quantizes the difference D according to a quantization step/parameter Q, for example, by calculating... This generates a quantized value delta, where ⌊⌋ represents the floor function. However, division is not easy to implement in computer systems, but multiplication and right shift are relatively easy to implement. In one embodiment, the following code and Equation 1 are provided in quantizer 220 for quantization: // Equation 1 delta = D < 0 ? - : //If D < 0, delta = - Otherwise, delta =

Where N and A are integers. If the input pixel s[k] contains n bits of data, then N = 2^ ⁿ . Since N is a power of 2, a right shift can be used instead of division. For example, if N = 4096, then the numerator ( Shift right 12 times per bit to get value.

Figure 3 shows the relationship between N, Q, and the value of A. The value of A in Figure 3 is an integer and must satisfy the condition: (Q...) A + 1) = N. When choosing a value for A, the selected value for N must be greater than or equal to the corresponding 2^ ⁿ value. For example, assuming n = 10 and Q = 5, according to Figure 3, the 3rd column from the left does not support any value for A; at this time, there are two choices: you can choose A = 819 for the column corresponding to N = 4096, or you can choose A = 13107 for the column corresponding to N = 65536. Note that both of these corresponding N values are greater than 2 ^{^10} (n = 10).

Figure 4 shows a portion of the calculated results (D values ranging from -3 to 14) for different equations with the same quantization level/parameter Q=3, where equation 3 ( The first equation is known, while Equation 1 is calculated based on N=4096 and A=1365. The second column of the table in Figure 4 shows the calculation. The result value of equation 2 ( ) is derived from The revised version. As can be observed from Figure 4, compared to the quotients in the second column (row), the calculated results in the third column (Equation 2) are more evenly distributed, and all groups are centered around multiples of 3. To approximate the calculated results of Equation 2, Equation 3 was previously published in the industry. However, it is clear that the data in the third and fourth columns do not match, and the data near D=0 in the fourth column of Equation 3 is not evenly distributed; conversely, the data in the third column (Equation 2) and the fifth column (Equation 1) match perfectly. The calculated results of Equation 1 of this invention have absolute accuracy and even distribution, minimize quantization error, and help with lossless compression/decompression, where the aforementioned quantization error refers to the difference between the difference D and its quantized value delta.

Returning to Figure 2, the VLC 230 encodes a sequence of quantized delta values using the run-value coding method of this invention to generate an encoded bitstream. In this specification, the term "zero-run (ZR)" refers to the number of consecutive zeros in the aforementioned sequence of quantized delta values, either before the next non-zero integer in the quantized sequence or at the end of the quantized sequence. Table 1 shows the encoding tables for different ZR values (i.e., different numbers of consecutive zeros). Table 1 Code ZR=0 1'b0 ZR=1 2'b10 ZR=2 3'b110 ESC-run(ER)=3 4'b1110 EOS 4'b1111

In Table 1, the term "end of segment (EOS)" refers to the fact that in the aforementioned delta quantization sequence, all subsequent/remaining values (up to the end of the delta quantization sequence) are equal to 0. The term "ESC-run (ER)" refers to the default number of consecutive zeros in the aforementioned delta quantization sequence; therefore, in the aforementioned delta quantization sequence, when ZR > ER, ZR consecutive zeros will be encoded as ER plus (ZR - ER) consecutive zeros. For example, 7 consecutive zeros (ZR=7 and ER=3) will be encoded in the format {3, 3, 1}, i.e., 10’b1110111010. In Table 1, the five codewords are five unary codes, corresponding to the following in the above-mentioned delta quantization value sequence: 0 zeros (i.e., no zeros), 1 zero, 2 zeros, 3 zeros, and the remainder (up to the end of the sequence) is equal to 0. In Table 1, each codeword (i.e., each unary code) uses ZR 1s plus one 0 to represent a corresponding ZR value. However, this is not a limitation of the present invention. In another embodiment, each codeword (i.e., each unary code) uses ZR 0s plus one 1 to represent a corresponding ZR value.

Table 2 shows the encoding table for non-zero integers. Table 2 Set of numbers class Code {+1, -1} 0 2'b0s {+2, -2, +3, -3} 1 4'b10xs {+4, -4, +5, -5, +6, -6, +7, -7} 2 6'b110xxs {+8, -8, +9, -9, +10, -10, +11, -11, +12, -12, +13, -13, +14, -14, +15, -15} 3 8'b1110xxxs … … …

In Table 2, x represents 0 or 1, and s represents the sign of the delta value. Furthermore, the larger the delta value, the greater the number of bits/depth in the corresponding codeword. For example, if "s=+1" represents a negative sign, a delta value of -5 will be encoded as codeword 6'b110011, and a delta value of +8 will be encoded as codeword 8'b11100000. Each codeword sequentially contains a first-order code, an index code, and a symbol code, where the first-order code is a unary code. For a non-zero delta value equal to -9, encoding its order q using unary coding will produce the first-order code 4'b1110, where q = =3; Represent an integer C using q bits in binary format. The code modulo 2 ^q = 1 is used to generate an index code 3'b001; finally, a symbol bit value of 1 is appended to the index code to form the codeword 8'b11100011. In each codeword in Table 2, each level code (i.e., each unary code) uses q ones plus one zero to represent level q, and the index code is placed between the level code and the symbol code; however, this is not a limitation of the invention. In another embodiment, in each codeword, each level code (i.e., each unary code) uses q zeros plus one 1 to represent level q, and the symbol code is placed between the level code and the index code.

One of the features of the operating value encoding method of this invention is that consecutive zeros and a non-zero integer are encoded alternately according to the encoding tables in Tables 1 and 2. In other words, the output of the VLC 230 contains two flags that are repeated until the end of the segment. These two flags are the first codeword representing ZR consecutive zeros (determined by Table 1) and the second codeword representing a non-zero integer (determined by Table 2). For example, after receiving the following sequence of quantized delta values (W quantized delta values in total): {+2, -3, 0, 0, 0, 1, 4, 0, 0, 0, 0 …., 0}, the VLC 230 treats (+2) as "ZR=0 plus (+2)" and encodes it as 5’b01000 (=1’b0+4’b1000); the VLC 230 treats (-3) as "ZR=0 plus (-3)" and encodes it as 5’b01011 (=1’b0+4’b1011); the VLC 230 treats {0, 0, 0, 1} as "ER=3, ZR=0 plus (+1)" and encodes it as 7’b1110000 (=4’b1110 + 1’b0 + 2’b00); VLC 230 treats the subsequent/remaining zeros at the end of the sequence: {0, 0, 0, 0 …., 0} as EOS and encodes them as a single codeword 4’1111.

In one embodiment, the following code is provided in VLC 230 to encode a sequence of quantized delta values: main(void) { ZR =p= 0; while (p＜W) {                 // W represents the segment width if (seq[p]==0)  ZR++;  // First, calculate the number of consecutive zeros ZR; seq[.] represents the sequence of quantized delta values else { encode_ZR(ZR);         // Next, encode ZR ZR = 0; encode_value(seq[p]); // Finally, encode a non-zero integer } p++; } if (ZR＞0) output ‘1111’;     // Indicates an EOS event } encode_ZR(int ZR){ while (ZR＞=3){ output '1110'; // Indicates an ER event ZR-=3; // Check ZR every three zeros } if (ZR==0) output '0'; // Please refer to the code in Table 1 else if (ZR==1) output '10'; else if (ZR==2) output '110'; } encode_Value (int value) { if (value＜0) sign=1; else sign=0; V = abs(value); Le = 0; // Le represents the class bound = 2; while (1) { if (V ＜ bound) break; bound = bound*2; Le=Le+1; } Base = bound/2; Index = V – Base; output Le consecutive '1'; // Please refer to the code in Table 2 output '0'; // Output index code output ‘Index’ with 1 bit; // Output index code output ‘sign’ with one bit; // Output sign code }

Next, multiplier 270 multiplies each delta value by Q to obtain a product value cp. Then, adder 260 adds the product value cp to the current predicted value p[k] to obtain a sum V. Then, limiter 240 receives the sum V based on the minimum value Mi and the maximum value Ma to generate a currently reconstructed pixel r[k], so Mi <= r[k] <= Ma.

In one embodiment, the following code is provided in predictor 250 for prediction: p[k] = k <= 1? (bx == 0? dc : r[W-2+k]) : r[k-2] ;

(bx, by) are the coordinates of the leftmost pixel of the current segment in the current LSDR image, W is the width of the current segment, and dc = ^2n-1 , where bx = 0~(Wi-1) and by = 0~(Hi-1), and Wi and Hi represent the width and height of each LSDR image, respectively. The above prediction code performs the following steps: (1) When k > 1, the value of the currently predicted pixel p[k] is equal to the value of the second immediately preceding reconstructed pixel r[k-2] (if k > 1, then p[k] = r[k-2]); (2) If k <= 1, then check if bx is equal to 0; (3) If bx = 0, it means that the current segment is located on the leftmost side of the current LSDR image, so set p[k] = dc = ^2n-1 ; (4) If bx If 0 and k <= 1, then set p[k] = r[W-2+k], where r[W] is a shared and covert one-dimensional array of size W. If bx 0 indicates that the current segment is not located on the far left of the current LSDR image.

Figure 5 is a schematic diagram of a Bayer image segment decoder 500 according to an embodiment of the present invention. Referring to Figure 5, the segment decoder 500 of the present invention includes a variable length decoder (VLD) 510, a limiter 240, a predictor 520, an adder 260, and a multiplier 270. Generally speaking, the decoding process performed by the segment decoder 500 is the opposite of the encoding process performed by the segment encoder 200 described above. The VLD 510 compares the front/leading bit pattern of the encoded bit stream with all the codewords in Tables 1 and 2 in an alternating manner to generate a decoded value delta in a decoded data sequence. The decoded value delta can be a set of consecutive zeros (i.e., a series of zeros) or a non-zero integer. In other words, VLD 510 first compares the pattern of the first bit of the encoded bit stream with all the codewords in Table 1 to generate a corresponding decoded value delta. Then, it compares the pattern of the next first bit of the encoded bit stream with all the codewords in Table 2 to generate a corresponding decoded value delta. This process is repeated until the entire encoded bit stream has been processed. Please refer to the code below for details.

The structures and operations of predictors 250 and 520 are similar. For example, predictor 520 provides the following code for prediction: p[k]=k＜=1? (ax==0? dc : r[W-2+k]) : r[k-2] ;

(ax, ay) are the coordinates of the leftmost pixel of the currently reconstructed segment in the currently decompressed/reconstructed LSDR image, k represents the index value of the currently reconstructed pixel in the currently reconstructed segment, W is the width of the currently reconstructed segment, and dc= ^2n-1 , where k=0~(W-1), ax=0~(Wi-1) and ay=0~(Hi-1), and Wi and Hi represent the width and height of each reconstructed LSDR image, respectively. The above-mentioned predictor 520 prediction code performs the following steps: (1) When k>1, the value of the currently predicted pixel p[k] is equal to the value of the previous second reconstructed pixel r[k-2] (if k>1, then p[k]=r[k-2]); (2) If k<=1, then check if ax is equal to 0; (3) If ax=0, it means that the above-mentioned currently reconstructed segment is located on the leftmost side of the currently reconstructed LSDR image, so set p[k]=dc= ^2n-1 ; (4) If ax If 0 and k <= 1, then set p[k] = r[W-2+k], where r[W] is a shared and covert one-dimensional array of size W. If ax 0 indicates that the currently reconstructed segment is not located on the far left of the currently reconstructed LSDR image.

The remaining elements (240, 260, and 270) of the segment decoder 500 operate in the same way as the segment encoder 200, and will not be described in detail. Finally, the segment decoder 500 outputs the currently reconstructed pixels r[k] of the currently reconstructed segment. 32 reconstructed pixels (because W=32) form a reconstructed segment, and a group of reconstructed segments forms a reconstructed LSDR image. In one embodiment, the following code is provided in VLD 510 to decode the encoded bitstream: main(void) { p = 0; while (p＜W) {               // W represents the segment width {ZR, EOS} = Decode_Run_EOB();  // First decode the "consecutive zeros"; the program returns ZR and EOS if (EOS)  break;      // If the EOS flag is set, exit the while loop for (i=0; i＜ZR; i++) {   // If ZR＞0, the decoded value = consecutive zeros seq[p] = 0; p++; } {value} = Decode_Value();  // Then decode the "non-zero integers"; the program returns value = non-zero integer seq[p] = value; p++; } while (p＜W) { seq[p] = 0; // Represents an EOS event p++; } } Decode_Run_EOB(){ Z=peep(4, ptr); // Read 4 bits from the current address ptr, assign the read value to Z, but do not change ptr; Z is a 4-bit variable; ptr is a pointer/address pointing to the beginning of the encoded bit stream EOS = 0; ZR = 0; if (Z==‘1111’) { fetch(4, ptr); // Read 4 bits from the current address ptr, and change ptr to (ptr+4) EOS=1; exit; } else{ do { if (Z==‘0xxx’) ZR = ZR+0; else if (Z=='10xx') ZR=ZR+1; else if (Z=='110x') ZR=ZR+2; else if (Z=='1110') { ZR=ZR+3; fetch(4, ptr); // Read 4 bits from the current address ptr and change ptr to (ptr+4) Z=peep(4, ptr); // Read 4 bits from the current address ptr, assign the read value to Z, but do not change ptr return ZR,EOS; } } while(Z=='1110') fetch (ZR+1, ptr); // Read (ZR+1) bits from the current address ptr and change ptr to (ptr+(ZR+1)) } Decode_Value () { Level = 0; do { X=peep(8, ptr); // Read 8 bits from the current address ptr, then assign the read value to Z, without changing ptr; X is an 8-bit variable; ptr is a pointer/address pointing to the beginning of the encoded bit stream if (X=='0xxxxxxx') level=level+0; else if (X=='10xxxxxx') level=level+1; else if (X=='110xxxxx') level=level+2; else if (X=='1110xxxx') level=level+3; else if (X=='11110xxx') level=level+4; else if (X=='111110xx') level=level+5; else if (X=='1111110x') level=level+6; else if (X=='11111110') level=level+7; else { level = level+8; // The number of consecutive 1s is greater than or equal to 8 fetch (8, ptr); // Read 8 bits from the current address ptr and change ptr to (ptr+8) } } while(X=='11111111'); index=fetch(level, ptr); // Read level bits from the current address ptr, assign the read value to index, and change ptr to (ptr+level) sign=fetch(1, ptr); // Read one bit from the current address ptr, assign the read value to sign, and change ptr to (ptr+1) value = (sign?-1:1)*((1<<level)+index); return value; }

In the code above, the function peep(m, ptr) reads m bits from the current pointer/address ptr without changing ptr; the function fetch(m, ptr) reads m bits from the current pointer/address ptr and changes ptr to (ptr+m), where ptr is a pointer/address pointing to the beginning of the encoded bit stream.

In short, the compression ratio of the segment encoder 200 of this invention is greater than or equal to 2x; furthermore, the encoded bit stream output by the segment encoder 200 can be mathematically reversed and decompressed in the segment decoder 500 to produce a high-quality reconstructed image, which, to the human eye, is exactly the same as the input image (feeded to the segment encoder 200). Moreover, the encoding and decoding process using the encoding tables in Tables 1 and 2 is both simple and accurate.

The segment encoder 200 and segment decoder 500 of the present invention can be implemented in software, custom hardware (such as a field programmable gate array or an application-specific integrated circuit), or a combination of software (or firmware) and hardware. In a preferred embodiment, the VLC 230 and predictor 250 in the segment encoder 200 are implemented using at least one first storage device and at least one first general-purpose processor; the VLD 510 and predictor 520 in the segment decoder 500 are implemented using at least one second storage device and at least one second general-purpose processor. The at least one first storage device stores a first processor executable program, and the at least one second storage device stores a second processor executable program. When the at least one first general-purpose processor executes the first processor executable program, the at least one first general-purpose processor is configured to operate as follows: VLC 230 and predictor 250. When the at least one second general-purpose processor executes the second processor executable program, the at least one second general-purpose processor is configured to operate as follows: VLD 510 and predictor 520.

The above are merely preferred embodiments of the present invention and are not intended to limit the scope of the patent application of the present invention; all other equivalent changes or modifications made without departing from the spirit disclosed in the present invention shall be included in the scope of the patent application below.

110: Image Sensor 120: ISP 130: DRAM 200: Segment Encoder 210: Subtractor 220: Quantizer 230: Variable Length Encoder 240: Limiter 250, 510: Predictor 260: Adder 270: Multiplier 500: Segment Decoder 510: Variable Length Decoder

[Figure 1] illustrates an example of an encoding/decoding system 100 according to an embodiment of the present invention. [Figure 2] illustrates a schematic diagram of a Bayer image segment encoder 200 according to an embodiment of the present invention. [Figure 3] shows the relationship between N, Q, and A values. [Figure 4] shows a portion of the calculated values (D values ranging from -3 to 14) of different equations with the same quantization level/parameter Q=3. Figure 5 is a schematic diagram of a Bayer image segment decoder 500 according to an embodiment of the present invention.

200: Segment Encoder

210: Subtraction Device

220: Quantizer

230: Variable Length Encoder

240: Limiter

250: Predictor

260: Adder

270: Multiplier

Claims (28)

A Bayer video encoding apparatus for image processing includes: a quantizer for quantizing the difference D between an input pixel and a currently predicted pixel according to a quantization parameter Q and an equation, to generate a quantized value in a quantization sequence. The equation is: A predictor, coupled to the quantizer, performs a set of first operations, including: providing the current predicted pixel based on the position of a current segment in a current Bayer image; and a variable length encoder, coupled to the quantizer, performs a set of second operations, including: (1) calculating the number of consecutive zeros ZR, wherein ZR consecutive zeros are located before the next non-zero integer in the quantization sequence or at the end of the quantization sequence; (2) encoding the ZR consecutive zeros into a first codeword using a first codeword group; (3) encoding the next non-zero integer into a second codeword using a second codeword group; and (4) repeating the second operations (1) to (3) until all quantized values in the quantization sequence have been processed to generate an encoded byte; wherein A satisfies the following equation: (Q A + 1) = N; and where N = 2 ^{d 2n} , where n represents the bit width of the input pixel and d is an integer. The apparatus of claim 1 further includes: a subtractor coupled between the quantizer and the predictor for subtracting the value of the currently predicted pixel from the value of the input pixel to generate the difference D. The apparatus of claim 1 further comprises: a multiplier coupled between the quantizer and the variable-length encoder for multiplying the quantized value by Q to obtain a product value; and an adder coupled between the predictor and the multiplier for adding the product value to the currently predicted pixel to obtain a currently reconstructed pixel. The apparatus of claim 1, wherein the first codeword group comprises a first unary code, a second unary code, a third unary code, a fourth unary code, and a fifth unary code, which respectively correspond to 0 zeros, 1 zero, 2 zeros, 3 zeros in the quantization sequence and subsequent quantization values are all equal to zero, and wherein the length of each unary code in the first codeword group is less than 5 bits. The apparatus of claim 4, wherein the second operation of encoding the ZR consecutive zeros into the first codeword using the first codeword group comprises: when ZR >= 3 and the ZR consecutive zeros precede the next non-zero integer in the quantization sequence, (21) generating the fourth unary code as part of the first codeword, (22) setting ZR to (ZR-3), and (23) repeating the second operations (21) and (22) until ZR < 3; when ZR = 0 and the ZR consecutive zeros precede the next non-zero integer in the quantization sequence, generating the first unary code as part of the first codeword; When ZR=1 and the ZR consecutive zero bits precede the next non-zero integer in the quantization sequence, the second unary code is generated as part of the first codeword; When ZR=2 and the ZR consecutive zero bits precede the next non-zero integer in the quantization sequence, the third unary code is generated as part of the first codeword; and When ZR>0 and the ZR consecutive zero bits are at the end of the quantization sequence, the first codeword is set to be equal to the fifth unary code. As in the apparatus of claim 1, wherein each codeword of the second codeword group comprises a level code and an index code, wherein the second operation (3) of encoding the next non-zero integer into the second codeword using the second codeword group comprises: encoding q using unary encoding to generate the level code, wherein q = And B represents the next non-zero integer; and an integer C is represented using (q+1) bits and a binary format to form the index code, where C = modulo 2 ^q , and one of the (q+1) bits of the index code is a symbol bit that corresponds to the symbol of B. As in the apparatus of claim 1, the first operation of providing the currently predicted pixel includes: when k > 1, providing the value of the currently predicted pixel equal to the value of a previously second reconstructed pixel; when the current segment is located on the leftmost side of the current Bayer image, providing the value of the currently predicted pixel equal to 2 ^{^n-1} ; when the current segment is not located on the leftmost side of the current Bayer image and k = 0, providing the value of the currently predicted pixel equal to the value of the second-to-last reconstructed pixel corresponding to the previous segment; and when the current segment is not located on the leftmost side of the current Bayer image and k = 1, providing the value of the currently predicted pixel equal to the value of the last reconstructed pixel corresponding to the previous segment; wherein k represents the index number of the input pixel in the current segment. A video encoding method for Bayer imagery includes the following steps: quantizing the difference D between an input pixel and a currently predicted pixel according to a quantization parameter Q and an equation to produce a quantized value in a quantization sequence. The equation is: Based on the position of a current segment in a current Bayer image, provide the current predicted pixel; calculate the number of consecutive zeros ZR, where the ZR consecutive zeros are located before the next non-zero integer in the quantization sequence or at the end of the quantization sequence; encode the ZR consecutive zeros into a first codeword using a first codeword group; encode the next non-zero integer into a second codeword using a second codeword group; and repeat the calculation steps, the steps of encoding the ZR consecutive zeros into the first codeword, and the steps of encoding the next non-zero integer into the second codeword, until all quantization values in the quantization sequence have been processed to generate an encoded byte; where A satisfies the following equation: (Q A + 1) = N; and where N = 2 ^{d 2n} , where n represents the bit width of the input pixel and d is an integer. The method of claim 8 further includes: subtracting the value of the currently predicted pixel from the value of the input pixel to generate the difference D. The method of claim 8 further includes: multiplying the quantization value by Q to obtain a product value; and adding the product value to the currently predicted pixel to obtain a currently reconstructed pixel. As in claim 8, the first codeword group includes a first unary code, a second unary code, a third unary code, a fourth unary code, and a fifth unary code, which respectively correspond to 0 zeros, 1 zero, 2 zeros, 3 zeros in the quantization sequence and subsequent quantization values are all equal to zero, and wherein the length of each unary code in the first codeword group is less than 5 bits. The method of claim 11, wherein the step of encoding the ZR consecutive zeros into the first codeword comprises: When ZR >= 3 and the ZR consecutive zeros precede the next non-zero integer in the quantization sequence, (a) generating the fourth unary code as part of the first codeword, (b) setting ZR to (ZR-3), (c) repeating steps (a) and (b) until ZR < 3; When ZR = 0 and the ZR consecutive zeros precede the next non-zero integer in the quantization sequence, generating the first unary code as part of the first codeword; When ZR = 1 and the ZR consecutive zeros precede the next non-zero integer in the quantization sequence, generating the second unary code as part of the first codeword; When ZR=2 and the ZR consecutive zero bits precede the next non-zero integer in the quantization sequence, the third unary code is generated as part of the first codeword; When ZR>0 and the ZR consecutive zero bits are at the end of the quantization sequence, the first codeword is set to be equal to the fifth unary code. As in claim 8, where each codeword of the second codeword group comprises a level code and an index code, the step of encoding the next non-zero integer into the second codeword comprises: encoding q using unary encoding to obtain the level code, where q = And B represents the next non-zero integer; an integer C is represented using (q+1) bits and binary format to form the index code, where C = modulo 2 ^q , and one of the (q+1) bits of the index code is a symbol bit that corresponds to the symbol of B. As in claim 8, the step of providing the currently predicted pixel includes: when k > 1, providing the value of the currently predicted pixel equal to the value of the second-to-last reconstructed pixel; when the current segment is located on the leftmost side of the current Bayer image, providing the value of the currently predicted pixel equal to 2 ^{^n-1} ; when the current segment is not located on the leftmost side of the current Bayer image and k = 0, providing the value of the currently predicted pixel equal to the value of the second-to-last reconstructed pixel corresponding to the previous segment; and when the current segment is not located on the leftmost side of the current Bayer image and k = 1, providing the value of the currently predicted pixel equal to the value of the last reconstructed pixel corresponding to the previous segment; where k represents the index number of the input pixel in the current segment. A video decoding apparatus for a Bayer image includes: a variable-length decoder for performing a first set of operations, including: alternately comparing a prefix bit pattern of an encoded byte with all codewords in a first codeword group and a second codeword group to generate a decoded value, the decoded value being either a sequence of consecutive zeros or a non-zero integer; and a predictor coupled to the variable-length decoder for performing a second set of operations, including: providing a current prediction pixel based on the position of a current reconstructed segment in a currently reconstructed Bayer image. The apparatus of claim 15 further comprises: a multiplier coupled to the variable-length decoder for multiplying the decoded value by a quantization parameter to obtain a product value; and an adder coupled between the predictor and the multiplier for adding the product value to the currently predicted pixel to obtain one of the currently reconstructed pixels of the currently reconstructed segment. The apparatus of claim 15, wherein the first codeword group comprises a plurality of unary codes, wherein the unary codes are less than 5 bits in length and correspond to different numbers of consecutive zeros of the decoded value, and wherein the second codeword group comprises a first-order code and an index code. The device of claim 17, wherein the first codeword group includes a first unary code, a second unary code, a third unary code and a fourth unary code corresponding to the decoded values being equal to 0 zeros, 1 zero, 2 zeros and 3 zeros respectively, and wherein the first codeword group further includes a fifth unary code corresponding to the subsequent decoded values in the currently reconstructed segment being equal to zero. The apparatus of claim 18, wherein the first operation of the comparison comprises: Resetting ZR, where ZR represents the number of consecutive zeros; Comparing the 4-bit front-end bit pattern with the five unary codes of the first codeword group; When the front-end bit pattern matches the fifth unary code, setting all subsequent decoded values in the currently reconstructed segment to zero; When the front-end bit pattern matches the fourth unary code, (1) Incrementing ZR by 3, (2) Removing the first 4 bits of the encoded bitstream to update the front-end bit pattern, and (3) Repeating the first operations (1) to (2) until the front-end bit pattern does not match the fourth unary code; When the front-end bit pattern matches the first unary code, keeping ZR unchanged; When the front-end bit pattern matches the second unary code, increment ZR by 1; When the front-end bit pattern matches the third unary code, increment ZR by 2; and When ZR > 0, provide the decoded value containing ZR consecutive zeros. The apparatus of claim 17, wherein the first operation of the comparison includes: calculating the number of consecutive default bit values in the front-end bit pattern. To obtain the level code, where the level code is a unary code; remove the first ( ) of the encoded bit stream. +1) units, to provide the next ( +1) The leading bit pattern of the unit digits is used as the index code; and the decoded value is obtained according to the level code and the index code; wherein, the index code is ( +1) One of the individual bits is a symbol bit. As in the apparatus of claim 15, the second operation of providing the currently predicted pixel includes: when k > 1, providing the value of the currently predicted pixel equal to the value of a previously second reconstructed pixel; when the currently reconstructed segment is located on the leftmost side of the currently reconstructed Bayer image, providing the value of the currently predicted pixel equal to 2 ^{^n-1} ; when the currently reconstructed segment is not located on the leftmost side of the currently reconstructed Bayer image and k = 0, providing the value of the currently predicted pixel equal to the value of the second-to-last reconstructed pixel corresponding to the previous reconstructed segment; and when the currently reconstructed segment is not located on the leftmost side of the currently reconstructed Bayer image and k = 1, providing the value of the currently predicted pixel equal to the value of the last reconstructed pixel corresponding to the previous reconstructed segment; wherein k represents the index number of the currently reconstructed pixel in the currently reconstructed segment. A video decoding method for Bayer imagery includes the following steps: Alternatingly comparing the leading bit pattern of an encoded byte with all codewords in a first codeword group and a second codeword group to generate a decoded value, which may be a sequence of consecutive zeros or a non-zero integer; Providing a currently predicted pixel based on the position of a currently reconstructed segment relative to a currently reconstructed Bayer imagery. The method of claim 22 further comprises: multiplying the decoded value by a quantization parameter to obtain a product value; and adding the product value to the currently predicted pixel to obtain one of the currently reconstructed pixels of the currently reconstructed segment. The method of claim 22, wherein the first codeword group comprises a plurality of unary codes, wherein the length of the unary codes is less than 5 bits and corresponds to a different number of consecutive zeros of the decoded value, and wherein the second codeword group comprises a first-order code and an index code. As in the method of claim 24, the first codeword group includes a first unary code, a second unary code, a third unary code, and a fourth unary code, which correspond to the decoded values being equal to 0 zeros, 1 zero, 2 zeros, and 3 zeros, respectively. The first codeword group also includes a fifth unary code, which corresponds to the subsequent decoded values in the currently reconstructed segment being equal to 0. The method of claim 25, wherein the comparison step comprises: Resetting ZR, where ZR represents the number of consecutive zeros; Comparing the 4-bit front-end bit pattern with the five unary codes of the first codeword; When the front-end bit pattern matches the fifth unary code, setting all subsequent decoded values in the currently reconstructed segment to 0; When the front-end bit pattern matches the fourth unary code, (1) Incrementing ZR by 3, (2) Removing the first 4 bits of the encoded bitstream to update the front-end bit pattern, and (3) Repeating steps (1) to (2) until the front-end bit pattern does not match the fourth unary code; When the front-end bit pattern matches the first unary code, keeping ZR unchanged; When the front-end bit pattern matches the second unary code, increment ZR by 1; When the front-end bit pattern matches the third unary code, increment ZR by 2; and When ZR > 0, provide the decoded value containing ZR consecutive zeros. The method of claim 24, wherein the comparison step includes: calculating the number of consecutive default bit values in the front-end bit pattern. To obtain the level code, where the level code is a unary code; remove the first ( ) of the encoded bit stream. +1) units of space to provide the next ( The leading bit pattern of +1) bits is used as the index code; and the decoded value is obtained according to the level code and the index code; wherein, the index code is ( +1) One of the individual bits is a symbol bit. As in claim 22, the provided second operation comprises: when k > 1, providing the value of the currently predicted pixel equal to the value of a previously second reconstructed pixel; when the currently reconstructed segment is located on the leftmost side of the currently reconstructed Bayer image, providing the value of the currently predicted pixel equal to 2 ^{^n-1} ; when the currently reconstructed segment is not located on the leftmost side of the currently reconstructed Bayer image and k = 0, providing the value of the currently predicted pixel equal to the value of the second-to-last reconstructed pixel corresponding to the previous reconstructed segment; and when the currently reconstructed segment is not located on the leftmost side of the currently reconstructed Bayer image and k = 1, providing the value of the currently predicted pixel equal to the value of the last reconstructed pixel corresponding to the previous reconstructed segment; wherein k represents the index number of the currently reconstructed pixel in the currently reconstructed segment.