JP2003204554A - Image signal encoding apparatus and encoding method - Google Patents

Abstract

(57) [Summary] PROBLEM TO BE SOLVED: To satisfactorily perform a process of controlling a quantization step according to an activity of each processing block. SOLUTION: The current min is set in S1. The order of activities is obtained for qq, a variable i indicating the order is initialized to 0 in S2, and the i-th activity is substituted for the variable in S3. In step S4, q-scaIe is obtained. In S5, the total code amount when q-scaIe is lowered by one step is obtained. In S6, the total code amount is compared with the target code amount. If the total code amount is equal to or less than the target code amount, the quantization step can be reduced. Therefore, the variable i indicating the order of the activity is advanced in S7, and the total
Update l and return to S3. If it is determined in S6 that the generated code amount is larger than the target code amount, the processing shifts to processing in units of macro blocks. Min whose total code amount is less than or equal to the target code amount
act is set. Activity order and min for each macroblock Whether to reduce the quantization step is controlled according to the result of comparison with act.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to an image signal encoding apparatus and an encoding method applicable to, for example, motion compensation and encoding using DCT (Discrete Cosine Transform).

[0002]

2. Description of the Related Art MPEG (Moving Pictures Expert Grou)
p) In the image compression method using DCT represented by the standard,
The code amount is controlled so that the bit stream sent to the transmission path has a desired rate. For example, the code amount is controlled by controlling the quantization index representing the quantization step. In the code amount control proposed as TM5 in MPEG2, the quantization step is feedback controlled by using the relationship between the remaining amount of the virtual buffer, the quantization index and the generated code amount at the time of previous encoding.

FIG. 1 shows the layer structure of MPEG. Sequence layer, GOP (Group Of Picture)
A hierarchical structure including layers, picture layers, slice layers, and macroblock layers is defined. More specifically, as shown in FIG. 1, a code generated in a predetermined period such as one frame by changing the quantization step in the data (called Q scale) included in the slice layer or macroblock layer. Adjusting the amount. For example, in the format of (4: 2: 0), four luminance signal blocks and color signal U
, And one block of the color signal V constitute a macro block.

As an example, the value q on the Q scale As scales, 31 kinds of Q1 to Q31 are prepared. The larger the Q scale number, the larger the quantization step. As shown in FIG. 2, regarding the relationship between the quantization and the total code length (also appropriately referred to as the total code amount), when the quantization step is increased, the quantization becomes coarse and the total code length decreases. On the contrary, when the quantization step is reduced, the quantization becomes finer and the total code length increases. Moreover, since the quantization can take only discrete values, the total code length is also discrete.

In applications such as communication, it is general to apply feedback to the current average rate using the relationship between the previous quantization step and the total code amount. That is, if the current average rate is higher than the target rate, the quantization step is slightly coarsened to reduce the total code amount, and if the current average rate is low, the quantization step is slightly fined to increase the total code amount. . In this way, control is performed so that the target rate is realized on average. That is,
Although the total code amount increases / decreases when viewed in a fine time, the total code amount becomes an average value when viewed in a long span.

However, a VTR based on the premise of editing, etc.
In an application like this, a problem will occur if control is performed only with the average rate as described above. In such an application, since there is an operation such as editing for each frame, it is necessary to control such that the total code amount does not exceed a certain amount for each editing unit. Hereinafter, such control will be referred to as fixed length code amount control.

[0007]

Since such control is difficult in the above-mentioned feedback control, the reproduced image may be broken, or the margin is too large so that the code amount does not exceed and the image quality deteriorates. There was something that happened. Therefore, quantization is performed using a plurality of fixed quantizers having different quantization steps in advance, and based on the total code amount at that time,
A technique of performing quantization control is known. For example, WO96 / 28937 discloses a feedforward type code amount control.

Specifically, there are 31 kinds of Q shown in FIG.
Quantizers each having a scale are provided, and the total code amount of the quantized DCT coefficient quantized by each quantizer in one frame period is obtained, and the total code amount is the target code amount (target bit length in FIG. 2). ) Is not exceeded and the difference with respect to the target code amount is small, the Q scale is determined. Figure 2
In the above example, Q4 corresponds to such a Q scale.

However, the calculated value of, for example, 31
The problem is how to determine the quantization step based on the total code amount at the time of the type of quantization. Q scale is
Since it is discrete, there is a problem that the bit rate can take only discrete values and fine control cannot be performed, and the difference from the target code amount cannot be sufficiently small.

Therefore, an object of the present invention is to reduce the difference between the target code amount and the total code amount in the feedforward type code amount control without exceeding the target code amount depending on the activity. An object is to provide a possible image signal encoding device and encoding method.

[0011]

According to a first aspect of the present invention, there is provided an image signal encoding apparatus for quantizing an image signal within a target code amount for each equal-length unit composed of a plurality of blocks, in which prediction is performed. And a predicting unit that quantizes the difference with each of a plurality of pieces of quantization information and, when quantized with each piece of quantization information, obtains a total code amount generated in equal length units,
A unit for determining the first quantization information having the minimum difference between the total code amount and the target code amount without the total code amount generated in the equal length unit exceeding the target code amount, and for each processing block of the image. The determining means comprises means for detecting local information and outputting the local information, and determining means for changing the first quantized information by the local information to determine the final second quantized information. For each of the first quantized information, the order is calculated in ascending order of the difference between the quantized information in which the local information is considered and the quantized information obtained by reducing the quantized information by one step. Based on the local information set by the first setting unit that aggregates the code amount for each local information and sets the local information that satisfies the target code amount from the aggregated code amount Processing block that can unconditionally reduce one quantization information , The second quantization information is determined by determining whether it is a processing block in which the quantization information cannot be reduced or a processing block in which it is verified whether or not the quantization information can be reduced. When determining and verifying whether or not it is possible to reduce the quantized information, an image including second setting means for comparing the total code amount and the target code amount by the quantized information that is reduced by one It is a signal encoding device.

According to a third aspect of the present invention, in an image signal encoding method for quantizing an image signal within a target code amount for each equal-length unit composed of a plurality of blocks, a difference is obtained between a plurality of pieces of quantization information. Respectively, when quantized by each quantization information, the step of obtaining the total code amount generated in the equal length unit, and the total code amount generated in the equal length unit does not exceed the target code amount, A step of determining first quantization information having a minimum difference between the total code amount and the target code amount, a step of detecting activity for each processing block of an image and outputting local information, and a first quantization A decision step of changing the information according to the local information to decide the final second quantized information, wherein the decision step includes, for each of the first quantized information, quantized information considering the local information. The quantization information is one step smaller The order is calculated in ascending order of the difference from the above, the code amount is aggregated for each local information starting from the earliest sequence, and the local information satisfying the target code amount is set from the aggregated code amount. The first setting step and the first
Based on the local information set by the setting step, the processing block that can unconditionally reduce one quantization information, the processing block that cannot reduce the quantization information, and the quantization information are reduced. When determining whether the second quantization information is determined by determining which is the processing block for performing the verification of whether the quantization information can be reduced or not, Is a second comparing the total code amount by the quantized information reduced by one and the target code amount.
And an image signal encoding method including the setting step.

The quantized information considering the activity is
Since they are discrete values, there is a difference between the target code amount and the total code amount. In order to reduce this, for example, the quantization step of each macroblock is reduced by one. In that case, the order is obtained for the local information for each quantization step, and the local information whose total code amount does not exceed the target code amount is set in order from the earliest one. Next, the quantization step is controlled in processing block units. In that case, a processing block whose order is earlier than the set local information unconditionally reduces one quantization step, and a processing block whose order is the same as the set local information reduces one quantization step. It is verified whether it is possible.

[0014]

BEST MODE FOR CARRYING OUT THE INVENTION An embodiment of the present invention will be described below with reference to the drawings. FIG. 3 shows the overall configuration of an encoder to which the present invention is applied. As an example, 1
Control is performed so that the total code length becomes a fixed length for each frame, that is, for each screen. In FIG. 3, reference numeral 1 indicates a scan conversion unit. In the scan conversion unit 1, the input image signal is divided into macroblocks. When the input image is progressive scan, it is divided into macroblocks as it is, and when interlaced scan is performed, it is divided into macroblocks by field-frame conversion. In MPEG, a block of size (16 × 16), which is composed of four DCT blocks, is configured for the luminance signal. When the color difference signals Cr and Cb are (4: 2: 0), blocks of (8 × 8) are formed. These six DCT blocks in total are combined to form one macroblock.

The data converted into macroblocks in the scan conversion unit 1 are input to the main line system 2 and the prediction system 3, respectively. The main line system 2 includes a FIFO denoted by reference numeral 4, a DCT processing unit denoted by reference numeral 5, a quantization unit denoted by reference numeral 6, and a VLC (Variable Lease) denoted by reference numeral 7.
ngth Coding) and a buffer with reference numeral 8.

In the DCT processing section 5, intra coding is performed and the input pixel value itself is DCT processed. The interframe difference between the predicted value formed by motion compensation of the local decoded value of the previous frame and the input pixel value may be obtained, and the interframe difference may be DCT. The quantization unit 6 includes a quantization step Q determined for each macroblock mb in the prediction system 3. final [mb] is supplied, this quantization step Q DCT coefficients are quantized by final [mb]. The FIFO 4 uses the quantization step Q in the prediction system 3. It is a delay element to compensate for the time until final is determined.

The quantized DCT coefficient from the quantizer 6 is VL.
Variable length coding is performed in the C unit 7. The output of the VLC unit 7 is supplied to the buffer 8. Smoothing is performed by the buffer 8 and the bit stream is output.

The prediction system 3 includes a DCT processing unit indicated by reference numeral 9 and reference numerals 10-1, 10-2, ..., 10-n.
N quantizers and reference symbols 11-1, 11-
2, ..., 11-n code amount detectors, a memory indicated by reference numeral 12, a quantization step determination unit indicated by reference numeral 13, and a working memory indicated by reference numeral 14. , Activity calculation circuit 15. The quantization step from the quantization step determination unit 13 is supplied to the quantization unit 6 of the main line system 2 described above.

The n quantizers 10-1, 10-2, ...
., 10-n are quantized at different quantization steps. The quantized DCT coefficient generated by each quantizer is supplied to the code amount detectors 11-1, 11-2, ..., 11-n, and the code amount of each macroblock is detected by the code amount detector 11-.
, 11-2, ..., 11-n. Code amount detectors 11-1, 11-2, ..., 11-
n has a configuration in which the quantized DCT coefficient is variable-length coded similarly to the VLC unit 7, and the variable-length code is aggregated for macroblocks. The code amount of each quantization for each macro block obtained in this way is stored in the buffer memory 12.

On the memory 12, for macroblock mb, q The code amount quantized by scaIe is Length [mb, q sca1
Save as a two-dimensional array such as e]. For example, if the number of macroblocks in one screen is 1350 and the type of quantization step is 31, one of the vertical and horizontal addresses is from (mb = 1) to (mb = 1350),
The other of the vertical and horizontal addresses is (q From scaIe = 1) to (q up to scaIe = 31), and the data of the code amount of each macroblock is stored at the address on the memory designated by both.

Using the code amount stored in the memory 12,
The code amount when summing up one screen while selecting one quantization step for each macroblock is the target code amount GEN.
Look for the closest combination of quantization steps that does not exceed TGT (see FIG. 2). The method for obtaining the combination of the quantization steps is related to the present invention. In an actual application, the quantization step of each macroblock is not made the same, but is changed in consideration of its property for each macroblock. For this purpose, an activity calculation circuit 15 is provided, and local information Act (mb) of each macroblock is calculated. The activity Act (mb) is supplied to the buffer memory 12.

The quantization step determining unit 13 is provided in the memory 12
The reference quantization min that does not exceed the target code amount by using the content of Using the contents of memory 12 to determine qq, which is the final one, as described below, Q It determines the final.

The quantization step determination unit 13 determines the quantization step determined for each macroblock mb as Q. f
It is stored in the form of an array called inal [mb]. This information is transmitted to the main line system 2. In the quantization unit 6 of the main line system 2, each macro block mb Quantization step Q detected for each no fina
The DCT coefficient of the macroblock is quantized by l [mb].

By such processing, fixed length code amount control can be realized in which the total code length of the equal length unit, for example, one screen unit, is made equal to or smaller than a desired amount. In this control, the target code amount GEN It is important to find a combination of quantization steps that does not exceed TGT and is closest to TGT. In the example of FIG. 2, in Q3, the total code length is the target code amount GEN. It exceeds TGT, and the total code length of Q4 is the target code amount GEN. It is the closest one within a range not exceeding TGT. Even so, when Q4 is applied, the total code length and the target code amount GEN There is a difference between TGT. It is desirable that this difference be as small as possible.

Here, in order to reduce this difference, it is effective to change the quantization step using the activity information of the macroblock. An activity represents a local image property on the screen. In the case of component signals, the luminance signal is used to calculate activity.

As the activity of the macroblock, several things such as the sum of the absolute values of the differences can be used as conventionally known. For example, as the activity, a macroblock as shown in the following formula 1 is used. A variance of the constituent pixel values can be used. In Expression 1, N is the number of pixels forming the macroblock, x is the pixel value, Σ is the total for N pixels, and x ^ is the average value of the pixel values of the macroblock.

Act (mb) = 1 / N · Σ (x−x ^) ² (1) (x ^ = 1 / N · Σx)

FIG. 4 shows the configuration of the activity calculation circuit 15. Reference numeral 101 is a macroblock average value calculation circuit, reference numeral 102 is a FIFO as a delay element for time adjustment, and a subtracter indicated by reference numeral 103 calculates the difference between each pixel value and the average value. .
The difference is squared by a squarer indicated by reference numeral 104, further integrated by an integrator 105, and the integrated value is divided by a division circuit indicated by 106. The division circuit 106 generates activity information Act (mb) represented by Expression 1.

Quantizers 10-1, 10-2 of the prediction system 3,
・ ・ ・ 1-10-n does not perform quantization considering activity. Each quantizer quantizes the DCT coefficient over the entire screen on the Q scale. The activity calculation circuit 15 in FIG. 3 has the configuration of FIG. 4 described above.

Then, for the constant value Q ^ref applied to the entire one screen, the quantization step Q ^act (mb) considering the activity applied to each macroblock is obtained. 1 using the code amount Length [mb, Q ^act (mb)] of the macroblock when quantized in this quantization step
The total code amount of the screen is obtained. Next, of the total code amount when Q ^ref is changed, the target code amount GEN Not exceed TGT, and the difference between the target code amount causes a total code amount for minimizing Q ^ref is the reference quantization min qq is obtained by the quantization step determination unit 13.

A method for obtaining the reference quantization min_qq will be described.
And explain. In the prediction system 3, as described above, 31 types
Quantization according to the Q scale of the class
Volume Length [mb, q scaIe] is stored in memory 12.
It Activities are not considered here. This
Quantization step q Reference quantization step with scaIe
Q^refThe macro block's activity
Considering Q^actIf, the sign obtained
Quantity, Q^refAccumulate over 1 screen as index
It As a result, when the processing of the prediction system for one screen is completed,
Is each reference quantization Q ^refConsider the activity against
The code amount of the screen sum considered is obtained.

In the rate control, Q ^ref is changed discretely to obtain the target code amount GEN. Target code amount GEN without exceeding TGT Find the reference quantization that minimizes the difference from the TGT. In this way min qq is required. This process requires the comparison of number of times equal to the total number of Q ^{re f.}

In order to realize the above processing, the prediction system 3 is provided with a quantization step determining unit 13. FIG. 5 shows an example of the configuration of the quantization step determining unit 13. The data given as input is the activity information Act (mb) of the macroblock (mbth macroblock).
, Q scale, and code amount when quantized by Q scale
Length (mb). The quantization step determination unit 13 outputs the address to the memory 12 and corresponds to the address.
Since Length (mb) is received, the value of the Q scale is known.
One Act (mb) is determined for each macroblock, and the Q scale applies different values in each macroblock in parallel by the quantizers 10-1, ..., 10-n, and Length (mb) is calculated. The activity information Act (mb) is supplied from the activity calculation circuit 15. The code amount Length (mb) is read from the memory 12. As an input to the quantization step determination unit 13, the code amount Length (m
b) is supplied in order from the first macroblock of the screen to the last macroblock.

Act (mb) and Q scale are supplied to the mapping unit indicated by reference numeral 301. The mapping unit 301 converts the Q scale (Q ^act ) input in the inverse relationship of the following Expression 2 into Q ^ref , for example. That is, assuming that the Q scale considers the activity, the mapping unit 301 outputs a value Q ^ref that does not consider the activity.

The deterioration of the image quality is relatively inconspicuous in the areas where the activity is large, and the quantization step can be made relatively coarse, and the deterioration in the image quality is relatively conspicuous in the areas where the activity is small. The conversion step needs to be relatively fine. A method of associating an activity with a quantization step will be described below.

[0036] with respect to the reference quantization step Q ^ref, the quantization step in the case of considering the activity of the (quantization step actually used) When ^{Q act (mb), Q act} (mb by the following formula 2 ) Is determined. In this case, controlling the total code amount to be equal to or less than the target code amount is ignored. The reference quantization step Q ^ref means a quantization step of quantizing the entire one screen without considering the activity. Since this one embodiment considers the activity as the local information of the screen, a virtual Q ^ref is introduced and the Q ^ref is changed according to the activity. The rate of change is constant depending on the activity, regardless of the value of Q ^ref .

Q ^act (mb) = f _map (Q ^ref (mb), act (mb)) (2)

Here, the function f _map () is the same as act (mb) and Q
It is for calculating Q ^act (mb) from ^ref . For example, the one used in TM (Test Model) 5 of MPEG is shown by the following Expression 3.

F _{map TM} (Q ^ref (mb), act (mb)) = [(2.0 × act (mb) + N act) / (act (mb) ＋ 2.0 × N act)] × Q ^ref (mb) (3)

Where N Although act is the average of one screen of act (mb), the value of the previous screen may be used in consideration of the system delay. In Expression 3, act (mb) = N act
Then, the coefficient k by which Q ^{ref is} multiplied becomes 1. If act (mb) = 0, the coefficient k to be multiplied with respect to Q ^{r ef} is 0.5. The coefficient k can take values in the range 0.5 to 2. Using such a function f _map (), Q
Calculate ^act (mb). Originally, activity information Act (m
b) is a continuous value (value with a value after the decimal point),
A properly rounded representative value, for example, a representative value of 16 steps is sufficient for image quality.

As a simple example, there are four macroblocks in one screen, and the quantization operation considering the activity information Act (mb) of each macroblock is (× 0.5, × 1.0, ×).
0.5, × 2.0). In the case the reference quantization Q ^ref is for example 10, the quantization Q ^act in consideration of activity for each macroblock, Act against Q ^ref
By performing the operation considering (mb), it becomes (5,10,5,20). For example, Act (mb) = 0.5 for the mapping unit 301
It can be seen that Q ^ref is 20 when Q ^act = 10 is supplied.

Reference quantization Q from mapping section 301
^{The ref} is supplied to the address generator 302. The address generator 302 generates the address of the memory 303 from Q ^ref . The memory 303 is cleared at the beginning of the frame in advance. When 31 kinds of Q ^ref are prepared, there are 31 addresses of the memory 303 corresponding to Q ^ref . 31 types of Q scales and Lengths corresponding to the respective Q scales are input to the quantization step determination unit 13 for each macroblock in one screen.

When an address is given to the memory 303, the amount of data already written at that address is read from the memory 303 and fed back to the adder 304. Then, the sum added with the input Length in the adder 304 is written in the same address of the memory 303,
Accumulation operation is performed. Therefore, when the processing of all macroblocks in one screen is completed, the total code amount for each Q ^ref is stored in the memory 303.

Next, the count value of the counter indicated by reference numeral 305 is the address generation unit 302 and the register 309.
Is supplied to. The count value is decremented, for example, 30, 29, ..., 0, corresponding to 31 values of Q ^ref . The total code amount increases as Q ^ref is decremented. Address generator 302
Read address (that is, Q
^ref ) is given to the memory 303. The total code amount of the address is read from the memory 303, and the total code amount is supplied to the subtractor 306.

The subtractor 306 has a target code amount GEN. T
When the GT is supplied and the total code amount read from the memory 303 is the target code amount GEN Subtracted from TGT. The output of the subtractor 306 is supplied to the comparator 307 and the register 308. The output of comparator 307 is provided as an enable to registers 308 and 309. Comparator 3
The output of register 308 is provided as the other input of 07.

The comparator 307 compares the subtraction output of the subtractor 306 with the register data stored in the register 308, and when the subtraction output is smaller than the register data,
Registers 308 and 309 generate the compare output as an enable to capture the inputs. If the subtraction output is negative, the comparator 307 does not generate an enable. Therefore, at the time when the generation of the read addresses corresponding to all of Q ^ref is completed, the minimum subtraction output is stored in the register 308, and the count value corresponding to Q ^ref that generated the minimum subtraction output is stored in the register 309. Is stored. This count value is min Output as qq. The count of the counter 305 may be stopped when the subtraction output becomes negative.

The process of the quantization step determining unit 13 will be described more specifically with reference to FIG. For simplicity, the quantization step (q (scale) types are 1, 2, 4,
8 and 16, and the quantization operation (coefficient k) considering the activity is 0.5, 1.0, and 2.0. In this case, Q ^ref and Q ^act have the relationship shown in FIG. 6A. For example, in the case of Q ^ref = 2, the quantization step Q ^act considering the activity is Q ^act = 1 and Q ^act = 2.
Q ^act = 4.

Now, four macro blocks mb0, mb1, mb2, mb
Consider a screen consisting of three. Each activity
The information (coefficient k) is (2.0,0.5,2.0,1.0). In the screen
Q^ref , 2, 4, 8 each macroblock mbn
The quantization step considering the activity of FIG.
It will be as shown in. Q^ref= 1 and Q^ref= 16
The value after operation will fall outside the specified range.
To exclude for. That is, it is treated as not applicable.
It

Therefore, the total code amount of one screen for Q ^ref total The length (Q ^ref ) is as shown below.

Total length (2) = Length [mb0,4] + Length
[mb1,1] ＋ Length [mb2,4] ＋ Length [mb3,2] total length (4) = Length [mb0,8] + Length [mb1,2] + Len
gth [mb2,8] ＋ Length [mb3,4] total length (8) = Length [mb0,16] + Length [mb1,4] + Le
ngth [mb2,16] ＋ Length [mb3,8]

In the prediction system 3 in FIG. 3, all the quantization steps 1, 2, 4, 8 and 16 are performed for each macroblock.
Quantize each by. First, total length
(2), total length (4), total length (8) is initialized to 0. For the first macroblock mb0, Length [mb
0,1], Length [mb0,2], Length [mb0,4], Length [mb0,
8], Length [mb0,16] are obtained. Since the operation (coefficient k) of the quantization step considering the activity of mb0 is 2, the code amount for each Q ^ref can be found as follows by obtaining the relationship of Q ^ref from Q ^act with reference to FIG. 6A. .

Length [mb0,1] ... Not applicable (Q ^act
It means that there is no Q ^ref such that 1 becomes 1. ) Length [mb0,2] ··· Code quantity considering activity with Q ^ref = 1 Length [mb0,4] ··· Code quantity considering activity with Q ^ref = 2 Length [mb0,8] ··· Q code amount considering the activity in ^ref = 4 Length ^[mb0,16] code amount in consideration of the activity in ···· Q ^ref = 8

The mapping unit 301 (see FIG. 5) refers to the table shown in FIG. 6A. The address of the memory 303 is changed according to Q ^ref from the mapping unit 301, and integration is performed. This allows to in macroblock mb0 only
tal The length is as follows.

Total length (2) = Length [mb0,4] total length (4) = Length [mb0,8] total length (8) = Length [mb0,16]

For the macroblock mb1, the operation of the quantization step (coefficient k) considering the activity is 0.
Since it is 5, the code amount can be similarly known with reference to FIG. 6A.

Length [mb1,1] ... Code amount considering the activity when Q ^ref = 2 Length [mb1,2] ... Code amount considering the activity when Q ^ref = 4 Length [mb1,4] ] ・ ・ ・ ・ Code amount Length [mb1,8] considering activity with Q ^ref = 8 ・ ・ ・ ・ Code amount Length [mb1,16] considering activity with Q ^ref = 16 ・ ・ ・ ・ ・ ・ Not applicable

By this, tota up to macroblock mb1
l The length is as follows.

Total length (2) = Length [mb0,4] + Length (mb1,1] total length (4) = Length [mb0,8] + Length (mb1,2] total length (8) = Length [mb0,16] + Length (mb1,4]

For the macroblock mb2, the quantization step operation (coefficient k) considering the activity is 2.
Since it is 0, the code amount can be similarly known with reference to FIG. 6A.

[0060] Length [mb2,1] ···· applicable without Length [mb2,2] ···· Q ^ref = amount of code in consideration of the activity in ^{1 Length [mb2,4] ···· Q ref} = 2 , Code amount considering the activity in Length [mb2,8] ··· Code amount considering the activity in Q ^ref = 4 Length [mb2,16] ··· Code amount considering the activity in Q ^ref = 8

As a result, tota up to macroblock mb2
l The length is as follows.

Total length (2) = Length [mb0,4] + Length
[mb1,1] ＋ Length [mb2,4] total length (4) = Length [mb0,8] + Length [mb1,2] + Len
gth [mb2,8] total length (8) = Length [mb0,16] + Length [mb1,4] + Le
It will be ngth [mb2,16].

For the macroblock mb3, the operation (coefficient k) of the quantization step considering the activity is 1.
Since it is 0, the code amount can be similarly known with reference to FIG. 6A.

Length [mb3,1] ... Code amount considering the activity with Q ^ref = 1 Length [mb3,2] ... Code amount considering the activity with Q ^ref = 2 Length [mb3,4 ] ··· Code amount Length [mb3,8] considering activity with Q ^ref = 4 ··· Code amount Length [mb3,16] considering activity with Q ^ref = 8 ··· Q ^ref = 16 Code amount considering activity in

As a result, the total of up to macroblock mb3 (that is, one screen) The length is as follows.

Total length (2) = Length [mb0,4] + Length
[mb1,1] ＋ Length [mb2,4] ＋ Length [mb3,2] total length (4) = Length [mb0,8] + Length [mb1,2] + Len
gth [mb2,8] ＋ Length [mb3,4] total length (8) = Length [mb0,16] + Length [mb1,4] + Le
It becomes ngth [mb2,16] + Length [mb3,8]. As described above, the total code amount of one screen for the Q ^refs of 2, 4, and 8 is obtained.

By the above processing, the target code amount GEN
The target code amount GEN is not exceeded without exceeding TGT. The reference quantization Q ^ref with the smallest difference from the TGT is min It is calculated as qq.
However, since Q ^ref is operated discretely, the bit rate can take only discrete values and fine control cannot be performed. Therefore, the target code amount GEN The difference from TGT may not be sufficiently small. Therefore, the present invention takes advantage of the fact that the quantization step can only select discrete discrete values, and the actually usable Q ^act (mb) is mapped to a close value by processing such as rounding. Target code amount GEN The difference from the TGT is made smaller. The bit rate is finely adjusted by using the rounding process.

That is, when it is desired to slightly reduce the bit rate, the Q scale may be increased for some macroblocks to reduce the total code amount. At this time,
Round up the rounded down rounding when considering the activities, that is, the rounded down rounds that seem to cause less harm. On the other hand, when it is desired to increase the bit rate slightly, the Q scale may be reduced for some macroblocks to increase the total code amount. At this time, the rounding-up process is performed in order from the largest amount rounded up. Thereby, when the Q scale is changed in consideration of the activity, the error is small with respect to the original Q scale.

An example is shown below. For simplicity, it is assumed that one screen is composed of four macro blocks. The quantization step of continuous values (values obtained to the right of the decimal point) considering the activity for each macroblock to obtain the desired bit rate is (3.2, 5.9, 4.1, 10.5).
And If you round this off, you get (3, 6,
4 and 11). If the bit rate obtained by this combination is higher than the desired one and the bit rate is desired to be lowered, the Q scale is changed in the following order. The value in () shows the difference from the original continuous value.

3 → 4 (0.8), 4 → 5 (0.9), 6 → 7 (1.
1), 11 → 12 (1.5)

On the contrary, when the bit rate is lower than the desired one and it is desired to increase the bit rate, the following order is applied. The value in () shows the difference from the original continuous value.

11 → 10 (0.5), 6 → 5 (0.9), 4 → 3
(1.1), 3 → 2 (1.2)

The above-mentioned min qq is set so that it does not exceed the target code amount, and there is still a margin up to the target code amount, so we try to increase the bit rate by using this margin, so in this case, the bit rate is This is lower than what is desired, and corresponds to the case where it is desired to increase the bit rate, and a process for reducing the Q scale is necessary. However,
Processing order For example, when the Q scale is decreased from the upper left end of the screen toward the lower right end, only the Q scale of the first part of the process is controlled, and the Q scale is not controlled in the latter part of the screen. There is an inconvenience that is not so effective for improving It is necessary to control the quantization step according to the activity information without causing such an inconvenience. A method for realizing such processing (called an activity partial sum method) will be described below.

The activity partial sum method uses the reference quantization min in the prediction system 3. In order to obtain qq, the code amount is totaled, and at the same time, the sum of the code amount for each activity is obtained. That is, the activities Act (mb) and q Array data indexed by two variables of scaI act sub ttl [acti
vity, q scaIe] is generated. This data will be called activity partial sum. If you use discrete values for the activity, q Since scaIe is also a discrete value, the capacity for storing this data is feasible.

FIG. 7 shows an example of the structure of the activity partial sum calculation circuit. The configuration is similar to that of FIG. 5 described above. That is, the quantization step determination unit 13 is
In addition to the above configuration, the activity partial sum calculation circuit of FIG. 7 is also provided. In the configuration of FIG. 5, when the processing of all macroblocks of one screen is completed, the total code amount for each Q ^ref is stored in the memory. On the other hand, in the configuration of FIG. 7, when processing of all macroblocks on one screen is completed, the activity and q The accumulated code amount indexed by the two variables of scaIe is stored in the memory.

In FIG. 7, reference numeral 401 indicates an address generation circuit, and reference numeral 402 indicates a memory. The address generation circuit 401 generates a write address and a read address for the memory 402. The write address is activity Act (mb) and q Determined by both scaIe (mb). An arbitrary address is given as the read address. When the same write address is designated, the read data from the memory 402 and the input data (Length) are added by the adder 403, and the addition output is written to the same address of the memory 402.
The memory 402 is cleared every frame. Therefore, the activity and q The accumulated code amount of one screen indexed by two variables of scaIe is stored. Each code amount is a partial activity sum.

Min After obtaining qq, the reference quantization min For qq, the order of activities in which the difference between the “non-rounding quantization step Q ^act (mb) considering the activity” and the “quantization step reduced by one step” is calculated. This is the activity and q Since scaIe is a discrete value, it can be calculated in advance and all q scaI
For each of the e, the order of the activities can be easily obtained by making a table of the order of the activities.

Based on the order of the activities, the quantization step is shifted by one step using the activity partial sum and the increase in the code amount is examined. That is, the quantization step is lowered by one from the earliest order. The total code amount is the target code amount GEN GEN without exceeding TGT
Find the activity with the smallest difference from the TGT. This is min Act. This process is done a number of times equal to the total number of activities.

Next, the macro block is examined. sand
Wow, the order of activities is min Macro faster than act
For blocks, unconditionally one quantization step
Lower. The order of activities is min same macro as act
For blocks, lower the quantization step by one.
Check if and are possible. The order of activities is min
For macroblocks one slower than act, the quantization step
It is impossible to lower the level by one step. This process
This is done a number of times equal to the total number of macroblocks.

8 and 9 are flow charts for explaining the above-mentioned activity partial sum method. In the configuration of FIG. 3, the quantization step determination unit 13 performs the process shown in the flowchart. These figures show a series of processes, but are divided into two figures due to the restriction of the drawing space. In the first step S1,
Current min with reference to table The order of activities act for qq ask for queue []. In this order, the earliest order is 0, and the order is 1, 2, ... The slowest ranking is the total number of activities minus one.

In step S2, a variable i indicating the order of activities is initialized to 0. In step S3,
Assign the i-th activity to the variable act.

At step S4, act and min qq by q
Find scaIe. In step S5, q Calculate the total code amount when scaIe is lowered by one step. The total code amount is written as tmp.

Q Since the sum of the generated code amount increases due to the decrease of scaIe, the total code amount tmp is set in step S6.
And the target code amount GEN Compare with TGT. Total code amount is GEN If it is less than or equal to TGT, the quantization step can be lowered, so that the process proceeds to the next step S7. In step S7, the variable i indicating the order of activities is advanced, total is updated in step S8, and the process returns to step S3. The same processing as described above is performed regarding the order of the next activity.

In step S6, the generated code amount is the target code amount GEN. If it is determined that it is larger than TGT, the process proceeds to step S9. The flow after step S9 is shown in FIG. The flow in FIG. 9 is processing in units of macroblocks. At step S9, one variable i indicating the order of activities is subtracted. The order of the activities resulting from this subtraction is that the total code amount tmp is the target code amount GEN.
It does not exceed TGT.

In step S10, the variable mb, which is the index of the macroblock, is initialized to zero. In step S11, the variable mb is the total number of macroblocks MB. It is determined whether it is NUM. If so, it means that the processing of all macroblocks has been completed, so the processing is completed.
Variable mb is the total number of macroblocks MB If it has not reached NUM, the process proceeds to step S12.

In step S12, the order of activity of the macroblock indicated by mb and min in step S9.
Compare with act. Order is min If it is smaller than act, the quantization step can be unconditionally lowered, so that the step jumps to step S17 and the quantization step of the macro block mb is reduced by one. Order is min If it is larger than act, the quantization step cannot be lowered, so the process jumps to step S18, and the macroblock mb is advanced without lowering the quantization step. The order is
min If it is equal to act, the quantization step may be lowered, so for verification, the next step S13
Proceed to.

In step S13, act and min qq by q scaIe is required. In step S14, q of the macro block mb The total code amount tmp when scaIe is subtracted by 1 is obtained. That is, q The result obtained by adding the increment of the code amount by subtracting scaIe to the original total code amount is substituted for the total code amount tmp.

In step S15, the total code amount tmp and the target code amount GEN Compare with TGT. Total code amount tmp is G
EN If it is equal to or lower than TGT, the quantization step can be lowered, so that the process proceeds to the next step S16. If not, the process jumps to step S18 (process for advancing mb).

In step S16, the total code amount is actually updated. Then, in step S17, the quantization step of the macro block mb is reduced by one. Step S18
In step S11, advance mb to step S11 (mb and total number of macroblocks MB. NUM comparison).

FIG. 10 explains the processing for obtaining the order of activities. For each reference quantization Q ^ref and each activity, q An example of the order in which the scale is changed is shown. Here, k represents a coefficient for operating the quantization step according to the activity information, that is, a coefficient portion to be multiplied by Q ^ref (mb) in the equation (3). As described above, macroblocks with high activity require coarse quantization steps, and macroblocks with low activity require fine quantization steps. That is, when the activity is small, the coefficient is made small, and the quantization step is finely divided. On the contrary, when the activity is large,
Coefficients are increased and quantization steps are coarser. Therefore, this coefficient k can be treated as an activity. In FIG. 10, for the sake of simplicity, the activity k can take five discrete values (0.5, 0.75, 1.0, 1.5, 2.0).

This “quantization step without rounding considering activity Q ^act (mb) (5,7.5,10,15,20)” and “the rounded quantization step reduced by one step (4,7,9 ,14,
19) ”is the smallest in the difference, that is, the order in which the difference with the value that should be taken as a continuous value is the smallest is ranked.

For example, when Q ^ref = 10, the value obtained by multiplying the activity k is (5,7.5,10,15,20), and the rounded value is (5,8,10,15,20). Become. To increase the bit rate, subtract 1 from the rounded quantization, (4,
7,9,14,19). Ordering is done in ascending order of difference. In this case, 0.75 is the fastest activity. Even in the case of Q ^ref = 11, the ranking is similarly obtained. For example, another Q of Q1 to Q31 shown in FIG.
The order of activities is also required for ^refs . The table shown in FIG. 10 can be obtained in advance. In step S1 in FIG. 8, the order of activities can be obtained by referring to the table.

In the present invention, the signal to be quantized may be either the image signal or the difference between the image signal and the predicted image signal. Further, in the above description, DCT is used as transform coding, but not limited to DCT, wavelet transform, Haar transform, KL transform, etc.
This invention can be applied.

The present invention can also be applied to the case of recording compression-coded data on a magnetic tape or a hard disk or a magneto-optical disk.

Further, as the structure of the macroblock,
Not only (4: 2: 0), but also (4: 2: 2) and (4: 4:
The structure may be 4), (4: 1: 1) or the like. The number of DCT blocks included in the macro block is not limited. Furthermore, the equal length unit for controlling the code amount is not limited to one frame, and a shorter period may be set.

[0096]

Since the present invention is feedforward control, it is possible to avoid problems in feedback control. That is, it is possible to control so that a certain number of frames can be suppressed to a certain bit rate without causing a breakdown of a reproduced image due to a sudden change in the data amount at the time of a scene change.

Further, according to the present invention, since the quantization step is changed depending on the local property of the image, the quality of the decoded image can be improved. In this case, the activity information is set to a discrete value, the order of the activity information is obtained, and the activity having the smallest difference from the target code amount is set within a range not exceeding the target code amount. Next, when performing processing in units of macroblocks, by comparing the activity information of each macroblock with the set activity, it is possible to limit the macroblocks for which the quantization step needs to be controlled. The quantization step can be determined by various processes.

[Brief description of drawings]

FIG. 1 is a schematic diagram showing an example of a method of transmitting data of a quantization step.

FIG. 2 is a schematic diagram showing an example of a change in total code length generated in one frame with respect to a quantization step.

FIG. 3 is a block diagram showing the overall configuration of an embodiment of the present invention.

FIG. 4 is a block diagram of an example of an activity calculation circuit.

FIG. 5 is a block diagram of an example of a quantization step determining unit according to an embodiment of the present invention.

FIG. 6 is a schematic diagram for explaining the relationship between Q ^ref and Q ^act in the quantization step in the embodiment of the present invention.

FIG. 7 is a block diagram of an example of an activity partial sum calculation circuit according to an embodiment of the present invention.

FIG. 8 is a flowchart illustrating a method of controlling a quantization step according to an embodiment of the present invention.

FIG. 9 is a flowchart illustrating a method of controlling a quantization step according to an embodiment of the present invention.

FIG. 10 is a schematic diagram for explaining a method of controlling a quantization step according to activity information according to an embodiment of the present invention.

[Explanation of symbols]

2 ... Main line system, 3 ... Prediction system, 6 ... Quantization unit,
10-1 to 10-n ... Quantizer, 13 ... Quantization step determination unit, 15 ... Activity calculation unit

   ─────────────────────────────────────────────────── ─── Continued front page    F-term (reference) 5C053 FA14 FA21 GA11 GB22 GB26                       GB28 GB34 GB38                 5C059 KK22 KK30 KK36 MA00 MA23                       MC11 MC38 ME01 PP16 SS11                       TA47 TB04 TC06 TC10 TC19                       TC38 TD04 UA02 UA33                 5J064 AA01 AA02 BA16 BB03 BC01                       BC04 BC16 BC21 BC26 BD01

Claims (4)

[Claims] 1. An image signal coding apparatus for quantizing an image signal within a target code amount for each equal-length unit composed of a plurality of blocks, wherein a prediction unit is provided, and the prediction unit is a plurality of units. A means for determining the total code amount generated in the equal length unit when the difference is quantized by the quantized information and quantized by each quantized information, and the total code amount generated in the equal length unit is the target. Means for determining first quantized information having a minimum difference between the total code amount and the target code amount without exceeding the code amount, and detecting local information for each processing block of an image to obtain local information. And a deciding means for deciding the final second quantized information by changing the first quantized information by the local information, and the deciding means comprises the first quantized information. For each piece of quantized information, the quantization information and its Of the quantized information, the order is calculated in ascending order of the difference from the quantized information, and the code amount is aggregated for each of the local information starting from the earlier sequence, and the target is calculated from the aggregated code amount. First setting means for setting local information satisfying the code amount, and a processing block capable of unconditionally subtracting one piece of quantization information based on the local information set by the first setting means. And the processing block in which the quantization information cannot be reduced, and the processing block in which it is verified whether or not the quantization information can be reduced are determined. When determining information and verifying whether it is possible to subtract the quantized information,
An image signal encoding apparatus comprising second setting means for comparing the total code amount based on the subtracted quantized information with the target code amount. 2. The image signal encoding device according to claim 1, wherein the prediction unit further has information of the order of each of the first quantization information as a lookup table. 3. An image signal encoding method for quantizing an image signal within a target code amount for each equal-length unit made up of a plurality of blocks, wherein each difference is quantized by a plurality of pieces of quantization information, A step of obtaining a total code amount generated in the equal length unit when quantized by each quantization information, and a total code amount generated in the equal length unit not exceeding a target code amount, Determining the first quantization information with the smallest difference between the amount and the target code amount, detecting the activity for each processing block of the image, and outputting the local information, the first quantization A decision step of deciding the final second quantized information by changing the information according to the local information, wherein the decision step considers the local information for each of the first quantized information. Quantization information and its Coca information in order difference is small and those one step smaller, determined order,
A first setting step of starting from the earliest one in order, totalizing the code amount for each of the local information, and setting local information satisfying the target code amount from the totalized code amount; Based on the local information set by the setting step, the processing block that can unconditionally reduce one quantization information, the processing block that cannot reduce the quantization information, and the quantization information are reduced. The second quantized information is determined by deciding which of the processing blocks is to verify whether or not the quantized information can be reduced. In this case, the image signal encoding method comprises a second setting step of comparing the total code amount obtained by subtracting the quantized information with the target code amount. 4. The image signal encoding method according to claim 3, further comprising the information of the order for each of the first quantized information as a lookup table.