JP2021048556A - Image decoding device and image coding device - Google Patents

Abstract

To provide an image decoding device and an image coding device to which weighting for conversion coefficients can be more preferably applied.SOLUTION: An image decoding device includes a scaling list decoding unit that decodes a first scaling list for separation conversion and a second scaling list for non-separation conversion, a scaling unit that performs scaling with respect to the decoded conversion coefficient, a second conversion unit that applies an inverse non-separation conversion to the conversion coefficient scaled by the scaling unit, and a first conversion unit that applies inverse core conversion to the conversion coefficient converted by the second conversion unit or the conversion coefficient scaled by the scaling unit, and the scaling list decoding unit decodes the value of the fixed number of elements as the second scaling list for each predetermined size.SELECTED DRAWING: Figure 22

Description

Embodiments of the present invention relate to an image decoding device and an image coding device.

In order to efficiently transmit or record an image, an image coding device that generates coded data by encoding the image and an image decoding device that generates a decoded image by decoding the coded data It is used.

Specific image coding methods include, for example, H.264 / AVC and HEVC (High-Efficiency Video).
Coding) method and the like.

In such an image coding method, the image (picture) constituting the image is a slice obtained by dividing the image, a coding tree unit (CTU: Coding Tree Unit) obtained by dividing the slice, and the like. A coding unit (sometimes called a coding unit (CU)) obtained by dividing a coding tree unit, and a transformation unit (TU: Transform Unit) obtained by dividing a coding unit. ) Is managed by a hierarchical structure, and each CU is encoded / decoded.

Further, in such an image coding method, a predicted image is usually generated based on a locally decoded image obtained by encoding / decoding an input image, and the predicted image is subtracted from the input image (original image). The resulting prediction error (sometimes referred to as a "difference image" or "residual image") is encoded. Examples of the method for generating a prediction image include inter-screen prediction (inter-screen prediction) and in-screen prediction (intra-prediction).

In addition, Non-Patent Document 1 is mentioned as a recent image coding and decoding technique. Non-Patent Document 1 discloses an image coding device that derives a conversion coefficient by converting each coefficient after conversion of a prediction error for each conversion unit by RST (Reduced Secondary Transform) conversion, that is, a secondary transformation. .. Further, Non-Patent Document 1 discloses an image decoding apparatus that reversely converts the conversion coefficient for each conversion unit by inverse secondary conversion. Non-Patent Document 2 discloses a technique of performing different scaling for each position of the conversion coefficient using a quantization matrix (scaling list).

"CE6: Reduced Secondary Transform (RST) (CE6-3.1)", JVET-N0193-v5, Joint Video Experts Team (JVET) of ITU-T SG 16 WP 3 and ISO / IEC JTC 1 / SC 29/WG 11, 2019-03-27 "CE7-related: Support of signaling default and user-defined scaling matrices", JVET-N0090-v3, Joint Video Experts Team (JVET) of ITU-T SG 16 WP 3 and ISO / IEC JTC 1 / SC 29/WG 11 , 2019-03-23

In the technique related to non-separation conversion as in Non-Patent Document 1, there is a problem that weighting (scaling) for an appropriate conversion coefficient cannot be performed with a quantization matrix corresponding to a normal spatial frequency.

An object of the present invention is to provide an image decoding device and an image coding device thereof to which weighting for conversion coefficients can be more preferably applied.

A scaling list decoding unit that decodes a first scaling list for separation conversion and a second scaling list for non-separation conversion, a scaling unit that scales with respect to the decoded conversion coefficient, and a scaling unit that is scaled by the scaling unit. Inverse core conversion is performed on the second conversion unit that applies the inverse non-separation conversion to the conversion coefficient, the conversion coefficient converted by the second conversion unit, or the conversion coefficient scaled by the scaling unit. The scaling list decoding unit includes a first conversion unit to be applied, and is characterized in that the value of a fixed number of elements is decoded as the second scaling list for each predetermined size.

According to the above configuration, any of the above problems can be solved.

It is the schematic which shows the structure of the image transmission system which concerns on this embodiment. It is a figure which showed the structure of the transmitting device equipped with the moving image coding device which concerns on this embodiment, and the receiving device equipped with moving image decoding device. PROD_A indicates a transmitting device equipped with a moving image coding device, and PROD_B indicates a receiving device equipped with a moving image decoding device. It is a figure which showed the structure of the recording device which mounted the moving image coding device which concerns on this embodiment, and the reproduction device which mounted on moving image decoding device. PROD_C indicates a recording device equipped with a moving image coding device, and PROD_D indicates a playback device equipped with a moving image decoding device. It is a figure which shows the hierarchical structure of the data of a coded stream. It is a figure which shows the division example of CTU. It is a schematic diagram which shows the type (mode number) of an intra prediction mode. It is the schematic which shows the structure of the moving image decoding apparatus. It is a flowchart explaining the schematic operation of the moving image decoding apparatus. It is the schematic which shows the structure of the intra prediction parameter decoding part. It is a functional block diagram which shows the structural example of the inverse quantization / inverse conversion part. It is a functional block diagram which shows the structural example of the inverse quantization / inverse conversion part. It is a figure which shows the method of deriving the scaling list number matrixId from CuPredMode, cIdx. It is a figure which shows the method of deriving the scaling list number matrixId from CuPredMode, cIdx, stIdx. It is a figure which shows the method of deriving the scaling list number matrixId from CuPredMode, cIdx, stIdx. It is a figure which shows the method of deriving the scaling list number matrixId from CuPredMode, cIdx, stIdx. It is a block diagram which shows the structure of the moving image coding apparatus. It is the schematic which shows the structure of the intra prediction parameter coding part. It is a figure explaining an example of a scaling list. It is a figure for demonstrating the syntax structure of a scaling list. It is a figure for demonstrating the syntax structure of a scaling list. It is a figure for demonstrating the syntax structure of a scaling list. It is a figure explaining the decoding method of the scaling list for non-separation conversion. It is a figure explaining the secondary conversion. It is a figure for demonstrating the syntax structure of the scaling list for non-separation conversion. It is the schematic which shows the structure of the moving image decoding apparatus of this embodiment which includes the scaling list decoding part for non-separation conversion.

[Embodiment 1]
Hereinafter, embodiments of the present invention will be described with reference to the drawings.

FIG. 1 is a schematic view showing a configuration of an image transmission system 1 according to the present embodiment.

The image transmission system 1 is a system that transmits a coded stream in which a coded image is encoded, decodes the transmitted coded stream, and displays an image. The image transmission system 1 includes a moving image coding device (image coding device) 11, a network 21, a moving image decoding device (image decoding device) 31, and an image display device (image display device) 41.

The image T is input to the moving image coding device 11.

The network 21 transmits the coded stream Te generated by the moving image coding device 11 to the moving image decoding device 31. The network 21 is an Internet (Internet), a wide area network (WAN: Wide Area Network), a small network (LAN: Local Area Network), or a combination thereof. The network 21 is not necessarily limited to a two-way communication network, but may be a one-way communication network that transmits broadcast waves such as terrestrial digital broadcasting and satellite broadcasting. Further, the network 21 may be replaced with a storage medium on which a coded stream Te such as a DVD (Digital Versatile Disc: registered trademark) or BD (Blue-ray Disc: registered trademark) is recorded.

The moving image decoding device 31 decodes each of the coded streams Te transmitted by the network 21 and generates one or a plurality of decoded images Td.

The image display device 41 displays all or a part of one or a plurality of decoded images Td generated by the moving image decoding device 31. The image display device 41 includes, for example, a display device such as a liquid crystal display or an organic EL (Electro-luminescence) display. Examples of the display form include stationary, mobile, and HMD. Further, when the moving image decoding device 31 has a high processing capacity, an image having a high image quality is displayed, and when the moving image decoding device 31 has a lower processing capacity, an image which does not require a high processing capacity and a display capacity is displayed. ..

<Operator>
The operators used herein are described below.

>> is the right bit shift, << is the left bit shift, & is the bitwise AND, | is the bitwise OR, | = is the OR assignment operator, and || is the OR.

x? y: z is a ternary operator that takes y when x is true (other than 0) and z when x is false (0).

Clip3 (a, b, c) is a function that clips c to a value greater than or equal to a and less than or equal to b. Is a function that returns c (where a <= b).

abs (a) is a function that returns the absolute value of a.

Int (a) is a function that returns an integer value of a.

floor (a) is a function that returns the smallest integer less than or equal to a.

ceil (a) is a function that returns the largest integer greater than or equal to a.

a / d represents the division of a by d (rounded down to the nearest whole number).

<Structure of coded stream Te>
Prior to the detailed description of the moving image coding device 11 and the moving image decoding device 31 according to the present embodiment, the data of the coded stream Te generated by the moving image coding device 11 and decoded by the moving image decoding device 31. The structure will be described.

FIG. 4 is a diagram showing a hierarchical structure of data in the coded stream Te. The coded stream Te typically includes a sequence and a plurality of pictures that make up the sequence. In FIG. 4, the coded video sequence that defines the sequence SEQ, the coded picture that defines the picture PICT, the coded slice that defines the slice S, the coded slice data that defines the slice data, and the coded slice data, respectively. A diagram showing a coded tree unit included and a coded unit included in the coded tree unit is shown.

(Coded video sequence)
The coded video sequence defines a set of data that the moving image decoding device 31 refers to in order to decode the sequence SEQ to be processed. The sequence SEQ includes a video parameter set (Video Parameter Set), a sequence parameter set SPS (Sequence Parameter Set), a picture parameter set PPS (Picture Parameter Set), a picture PICT, and a picture PICT, as shown in the encoded video sequence of FIG. Includes Supplemental Enhancement Information (SEI).

The video parameter set VPS defines a set of coding parameters common to a plurality of images and a set of coding parameters related to the plurality of layers included in the image and each layer in an image composed of a plurality of layers. Has been done.

The sequence parameter set SPS defines a set of coding parameters that the moving image decoding device 31 refers to in order to decode the target sequence. For example, the width and height of the picture are specified. There may be a plurality of SPS. In that case, select one of multiple SPSs from PPS.

The picture parameter set PPS defines a set of coding parameters that the moving image decoding device 31 refers to in order to decode each picture in the target sequence. For example, the quantization width reference value (pic_init_qp_minus26) used for decoding the picture, the flag (weighted_pred_flag) indicating the application of the weighted prediction, and the scaling list (quantization matrix) are included. There may be a plurality of PPSs. In that case, one of a plurality of PPSs is selected from each picture in the target sequence.

(Coded picture)
The coded picture defines a set of data referred to by the moving image decoding device 31 in order to decode the picture PICT to be processed. The picture PICT includes slices 0 to NS-1 as shown in the coded picture in FIG. 4 (NS is the total number of slices contained in the picture PICT).

In the following, when it is not necessary to distinguish between slice 0 and slice NS-1, the subscripts of the symbols may be omitted. The same applies to the data included in the coded stream Te described below and with subscripts.

(Coded slice)
The coded slice defines a set of data referred to by the moving image decoding device 31 in order to decode the slice S to be processed. The slice contains a slice header and slice data, as shown in the coded slice of FIG.

The slice header contains a group of coding parameters referred to by the moving image decoding device 31 to determine the decoding method of the target slice. The slice type specification information (slice_type) that specifies the slice type is an example of the coding parameter included in the slice header.

The slice types that can be specified by the slice type specification information include (1) I slices that use only intra-prediction during coding, and (2) P-slices that use unidirectional prediction or intra-prediction during coding. (3) Examples thereof include a B slice that uses unidirectional prediction, bidirectional prediction, or intra prediction at the time of coding. Note that the inter-prediction is not limited to single prediction and bi-prediction, and a prediction image may be generated using more reference pictures. Hereinafter, when referred to as P and B slices, they refer to slices containing blocks for which inter-prediction can be used.

The slice header may include a reference (pic_parameter_set_id) to the picture parameter set PPS.

(Coded slice data)
The coded slice data defines a set of data referred to by the moving image decoding device 31 in order to decode the slice data to be processed. The slice data includes a CTU, as shown in the coded slice header of FIG. A CTU is a fixed-size (for example, 64x64) block that constitutes a slice, and is sometimes called a maximum coding unit (LCU).

(Coded tree unit)
The coded tree unit of FIG. 4 defines a set of data referred to by the moving image decoding device 31 in order to decode the CTU to be processed. CTU is the basis of coding processing by recursive quadtree division (QT (Quad Tree) division), binary tree division (BT (Binary Tree) division) or ternary tree division (TT (Ternary Tree) division). It is divided into a coding unit CU, which is a typical unit. The BT division and the TT division are collectively called a multi-tree division (MT (Multi Tree) division). A tree-structured node obtained by recursive quadtree division is called a coding node. The intermediate nodes of the quadtree, binary, and ternary tree are coded nodes, and the CTU itself is defined as the highest level coded node.

As CT information, CT includes a QT division flag (cu_split_flag) indicating whether or not to perform QT division, an MT division flag (split_mt_flag) indicating the presence or absence of MT division, and an MT division direction (split_mt_dir) indicating the division direction of MT division. Includes MT split type (split_mt_type) that indicates the split type of MT split. cu_split_flag, split_mt_flag, split_mt_dir, split_mt_type are transmitted for each coding node.

If cu_split_flag is 1, the coding node is split into 4 coding nodes (QT in Figure 5).

When cu_split_flag is 0 and split_mt_flag is 0, the coded node is not divided and has one CU as a node (no division in Fig. 5). The CU is the terminal node of the coding node and is not divided any further. The CU is the basic unit of coding processing.

When split_mt_flag is 1, the coding node is MT split as follows. When split_mt_type is 0, the coded node is horizontally divided into two coded nodes when split_mt_dir is 1 (BT (horizontal split) in Fig. 5), and when split_mt_dir is 0, the coded node is coded in two. It is vertically divided into nodes (BT (vertical division) in Fig. 5). Also, when split_mt_type is 1, the coding node is horizontally divided into 3 coding nodes when split_mt_dir is 1 (TT (horizontal division) in Fig. 5), and when split_mt_dir is 0, there are 3 coding nodes. It is vertically divided into coding nodes (TT (vertical division) in Fig. 5). These are shown in the CT information in FIG.

When the CTU size is 64x64 pixels, the CU size is 64x64 pixels, 64x32 pixels, 32x64 pixels, 32x32 pixels, 64x16 pixels, 16x64 pixels, 32x16 pixels, 16x32 pixels, 16x16 pixels, 64x8 pixels, 8x64 pixels. , 32x8 pixels, 8x32 pixels, 16x8 pixels, 8x16 pixels, 8x8 pixels, 64x4 pixels, 4x64 pixels, 32x4 pixels, 4x32 pixels, 16x4 pixels, 4x16 pixels, 8x4 pixels, 4x8 pixels, and 4x4 pixels. ..

(Code-coding unit)
As shown in the coding unit of FIG. 4, a set of data referred to by the moving image decoding device 31 for decoding the coding unit to be processed is defined. Specifically, the CU is composed of a CU header CUH, a prediction parameter, a conversion parameter, a quantization conversion coefficient, and the like. The CU header defines the prediction mode and so on.

The prediction process may be performed in CU units or in sub-CU units in which the CU is further divided. If the size of the CU and the sub CU are equal, there is only one sub CU in the CU. If the CU is larger than the size of the sub CU, the CU is split into sub CUs. For example, if the CU is 8x8 and the sub CU is 4x4, the CU is divided into 4 sub CUs consisting of 2 horizontal divisions and 2 vertical divisions.

There are at least two types of prediction (prediction mode CuPredMode): intra prediction (MODE_INTRA) and inter prediction (MODE_INTER). In addition, an intrablock copy prediction (MODE_IBC) may be provided. Intra-prediction and intra-block copy prediction are predictions within the same picture, and inter-prediction refers to prediction processing performed between different pictures (for example, between display times and between layer images).

The conversion / quantization process is performed in CU units, but the quantization conversion coefficient may be entropy-encoded in subblock units such as 4x4.

(Prediction parameter)
The prediction image is derived by the prediction parameters associated with the block. Prediction parameters include intra-prediction and inter-prediction prediction parameters.

Hereinafter, the prediction parameters of the intra prediction will be described. The intra prediction parameters are composed of the luminance prediction mode IntraPredModeY and the color difference prediction mode IntraPredModeC. FIG. 6 is a schematic diagram showing the types (mode numbers) of the intra prediction modes. As shown in FIG. 6, there are 67 types (0 to 66) of intra prediction modes, for example. For example, planar prediction (0), DC prediction (1), Angular prediction (2-66). In addition, LM modes (67-72) may be added for color difference.

Syntax elements for deriving intra prediction parameters include, for example, intra_luma_mpm_flag, intra_luma_mpm_idx, intra_luma_mpm_remainder and the like.

(MPM)
intra_luma_mpm_flag is a flag indicating whether or not IntraPredModeY and MPM (Most Probable Mode) of the target block match. MPM is a prediction mode included in the MPM candidate list mpmCandList []. The MPM candidate list is a list that stores candidates that are presumed to have a high probability of being applied to the target block from the intra prediction mode of the adjacent block and the predetermined intra prediction mode. When intra_luma_mpm_flag is 1, the IntraPredModeY of the target block is derived using the MPM candidate list and the index intra_luma_mpm_idx.

IntraPredModeY = mpmCandList [intra_luma_mpm_idx]
(REM)
When intra_luma_mpm_flag is 0, the intra prediction mode is selected from the remaining modes RemIntraPredMode excluding the intra prediction modes included in the MPM candidate list from the entire intra prediction mode. The intra prediction mode that can be selected as the RemIntraPredMode is called "non-MPM" or "REM". RemIntraPredMode is derived using intra_luma_mpm_remainder.

(Configuration of moving image decoding device)
The configuration of the moving image decoding device 31 (FIG. 7) according to the present embodiment will be described.

The moving image decoding device 31 includes an entropy decoding unit 301, a parameter decoding unit (predicted image decoding device) 302, a loop filter 305, a reference picture memory 306, a predicted parameter memory 307, a predicted image generator (predicted image generator) 308, and a reverse. It is composed of a quantization / inverse conversion unit 311 and an addition unit 312. In addition, there is also a configuration in which the loop filter 305 is not included in the moving image decoding device 31 in accordance with the moving image coding device 11 described later.

The parameter decoding unit 302 further includes a header decoding unit 3020, a CT information decoding unit 3021, and a CU decoding unit 3022 (prediction mode decoding unit), and the CU decoding unit 3022 includes a TU decoding unit 3024. These may be generically called a decoding module. The header decoding unit 3020 decodes the parameter set information such as VPS, SPS, PPS, and the slice header (slice information) from the coded data. The CT information decoding unit 3021 decodes the CT from the coded data. The CU decoding unit 3022 decodes the CU from the coded data. The TU decoding unit 3024 decodes the QP update information (quantization correction value) and the quantization prediction error (residual_coding) from the coded data when the TU contains a prediction error.

The TU decoding unit 3024 decodes the value stIdx indicating the use of the secondary conversion and the conversion basis from the coded data. Specifically, in the TU decoding unit 3024, the width and height of the CU are 4 or more, the prediction mode is the intra mode, and the number of conversion coefficients in the CU numSigCoeff is a predetermined number THSt (for example). , SINGLE_TREE is 2, otherwise 1) Decrypts stIdx if it is greater than. When stIdx is 0, it indicates that the secondary conversion is not applied, when it is 1, it indicates the conversion of one of the set (pair) of the secondary conversion basis, and when it is 2, it indicates the conversion of the other of the above pairs. Further, stIdx may be decoded when the variable lfnstLastScanPos derived from the last position lastScanPos of the conversion coefficient is 0.

lfnstLastScanPos = 1
if (log2TbWidth> = 2 &&log2TbHeight> = 2 &&! Transform_skip_flag) {
lfnstLastScanPos = lfnstLastScanPos && (lastScanPos <1)
}
Also, stIdx may be decrypted only when mtsIdx is 0. Also, stIdx may be 0 or 1. Further, stIdx may be derived from the intra prediction mode.

stIdx = stIdx! = 0? (IntraPredModeY% 2) + 1: 0
Further, the parameter decoding unit 302 includes an inter-prediction parameter decoding unit 303 and an intra-prediction parameter decoding unit 304 (not shown). The prediction image generation unit 308 includes an inter-prediction image generation unit 309 and an intra-prediction image generation unit 310.

In the following, an example in which CTU and CU are used as the processing unit will be described, but the processing is not limited to this example, and processing may be performed in sub-CU units. Alternatively, CTU and CU may be read as blocks, sub-CUs may be read as sub-blocks, and processing may be performed in units of blocks or sub-blocks.

The entropy decoding unit 301 performs entropy decoding on the coded stream Te input from the outside, separates and decodes each code (syntax element). For entropy coding, a method of variable-length coding of syntax elements using a context (probability model) adaptively selected according to the type of syntax element and the surrounding situation, a predetermined table, or There is a method of variable-length coding the syntax element using a calculation formula. The former CABAC (Context Adaptive Binary Arithmetic Coding) stores a stochastic model updated for each coded or decoded picture (slice) in memory. Then, as the initial state of the context of the P picture or the B picture, the probability model of the picture using the same slice type and the same slice level quantization parameter is set from the probability models stored in the memory. This initial state is used for coding and decoding processing. The separated codes include prediction information for generating a prediction image, prediction error for generating a difference image, and the like.

The entropy decoding unit 301 outputs the separated codes to the parameter decoding unit 302. The separated code is, for example, the prediction mode CuPredMode. The control of which code is decoded is performed based on the instruction of the parameter decoding unit 302.

(Basic flow)
FIG. 8 is a flowchart illustrating a schematic operation of the moving image decoding device 31.

(S1100: Parameter set information decoding) The header decoding unit 3020 decodes the parameter set information such as VPS, SPS, and PPS from the coded data.

(S1200: Decoding of slice information) The header decoding unit 3020 decodes the slice header (slice information) from the coded data.

Hereinafter, the moving image decoding device 31 derives a decoded image of each CTU by repeating the processes of S1300 to S5000 for each CTU included in the target picture.

(S1300: CTU information decoding) The CT information decoding unit 3021 decodes the CTU from the encoded data.

(S1400: CT information decoding) The CT information decoding unit 3021 decodes the CT from the encoded data.

(S1500: CU decoding) The CU decoding unit 3022 executes S1510 and S1520 to decode the CU from the coded data.

(S1510: CU information decoding) The CU decoding unit 3022 decodes CU information, prediction information, TU division flag split_transform_flag, CU residual flags cbf_cb, cbf_cr, cbf_luma, etc. from the encoded data.

(S1520: TU information decoding) When the TU contains a prediction error, the TU decoding unit 3024 decodes the QP update information (quantization correction value) and the quantization prediction error (residual_coding) from the encoded data. The QP update information is a difference value from the quantization parameter prediction value qPpred, which is the prediction value of the quantization parameter QP.

(S2000: Prediction image generation) The prediction image generation unit 308 generates a prediction image based on the prediction information for each block included in the target CU.

(S3000: Inverse quantization / inverse conversion) The inverse quantization / inverse conversion unit 311 executes the inverse quantization / inverse conversion process for each TU included in the target CU.

(S4000: Decoded image generation) The addition unit 312 decodes the target CU by adding the prediction image supplied by the prediction image generation unit 308 and the prediction error supplied by the inverse quantization / inverse conversion unit 311. Generate an image.

(S5000: Loop filter) The loop filter 305 applies a loop filter such as a deblocking filter, SAO (Sample Adaptive Filter), and ALF (Adaptive Loop Filter) to the decoded image to generate a decoded image.

(Scaling list)
The scaling list means a method of performing different quantization / inverse quantization depending on the position of the conversion coefficient, and a matrix used for quantization. Quantization / dequantization is also called scaling, and scaling list is also called scaling list or scaling factor. By using the scaling list, it is possible to make the high frequency component smaller (it tends to be 0) and reduce the coding rate while suppressing the deterioration of the subjective image quality. Further, the image quality can be adjusted by adjusting the ratio of the high frequency component to the low frequency component and the ratio of the horizontal component, the vertical component, and the diagonal component.

The parameter decoding unit 302 includes a scaling list decoding unit 3026.

FIG. 18 shows an example of a scaling list (scaling factor). Here are examples of Scaling Factor [3] [3] [0] [x] [y], x = 0.7, y = 0.7 for the 8x8 conversion coefficient array d [x] [y]. ..

FIG. 19 shows the syntax configuration of the scaling list.

The scaling list decoding unit 3026 decodes the scaling_list_enabled_flag indicating whether or not to use the scaling list from the encoded data. When scaling_list_enabled_flag is 1, the scaling process described later is performed using the scaling list.

The scaling list decoding unit 3026 decodes the scaling list information called scaling_list_data () from the encoded data, and derives the scaling list. Further, the scaling list decoding unit 3026 may use a predetermined matrix (default matrix) that is not decoded from the coded data.

The scaling list decoding unit 3026 decodes the scaling list ScalingList [sizeId] [matrixId] [i] represented by the size identifier sizeId and the matrix identifier matrixId. sizeId = 1,2,3,4,5,6 corresponds to 2x2, 4x4, 8x8, 16x16, 32x32, 64x64, respectively.

As shown in FIG. 12, matrixId = 0,1,2,3,4,5 are the brightness of the intra prediction (cIdx == 0), the Cb of the intra prediction (cIdx == 1), and the Cr of the intra prediction, respectively. It may correspond to cIdx == 2), brightness of inter-prediction (cIdx == 0), Cb of inter-prediction (cIdx == 1), and Cr of inter-prediction (cIdx == 2).

As yet another configuration, as shown in FIG. 13, matrixId = 0,1,2,3,4,5,6,7,8 are the intra-predicted brightness (stIdx =) when the non-separable conversion is off, respectively. = 0, cIdx == 0), Cb for intra-prediction when non-separable conversion is off (stIdx == 0, cIdx == 1), Cr for intra-prediction when non-separable conversion is off (stIdx == 0) , cIdx == 2), Inter-prediction brightness (cIdx == 0), Inter-prediction Cb (cIdx == 1), Inter-prediction Cr (cIdx == 2), Intra-prediction when non-separation conversion is on Brightness (stIdx! = 0, cIdx == 0), intra-prediction color difference Cb (stIdx! = 0, cIdx == 1) when non-separation conversion is on, intra-prediction when non-separation conversion is on It may correspond to the color difference Cr (stIdx! = 0, cIdx == 2). That is, the scaling list of matrixId = 0,1,2,3,4,5 may be used for the coefficients of the core transformation (separation transformation, first transformation, stIdx == 0). The scaling list decoding unit 3026 may further use a scaling list with matrixId = 6, 7, 8 for the coefficients of the non-separable conversion (secondary conversion, second conversion, stIdx! = 0).

Here, (((sizeId == 1) && (matrixId% 3 == 0)) || ((sizeId == 6) && (matrixId% 3! = 0)) of SYN2001 in Fig. 19 is concrete. Represents the following processing.

When matrixId% 3 == 0 (luminance) and sizeId == 1 (2x2), the syntax elements of the scaling list such as scaling_list_pred_mode_flag and scaling_list_delta_coef are not decoded.

When matrixId% 3! = 1 (color difference) and sizeId == 6 (64x64), the syntax elements of the scaling list such as scaling_list_pred_mode_flag and scaling_list_delta_coef are not decoded.

scaling_list_pred_mode_flag is a flag indicating whether the scaling list used in the target block is in the reference scaling list. When scaling_list_pred_mode_flag = 0, it indicates that there is a scaling list to be referred to, and the scaling list decoding unit 3026 decodes the index indicating the desired scaling list. When scaling_list_pred_mode_flag! = 0, it means that there is no scaling list to be referred to, and the scaling list decoding unit 3026 decodes the information of the new scaling list. Set to 0 if scaling_list_pred_mode_flag is not notified.

Figure 20 is another example of a scaling list syntax configuration. In this example, the size of the non-separable transformation using the scaling list is more limited. Specifically, SYN2001A adds the condition "(sizeId == 1 || sizeId> 3) && (matrixId> 5)" to SYN2001. This is the syntax of scaling list for non-separable conversion such as scaling_list_pred_mode_flag, scaling_list_delta_coef when matrixId> 5 (non-separable conversion) and sizeId == 1, 4, 5, 6 (2x2, 16x16, 32x32, 64x64). Indicates that the element is not decrypted.

Figure 21 is another example of a scaling list syntax configuration. In this example, the size of the non-separable transformation using the scaling list is more limited. Specifically, SYN2001B adds the condition "(sizeId! = 2 && sizeId! = 3 && (matrixId> 5)" to SYN2001.

This indicates that the syntax elements of the scaling list for non-separable conversion such as scaling_list_pred_mode_flag and scaling_list_delta_coef are not decoded except for matrixId> 5 (non-separable conversion) and sizeId == 2, 3 (4x4, 8x8).

Note that matrixId> 5 is equivalent to matrixId> = 6.

FIG. 24 shows an example of transmitting a scaling list for separation conversion and a scaling list for non-separation conversion as coded data having different APS. In APS, aps_params_type is used as the coded data to indicate the type of information encoded in APS, and one APS data is aps_params_.
Contains only the information specified by type. For example, aps_params_type may be ALF_APS of ALF data, LMCS_APS of LMCS data, and SCALING_APS of scaling list data.

Further, the scaling list data may be provided with different aps_params_types depending on the scaling list for separation conversion and the scaling list for non-separation conversion. For example, SCALING_APS for separation conversion and LFNST_SCALING_APS for non-separation conversion may be used. As shown in FIG. 24, the scaling list decoding unit decodes the adaptation parameter set (APS), and when aps_params_type of APS indicates a separation conversion scaling list (SCALING_APS), the first scaling for separation conversion is described above. The list scaling_list_data () is decoded, and when the adaptation_paraemeter_set_id indicates a non-separable conversion scaling list (LFNST_SCALING_APS), the second scaling list lfnst_scaling_list_data () for the non-separable conversion is decoded.

As a result, since the first scaling list for separation conversion and the second scaling list for non-separation conversion are transmitted with coded data of different parameter sets, it is possible to transmit and update only one scaling list. It becomes.

Also, as shown in FIG. 14, the scaling list of sizeId = 1,2,3,4,5,6 is decoded, and matrixId = 6 is converted to non-separable conversion without separating Cb and Cr in the non-separable conversion. Luminance (stIdx! = 0, cIdx == 0) and matrixId = 7 may correspond to the color difference of non-separable conversion (stIdx! = 0, cIdx! = 0).

(Decoding the scaling list)
The scaling list decoding unit 3026 decodes the one-dimensional list ScalingList [sizeId] [matrixId] [i] for each position i on the Diagonal Scan for each size sizeId and the type matrixId of the scaling list.

The scaling list decoding unit 3026 decodes the flags scaling_list_pred_mode_flag [sizeId] [matrixId] indicating whether or not to predict from the already decoded scaling list (reference scaling list). When predicting the scaling list (when scaling_list_pred_mode_flag == 0), decode the scaling_list_pred_matrix_id_delta [sizeId] [matrixId] that represents the reference scaling list. In this case, the scaling list decoding unit 3026 derives the refMatrixId from the scaling_list_pred_matrix_id_delta and derives the ScalingList by referring to the existing scaling list referred to by the refMatrixId.

refMatrixId = matrixId --scaling_list_pred_matrix_id_delta [sizeId] [matrixId] *
(sizeId == 6? 3: 1)
ScalingList [sizeId] [matrixId] [i] = ScalingList [sizeId] [refMatrixId] [i] (i = 0..coefNum-1)
Conversely, when decoding a new scaling list (when scaling_list_pred_mode_flag == 1), the coefNum value nextCoef, which is the number of elements in the scaling list, is decoded, and a one-dimensional list for each size sizeId and matrixId ScalingList [sizeId] ] [matrixId] Store in [i].

That is, the scaling list decoding unit 3026 derives nextCoef from the decoded syntax values scaling_list_dc_coef_minus8 [sizeId-4] [matrixId] and scaling_list_delta_coef, and on DiagonalScan in the array d [] [] of sizeId, matrixId, and conversion coefficients. Derivation of ScalingList [sizeId] [matrixId] [i] for each position i.

nextCoef = (nextCoef + scaling_list_delta_coef + 256)% 256 (i = 0..coefNum-1)
ScalingList [sizeId] [matrixId] [i] = nextCoef
coefNum is the number of elements in the scaling list.

The scaling list decoding unit 3026 may further decode the information scaling_list_dc_coef_minus8 [sizeId-4] [matrixId] of the predicted value of the coefficient value nextCoef of the scaling list and derive it as follows.

nextCoef = scaling_list_dc_coef_minus8 [sizeId-4] [matrixId] + 8
The scaling list decoding unit 3026 decodes the first scaling list for separation conversion and the second scaling list for non-separation conversion, and uses the fixed number of elements NumLFNSTCoeff as the second scaling list for each predetermined size sizeId. Decrypt the value of.

The number of fixed elements NumLFNSTCoeff may be 16 as described later. As already explained, the predetermined size sizeId of the scaling matrix for separation and conversion to be coded and decoded is sizeId = 2 (that is, width and height are 4), sizeId = 3 (width and height is 8). It may be.

(Number of elements in the scaling list coefNum)
FIG. 22 is a diagram illustrating a method of decoding a scaling list for non-separable conversion.

The scaling list decoding unit 3026 determines whether the scaling list is for separation conversion or non-separation conversion (S3001), and in the case of separation conversion (for example, matrixId is a predetermined value, matrixId <= 5). , The number of conversion coefficients (1 << sizeId * 2) corresponding to the conversion size sizeId may be set in coefNum (S3003).

coefNum = (1 << (sizeId << 1)) = (1 << (sizeId * 2))
Further, the scaling list decoding unit 3026 may limit the maximum number of coefNums when the conversion size is large to 64.

coefNum = Min (64, (1 << (sizeId << 1)))
Further, when using non-separable conversion (for example, matrixId> 5,), the scaling list decoding unit 3026 sets coefNum to a predetermined number of fixed elements NumLFNSTCoeff (for example, 16) as the number of conversion coefficients used for non-separable conversion. May be (S3002).

coefNum = NumLFNSTCoeff (for matrixId> 5)
In summary, the scaling list decoding unit 3026 sets the coefNum as follows.

coefNum = matrixId> 5? NumLFNSTCoeff: Min (64, (1 << (sizeId << 1)))
If the number of conversion coefficients used for non-separable conversion of 4x4 (sizeId = 4) is 8, the following settings may be used.

coefNum = matrixId> 5? (SizeId == 4)? 8: 16: Min (64, (1 << (sizeId << 1)))
(Derivation of 2D list Scaling Factor)
The scaling list decoding unit 3026 uses the ScalingList [sizeId] [matrixId] [i], and further, the ScalingFactor for each position (x, y) in the array d [x] [y] of the sizeId, matrixId, and conversion coefficients. [sizeId] [sizeId] [matrixId] [x] [y] may be derived. For example, the Scaling Factor when 4x4 (sizeId == 2) and non-separable conversion is not used (matrixId = 0.5) is derived as follows.

ScalingFactor [2] [2] [matrixId] [x] [y] = ScalingList [2] [matrixId] [i]
x = DiagScanOrder [2] [2] [i] [0]
y = DiagScanOrder [2] [2] [i] [1]
On the other hand, the Scaling Factor when 4x4 (sizeId == 2) is used for non-separable conversion (matrixId> 5) is derived as follows.

ScalingFactor [2] [2] [matrixId] [x] [y] = ScalingList [2] [matrixId] [i]
x = DiagScanOrder [2] [2] [i] [0]
y = DiagScanOrder [2] [2] [i] [1]
Where i = 0.15.

The Scaling Factor when 8x8 (sizeId == 3) is not used for non-separable conversion (matrixId = 0.5) is derived as follows.

ScalingFactor [3] [3] [matrixId] [x] [y] = ScalingList [3] [matrixId] [i]
x = DiagScanOrder [3] [3] [i] [0]
y = DiagScanOrder [3] [3] [i] [1]
On the other hand, the Scaling Factor when 8x8 (sizeId == 3) is used for non-separable conversion (matrixId> 5) is derived as follows. Here, 16 below is a coefNum, which may be 8, 12, 24, 32, for example.

ScalingFactor [3] [3] [matrixId] [x] [y] = i <16? ScalingList [3] [matrixId] [i]: 0
x = DiagScanOrder [2] [2] [i] [0]
y = DiagScanOrder [2] [2] [i] [1]
Where i = 0.63.

The scaling list decoding unit displays a one-dimensional ScalingList [log2StSize] [log2StSize] [pos] decoded for each predetermined size log2StSize and a table DiagScanOrder [log2StSize] [log2StSize] [] showing the scanning order for each predetermined size. By referring to and deriving the two-dimensional ScalingFactor [log2StSize] [log2StSize] [x] [y], the second scaling list is decoded, and the scaling list decoding unit has the above pos less than the above fixed number of elements NumLFNSTCoeff. In the case of, set the value of ScalingList [log2StSize] [log2StSize] [pos] to ScalingFactor [log2StSize] [log2StSize] [x] [y], and in other cases, set a predetermined fixed value (for example, 0). Use.

As a result, when converting conversion coefficients less than coefNum by non-separation conversion, a two-dimensional Scaling Factor for each conversion size used by the scaling unit 31111 is derived from the values in the scaling list of coefNum. Therefore, in the scaling unit 31111, the non-separation conversion and the scaling of the separation conversion can be performed by the same processing using the two-dimensional Scaling Factor. There is an effect that the processing is standardized.

DiagScanOrder [sizeId] [sizeId] [i] [j] is an array indicating the scan order (Diagonal order) in a block (array) having a width of 1 << sizeId and a height of 1 << sizeId. DiagScanOrder [sizeId] [sizeId] [i] [0] is the X coordinate when the scan order is i, and DiagScanOrder [sizeId] [sizeId] [i] [1] is Y when the scan order is i. Show the coordinates.

Further, the scaling list decoding unit 3026 derives the scaling list ScalingFactor [wId] [hId] [matrixId] [x] [y] of the conversion coefficient block (TU) other than the square by the following equation. wId and hId indicate the width (1 << wId) and height (1 << hId) of the TU. Here, the Scaling Factor when it is not used for non-separable conversion (matrixId = 0.5) is derived as follows.

k = min (maxSizeId, 3),
x = DiagScanOrder [k] [k] [i] [0]
y = DiagScanOrder [k] [k] [i] [1]
ratioW = (1 << wId) / (1 << k)
ratioH = (1 << hId) / (1 << k)
diffWH = 1 << abs (wId? HId)
if (wId> hId)
ScalingFactor [wId] [hId] [matrixId] [x] [y] =
ScalingList [maxSizeId] [matrixId] [RasterScanOrder [k] [k] [(1 << k) * (y * diffWH) / ratioW) + x / ratioW]]
else (wId <hId)
ScalingFactor [wId] [hId] [matrixId] [x] [y] =
ScalingList [maxSizeId] [matrixId] [RasterScanOrder [k] [k] [(1 << k) * (y / ratioH) + (x * diffWH) / ratioH]]
On the other hand, the Scaling Factor when used for non-separable conversion (matrixId> 5) may be derived as follows.

k = (wId> = 3 &&hId> = 3)? 3: 2 (LFNST-1)
x = DiagScanOrder [k] [k] [i] [0]
y = DiagScanOrder [k] [k] [i] [1]
ScalingFactor [wId] [hId] [matrixId] [x] [y] =
ScalingList [k] [matrixId] [Raster2DiagScanPos [k] [k] [(4 * y + x)]]
Raster2DiagScanPos [k] [k] [pos] is an array for deriving the Diagonal order from the position pos in the raster scan order of k * k size blocks.
Here, wId = 0..6, hId = 0..6, x = 0 .. (1 << wId) -1, y = 0 .. (1 << hId) -1. Note that (wId, hId) = (0, 0) is not used.

Further, the parameter decoding unit 302 includes an inter-prediction parameter decoding unit 303 and an intra-prediction parameter decoding unit 304 (not shown). The prediction image generation unit 308 includes an inter-prediction image generation unit 309 and an intra-prediction image generation unit 310 (not shown).

Further, as shown in FIG. 25, the parameter decoding unit 302 may include a scaling list decoding unit 3026 and a non-separable conversion scaling list decoding unit 3027. The non-separable conversion scaling list decoding unit 3027 decodes the non-separable conversion scaling list information lfnst_scaling_list_data () from the encoded data, and derives the non-separable conversion scaling list. Further, the scaling list decoding unit 3026 may decode the scaling list information for non-separable conversion when the scaling_list_enabled_flag is 1 and the sps_lfnst_enabled_flag indicating whether or not to apply the non-separable conversion at the SPS level is 1. Further, the scaling list decoding unit 3027 for non-separation conversion may use a predetermined matrix (default matrix) that is not decoded from the coded data.

(Scaling section 31111)
The scaling unit 31111 uses the quantization conversion coefficient qd [] [] input from the entropy decoding unit 301.
] Is scaled using the weight of the coefficient unit.

As shown in FIG. 12, the scaling unit 31111 may use the scaling factor regardless of the presence or absence of the non-separable conversion. In this case as well, as will be described later, it is appropriate to transpose the scaling factor (or the intermediate array for obtaining the scaling factor) according to the intra mode.

Further, in the scaling unit 31111, when stIdx == 0 which does not perform non-separable conversion, the conversion coefficient corresponds to the spatial frequency, whereas when stIdx! = 0 which performs non-separable conversion, the conversion coefficient becomes the spatial frequency. Does not correspond, so different scaling factors may be used depending on the presence or absence of non-separable conversion. Below, the scaling factor (mat) of the core conversion decoded by the scaling list decoding unit 3026.
An example of scaling according to the presence or absence of non-separable conversion using rixId == 0,1,2,3,4,5) and the scaling factor of non-separable conversion (matrixId == 6,7,8) explain. Further, the value of matrixId is not limited to the above, and for example, a scaling list of matrixId == 6,7,8,9,10,11 may be used for the non-separable conversion.

That is, the scaling unit derives a scale factor using the first scaling list when the scaling list is valid and the non-separable conversion is not valid. Further, when the scaling list is valid and the non-separable conversion is valid, the scale factor using the second scaling list is derived. It also derives a fixed scale factor when the scaling list is not valid. Then, scaling may be performed on the conversion coefficient using the above scale factor.

(Explanation of scaling by scaling list decoding unit 3026 and scaling unit 31111)
The scaling unit 31111 in the present embodiment switches between the scaling factor used when the inverse non-separation conversion is applied and the scaling factor used when the inverse non-separation conversion is not applied, and scales the quantization conversion coefficient. Specifically, the scaling unit 31111 performs scaling using the scaling factor input from the scaling list decoding unit 3026. The scaling list decoding unit 3026 derives the scaling factor corresponding to the non-separable conversion when the inverse non-separable conversion is applied, and derives the scaling list corresponding to the core transformation when the inverse non-separable conversion is not applied. Derived. As a result, it is possible to appropriately scale for conversion coefficients having different properties that occur depending on the presence or absence of non-separable conversion. As a result, the inverse non-separation conversion can be preferably applied.

<Structure example of inverse quantization / inverse conversion unit 311>
FIG. 10 is a block diagram showing the configuration of the inverse quantization / inverse conversion unit 311 of the present embodiment. The inverse quantization / inverse conversion unit 311 is composed of a scaling unit 31111, an inverse secondary conversion unit 31121, and an inverse core conversion unit 31123.

FIG. 11 is a block diagram showing another configuration of the inverse quantization / inverse conversion unit 311 of the present embodiment. The inverse quantization / inverse conversion unit 311 is composed of a scaling unit 31111, an inverse secondary conversion unit 31121, an inverse core conversion unit 31123, and a joint error derivation unit 3113. This is a configuration in which the joint error derivation unit 3113 is added to FIG.

The inverse quantization / inverse conversion unit 311 scales (inversely quantizes) the quantization conversion coefficient qd [] [] input from the entropy decoding unit 301 by the scaling unit 31111 to obtain the conversion coefficient d [] []. This quantization transform coefficient qd [] [] is quantized by transforming the prediction error with DCT (Discrete Cosine Transform), DST (Discrete Sine Transform), etc. in the coding process. It is a coefficient obtained by the above-mentioned, or a conversion coefficient after conversion is further converted by a secondary transformation. When stIdx! = 0, the inverse quantization / inverse conversion unit 311 performs conversion by the inverse secondary conversion unit 31121. Further, the converted conversion coefficient is subjected to inverse frequency conversion such as inverse DCT and inverse DST, and the prediction error is calculated. When stIdx == 0, the inverse secondary conversion unit 31121 is not performed, and the conversion coefficient scaled by the scaling unit 31111 is subjected to inverse frequency conversion such as inverse DCT and inverse DST to calculate the prediction error. The inverse quantization / inverse conversion unit 311 outputs the prediction error to the addition unit 312.

Since the inverse transformation and the transformation are paired processes, the transformation and the inverse transformation may be interpreted by replacing each other. Alternatively, when the inverse transformation is called a transformation, the transformation may be called a forward transformation. For example, when the inverse secondary conversion is called a secondary conversion, the secondary conversion may be called a forward secondary conversion. Also, core conversion is simply called conversion.

(Details of scaling unit 31111)
In the scaling unit 31111 in the present embodiment, the scaling factor when the inverse secondary transformation is applied will be described in detail.

The scaling unit 31111 may perform scaling by using a scaling factor for non-separation conversion (second scaling factor) input from the scaling list decoding unit 3026, which differs depending on the size of the transformation matrix of the inverse separation conversion. The second scaling factor is, for example, (LFNST-1) Scaling Factor [] [] [matrixId] [x] [y] (matrixId> 5).

Of the second scaling factor, the scaling unit 31111 may switch the scaling factor according to the intra prediction mode to perform scaling.

The scaling unit 31111 uses the quantization parameter and the scaling factor derived in the parameter decoding unit 302 to scale the conversion coefficient decoded by the TU decoding unit using the weight in coefficient units.

Here, the quantization parameter qP is derived below using the color component cIdx of the target conversion coefficient and the joint color difference residual coding flag tu_joint_cbcr_flag.

qP = qPY (cIdx == 0)
qP = qPCb (cIdx == 1 && tu_joint_cbcr_flag == 0)
qP = qPCr (cIdx == 2 && tu_joint_cbcr_flag == 0)
qP = qPCbCr (tu_joint_cbcr_flag! = 0)
The scaling unit 31111 derives the value rectNonTsFlag related to the shape from the size (nTbW, nTbH) of the target TU.

rectNonTsFlag = ((((Log2 (nTbW) + Log2 (nTbH)) & 1) == 1 && transform_skip_flag [xTbY] [yTbY] == 0)
rectNonTsFlag is 1 when it is not a square and it is not a conversion skip.

The scaling unit 31111 performs the following processing using the Scaling Factor [] [] derived in the scaling list decoding unit 3026.

The scaling unit 31111 sets m [x] [y] = 16 when scaling_list_enabled_flag is 0 or when transformation skip is enabled (transform_skip_flag == 1). That is, uniform quantization is performed.

Otherwise, when applying the inverse secondary conversion (non-separable conversion) (stIdx! = 0), the scaling unit 31111 uses the scaling list of the non-separable conversion. Here, m [] [] is set as follows.

log2StSize = (nTbW> = 8 &&nTbH> = 8)? 3: 2
m [x] [y] = ScalingFactor [log2StSize] [log2StSize] [matrixId] [x] [y]
When the inverse secondary conversion (non-separable conversion) is applied (stIdx! = 0 and nTbW> = 4 and nTbH> = 4), the scaling unit 31111 may use the scaling list of the non-separable conversion.

log2StSize = (nTbW> = 8 &&nTbH> = 8)? 3: 2
m [x] [y] = ScalingFactor [log2StSize] [log2StSize] [matrixId] [x] [y]
In order to prevent the values of x> = 4 and y> = 4 from becoming indefinite, set fixed values (for example, 0 or 16) when x <4 && y <4 other than x <4 && y <4 as shown below. Is also good.

m [x] [y] = (x <4 && y <4)? ScalingFactor [log2StSize] [log2StSize] [matrixId] [x] [y]
: 0:
In other cases (that is, when scaling_list_enabled_flag == 1 and transform_skip_flag == 0), the scaling unit 31111 uses the scaling list. Here, m [] [] is set as follows.

m [x] [y] = ScalingFactor [Log2 (nTbW)] [Log2 (nTbH)] [matrixId] [x] [y]
Here, matrixId is set by the prediction mode (CuPredMode) of the target TU, the color component index (cIdx), and whether or not the secondary conversion is applied (stIdx).

When deriving the scaling factor m [] [] of the non-separable conversion, the scaling unit 31111 derives the logarithmic log2StSize of the size of the separation conversion from the nTbW and nTbH of the conversion block, and the Scaling Factor specified by the log2StSize. Use [log2StSize] [log2StSize] [matrixId] [x] [y].

In this way, the scaling unit 31111 can perform the scaling of the non-separation conversion and the separation conversion by the same processing using the two-dimensional Scaling Factor, so that there is an effect that the processing is standardized.

(Modification example)
Another configuration of the scaling unit 31111 may derive m [] [] directly from the ScalingList in one-dimensional scan order (for example, Diagonal order). In this case, when applying the inverse secondary transformation (stIdx! = 0), the scaling unit 31111 uses the scaling list of the non-separable transformation. Here, m [] [] may be set as follows.

log2StSize = (nTbW> = 8 &&nTbH> = 8)? 3: 2
m [x] [y] = ScalingList [log2StSize] [Raster2DiagScanPos [2] [2] [x + y * 4]]
When the inverse secondary conversion (non-separable conversion) is applied (stIdx! = 0 and nTbW> = 4 and nTbH> = 4), the scaling unit 31111 may use the scaling list of the non-separable conversion.

log2StSize = (nTbW> = 8 &&nTbH> = 8)? 3: 2
m [x] [y] = ScalingList [log2StSize] [Raster2DiagScanPos [2] [2] [x + y * 4]]
In order to prevent the values of x> = 4 and y> = 4 from becoming indefinite, set fixed values (for example, 0 or 16) when x <4 && y <4 other than x <4 && y <4 as shown below. Is also good.

m [x] [y] = (x <4 && y <4)? ScalingList [log2StSize] [Raster2DiagScanPos [2] [2] [x + y * 4]]: 0
Only 16 components (NumLFNST Coeff) are used in the low frequency non-separable conversion (LFNST). Here, the components of NumLFNST Coeff in the Scaling List are used as they are.
Another configuration of the scaling unit 31111 is to derive the logarithmic log2StSize of the size of the separation conversion from the conversion blocks nTbW and nTbH when deriving the scaling factor m [] [] of the non-separation conversion. Scan order from raster scan for a given size (here, logarithmic 2) One-dimensional ScalingList [log2StSize] [Raster2DiagScanPos [2] [2] [x + y * 4] specified by Raster2DiagScanPos [2] [2] ] To derive the scaling factor.

Also, for the region where the position (x, y) of the conversion block is low frequency (for example, x <4, y <4), the non-separable conversion ScalingList [log2StSize] [Raster2DiagScanPos [2] decoded from the above coded data. ] [2] The value of [x + y * 4] may be used, and other than that, a predetermined fixed value may be used.

Here, the ScalingList can be directly referenced without deriving the 2D list ScalingFactor [] [] [x] [y] from the 1D list ScalingList [] [] [pos], so it is for non-separable conversion. The process of deriving the Scaling Factor and the memory of the Scaling Factor for non-separable conversion can be omitted.

FIG. 12 is a diagram showing a method of deriving matrixId from CuPredMode and cIdx.

FIG. 13 is a diagram showing a method of deriving matrixId from CuPredMode, cIdx, and stIdx. Specifically, when stIdx == 0, matrixId = 0, 1, 2, 3, 4, 5 is used, and when stIdx! = 0, matrixId = 6, 7, 8 is used. If stIdx == 0, then CuPredMode is an intra-prediction or matrixId is set according to the color component. When stIdx! = 0, since it is an intra prediction mode, set matrixId according to the color component.

FIG. 14 is another example of a diagram showing how to derive matrixId from CuPredMode, cIdx, stIdx. When stIdx! = 0 and cIdx! = 0, the second and third color components are not distinguished.

FIG. 15 is another example of a diagram showing how to derive matrixId from CuPredMode, cIdx, stIdx. In this case, if stIdx == 1, set matrixId = 6, 7, 8, and if stIdx == 2, set matrixId = 9, 10, 11. In this way, the scaling factor is changed according to the transformation matrix type stIdx of the secondary transformation.

The scaling unit 31111 multiplies the derived scaling factor by the array levelScale of the conversion coefficients. For example
ls [x] [y] = (m [x] [y] * levelScale [rectNonTsFlag] [qP% 6]) << (qP / 6)
The scaling unit 31111 derives the scaling factor ls [x] [y] by the following equation.

ls [x] [y] = (m [x] [y] * levelScale [rectNonTsFlag] [(qP + 1)% 6]) << ((qP + 1) / 6)
Alternatively, it may be derived by the following formula.

ls [x] [y] = (m [x] [y] * levelScale [rectNonTsFlag] [qP% 6]) << (qP / 6)
Where levelScale [] = {{40, 45, 51, 57, 64, 72}, {57, 64, 72, 80, 90, 102}}.

The scaling unit 31111 derives dnc [] [] from the product of the scaling factor ls [] [] and the decoded conversion coefficient TransCoeffLevel, and performs inverse quantization.

dnc [x] [y] = (TransCoeffLevel [xTbY] [yTbY] [cIdx] [x] [y] * ls [x] [y] + bdOffset) >> bdShift
Finally, the scaling unit 31111 clips the inverse quantized conversion coefficient and derives d [x] [y].

d [x] [y] = Clip3 (CoeffMin, CoeffMax, dnc [x] [y])
d [x] [y] is transmitted to the reverse core conversion unit 31123 or the reverse secondary conversion unit 31121. The secondary conversion unit (second conversion unit) 31121 applies the secondary conversion to the conversion coefficient d [] [] after the inverse quantization and before the core conversion.

The inverse secondary conversion unit 31121 applies a conversion using a transformation matrix to a part or all of the conversion coefficients d [] [] received from the scaling unit 31111, thereby causing a correction conversion coefficient (conversion by the secondary conversion unit). Later conversion factor) Restores d [] []. Inverse secondary converter 311
21 applies the inverse secondary conversion to the conversion coefficient d [] [] of a predetermined unit for each conversion unit TU. The secondary transformation is applied only in the intra CU, and the transformation basis is determined with reference to the intrapred mode IntraPredMode. The selection of the conversion basis will be described later. The inverse secondary conversion unit 31121 outputs the restored modified conversion coefficient d [] [] to the inverse core conversion unit 31123.

The core conversion unit 31123 acquires the conversion coefficient d [] [] or the correction conversion coefficient d [] [] restored by the inverse secondary conversion unit 31121, performs conversion, and derives the prediction error r [] []. .. Then, the r [] [] is scaled according to the bit depth, and the error resSamples [] [] with the same accuracy as the predicted image derived by the predicted image generation unit 308 is derived. For example, scaling is expressed as:

resSamples [x] [y] = (r [x] [y] + (1 << (bdShift -1))) >> bdShift (expression BD-1)
bdShift = Max (20 --bitDepth, 0)
In this operation, resSamples [] [] with bitDepth accuracy is obtained from r [] [] with 20-bit accuracy by shift operation. The value indicating the accuracy is not limited to 20, and other values between 8 and 24 may be used (the same shall apply hereinafter). Scaling according to bitDepth may be performed by providing a bit depth scale unit (not shown). The derived error is output to the addition unit 312.

The joint error derivation unit 3113 derives the prediction error resSamples [] [] of the second color component (for example, cIdx = cIdx1) by using the prediction error r [] [] of the first color component (cIdx = cIdx0). To do. Color components can be identified by cIdx, for example, cIdx = 0 indicates luminance, cIdx = 1 indicates color difference Cb, and cIdx = 2 indicates color difference Cr. Since the joint error derivation unit 3113 does not perform luminance processing, cIdx0 and cIdx1 are 1 or 2 (the same applies hereinafter). resSamples [] [] with cIdx == 1 is written as resSamplesCb [] [] or resCb [] []. resSamples [] [] of cIdx == 2 is written as resSamplesCr [] [] or resCr [] []. Further, the joint error derivation unit 3113 uses the addition and difference of the prediction error r [] [] of the two color components (cIdx = cIdx0, cIdx = cIdx1) to use the two color components (cIdx = cIdx0, cIdx = cIdx1). ) ResSamples [] [] may be derived. Further, the joint error derivation unit 3113 uses the prediction error r [] [] of the first color component (cIdx = cIdx0) by the shift operation depending on the bitDepth of the image as described later, and uses the second color component. You may derive resSamples [] [] of (for example, cIdx = cIdx1). The variables cIdx0 and cIdx1 indicating a specific color component may be 1, 2 (Cr is derived from Cb) or 2, 1 (Cb is derived from Cr). Also, when cIdx0 = 1, the relationship of cIdx1 = 2 is satisfied, and when cIdx0 = 2, the relationship of cIdx1 = 1 is satisfied. That is, the relationship of cIdx1 = 3-cIdx0 is satisfied.

(Explanation of secondary conversion and inverse secondary conversion)
The secondary conversion (second conversion, non-separable conversion) is applied to the conversion coefficient of a part or all of the TU after the core conversion (DCT2, DST7, etc.) in the moving image coding apparatus 11. In the secondary conversion, the correlation remaining in the conversion coefficient is removed and the energy is concentrated on some conversion coefficients. The inverse secondary conversion is applied to the conversion coefficient of a part or all of the TU in the moving image decoding device 31. After the inverse secondary conversion is applied, the inverse core conversion (DCT2, DST7, etc.) is applied to the conversion coefficient after the inverse secondary conversion. Further, when the TU is divided into 4x4 sub-blocks, the secondary conversion and the inverse secondary conversion are applied only to the predetermined sub-block on the upper left. Of the width W and height H of the TU, the size of the TU whose one is 4 is, for example, 4 × 4, 8 × 4, 4 × 8, L × 4 and 4 × L (L is a natural number of 16 or more). Can be mentioned.

Further, a technique of transmitting only a part of low frequency components in the conversion coefficient after separation transformation (secondary transformation) is called RST (Reduced Secondary Transform) transformation or LFNST (Low Frequency Non-Separable-Transform). Specifically, if the number of conversion coefficients of the separation conversion to be transmitted, nonZeroSize, is less than or equal to the size of the separation conversion (1 << log2StSize) * (1 << log2StSize), it becomes LFNST.

In the secondary conversion and the inverse secondary conversion, the following processing is performed according to the size of the TU and the intrapred mode. Hereinafter, the processing of the inverse secondary conversion will be described in order.

FIG. 23 is a diagram illustrating the secondary conversion. In the figure, for the 8x8 TU, the conversion coefficient d [] [] in the 4x4 region is stored in the nonZeroSize one-dimensional array u [] in the S2 processing, and the one-dimensional array u [] to the one-dimensional array in the S3 processing. The process of converting to v [] and finally storing it in d [] [] in the process of S4 is shown.

(S1: Setting of conversion size and input / output size)
In inverse secondary conversion, depending on the size of the TU (width W, height H), the size of the inverse secondary conversion (4x4 or 8x8), the number of output conversion factors (nStOutSize), and the conversion factor to be applied (input conversion factor). ) Number nonZeroSize and the number of subblocks (numStX, numStY) to which the inverse secondary transformation is applied are derived. The size of the inverse secondary conversion of 4x4 and 8x8 is indicated by nStSize = 4 and 8. Further, the sizes of the inverse secondary conversions of 4x4 and 8x8 may be referred to as RST4x4 and RST8x8, respectively.

In the inverse secondary conversion, when the TU is larger than a predetermined size, 48 conversion coefficients are output by the inverse secondary conversion of RST8x8. Otherwise, RST4x4 inverse secondary conversion outputs 16 conversion coefficients. When the TU is 4x4, 16 conversion coefficients are derived from the conversion coefficient of 8 using RST4x4, and when the TU is 8x8, the conversion coefficient of 48 is derived from the conversion coefficient of 8 using RST8x8. In other cases, 16 or 48 conversion coefficients are output from 16 conversion coefficients depending on the size of the TU.

If both W and H are 8 or more, log2StSize = 3, nStOutSize = 48
Other than the above, log2StSize = 2, nStOutSize = 16
nStSize = 1 << log2StSize
If both W and H are 4, or 8x8, nonZeroSize = 8
Other than the above, nonZeroSize = 16
The input nonZeroSize of LFNST is not limited to 8 and 16. For example, it may be 12. The output nStOutSize is not limited to 16 and 48, but may be 32, 36, 64, etc.

numStX = (nTbH == 4 &&nTbW> 8)? 2: 1
numStY = (nTbW == 4 &&nTbH> 8)? 2: 1
Note that numStX = numStY may always be set without performing secondary conversion on multiple subblocks.

(S2: Sorted into one-dimensional signal)
The inverse secondary conversion unit 31121 once rearranges a part of the conversion coefficients d [] [] of the TU into the one-dimensional array u [] and processes them. Specifically, the inverse secondary conversion unit 31121 has x = 0..nonZeroSize-1 from the two-dimensional conversion coefficient d [] [] of the target TU indicated by the region RU, which is the rectangular block of the dotted line in FIG. Derivation of u [] with reference to the conversion factor. xC and yC are positions on the TU, and are derived from the array DiagScanOrder indicating the scan order and the position x of the conversion coefficient in the subblock.

xC = (xSbIdx << log2StSize) + DiagScanOrder [log2StSize] [log2StSize] [x] [0]
yC = (ySbIdx << log2StSize) + DiagScanOrder [log2StSize] [log2StSize] [x] [1]
u [x] = d [xC] [yC]
The range copied to the one-dimensional array is called the area RU.

(S3: Application of conversion processing)
The inverse secondary conversion unit 31121 converts u [] (vector F') having a length of nonZeroSize using the transformation matrix secTransMatrix [] [], and outputs a coefficient of a one-dimensional array having a length of nStOutSize. Derivation of v'[] (vector V').

Specifically, the inverse secondary conversion unit 31121 includes a set number (stTrSetId) of the secondary conversion derived from the intraprediction mode IntraPredMode, stIdx indicating the conversion basis of the secondary conversion decoded from the coded data, and a secondary conversion size. Derivation of the corresponding conversion matrix secTranMatrix [] [] from nStSize (nTrS). Further, the inverse secondary conversion unit 31121 performs a multiply-accumulate operation between the conversion matrix and the one-dimensional variable u [], as shown in the following equation.

v [i] = Clip3 (CoeffMin, CoeffMax, Σ (secTransMatrix [i] [j] * u [j] +64) >> 7)
Here, Σ is the sum up to j = 0..nonZeroSize-1. Also, i processes 0..nStSize-1. CoeffMin and CoeffMax indicate the range of conversion coefficient values.

(S4: Two-dimensional arrangement of one-dimensional signal after conversion processing)
The inverse secondary conversion unit 31121 repositions the coefficient v'[] of the converted one-dimensional array at a predetermined position in the TU. The arrangement method may be changed according to PredModeIntra.

Specifically, in the case of "PredModeIntra <= 34 or INTRA_LT_CCLM, INTRA_T_CCLM, or INTRA_L_CCLM", the following processing may be applied in the inverse secondary conversion.

d [x] [y] =
(y <4)? v [x + (y << log2StSize)]: ((x <4)? v [32 + x + ((y-4) << 2)]: d [x] [y])
Otherwise, the following equation is applied in the inverse secondary conversion.

d [x] [y] =
(x <4)? v [y + (x << log2StSize)]: ((y <4)? v [32 + y + ((x-4) << 2)]: d [x] [y])
Further, the above-mentioned branch determination may be "PredModeIntra <= 34" or the like.

(Reverse core converter 31123)
The inverse core conversion unit 31123 applies the inverse core conversion to the coefficient (conversion coefficient) after conversion by the inverse secondary conversion unit 31121. In the inverse core conversion unit 31123, the conversion coefficient converted by the inverse secondary conversion unit 31121 may apply the inverse core conversion to the coefficient (conversion coefficient) after scaling by the scaling unit 31111. The inverse core conversion unit 31123 is a means for performing two one-dimensional conversions in the vertical direction and the horizontal direction, and is usually called a conversion unit. The inverse core conversion unit 31123 may include a case where one or both of the vertical direction and the horizontal direction are skipped and only the magnitude conversion (scaling) of the conversion coefficient is performed.

The inverse core conversion unit 31123 converts the modified conversion coefficient d [] [] (for example, the conversion coefficient after the inverse secondary conversion) into the intermediate value e [] [] by the vertical one-dimensional conversion, and the intermediate value e [] [ ] To clip. The inverse core conversion unit 31123 converts the intermediate value g [] [] into the predicted residual r [] [], and the predicted residual r [] [] is sent to the adding unit 312.

More specifically, the inverse core conversion unit 31123 derives the first intermediate value e [x] [y] by the following equation.

e [x] [y] = Σ (transMatrix [y] [j] × d [x] [j]) (j = 0..nTbS -1)
Here, transMatrix [] [] (= transMatrixV [] []) is a conversion basis represented by a matrix of nTbS * nTbS derived using trTypeVer. nTbS is the height of TU nTbH. In the case of DCT2 4x4 conversion (nTbS = 4) with trType == 0, for example transMatrix = {{29, 55, 74, 84} {74, 74, 0, -74} {84, -29, -74 , 55} {55, -84, 74, -29}}. The symbol of Σ means the process of adding the product of the matrix transMatrix [y] [j] and the conversion coefficient d [x] [j] for the subscript j up to j = 0 .. nTbS-1. That is, e [x] [y] is a vector x [j] consisting of d [x] [j] (j = 0..nTbS-1), which is each column of d [x] [y]. It is obtained by arranging the columns obtained from the product of (j = 0 .. nTbS-1) and the matrix elements transMatrix [y] [j].

The inverse core conversion unit 31123 clips the first intermediate value e [x] [y] and derives the second intermediate value g [x] [y] by the following equation.

g [x] [y] = Clip3 (coeffMin, coeffMax, (e [x] [y] + 64) >> 7)
The above equations 64 and 7 are numerical values determined by the bit depth of the conversion basis, and the above equation assumes that the conversion basis is 7 bits. Also, coeffMin and coeffMax are the minimum and maximum values of clipping.

The inverse core conversion unit 31123 is a conversion basis transMatrix [] [] (= transMatrixH [] []) represented by a matrix of nTbS * nTbS derived using trTypeHor. nTbS is the height of TU nTbH. The horizontal conversion unit 152123 converts the intermediate value g [x] [y] into the predicted residual r [x] [y] by the horizontal one-dimensional conversion.

r [x] [y] = ΣtransMatrix [x] [j] × g [j] [y] (j = 0..nTbS-1)
The above symbol Σ means the process of adding the product of the matrices transMatrix [x] [j] and g [j] [y] for the subscript j up to j = 0 .. nTbS-1. That is, r [x] [y] is obtained from the product of each row of g [x] [y], g [j] [y] (j = 0..nTbS-1), and the matrix transMatrix. Obtained side by side.

The addition unit 312 adds the prediction image of the block input from the prediction image generation unit 308 and the prediction error input from the inverse quantization / inverse conversion unit 311 for each pixel to generate a decoded image of the block. The addition unit 312 stores the decoded image of the block in the reference picture memory 306, and outputs the decoded image to the loop filter 305.

(Configuration of moving image coding device)
Next, the configuration of the moving image coding device 11 according to the present embodiment will be described. FIG. 16 is a block diagram showing the configuration of the moving image coding device 11 according to the present embodiment. The moving image coding device 11 includes a prediction image generation unit 101, a subtraction unit 102, a conversion / quantization unit 103, an inverse quantization / inverse conversion unit 105, an addition unit 106, a loop filter 107, and a prediction parameter memory (prediction parameter storage unit). , Frame memory) 108, reference picture memory (reference image storage unit, frame memory) 109, coding parameter determination unit 110, parameter coding unit 111, and entropy coding unit 104.

The prediction image generation unit 101 generates a prediction image for each CU, which is a region in which each picture of the image T is divided. The prediction image generation unit 101 has the same operation as the prediction image generation unit 308 described above, and the description thereof will be omitted.

The subtraction unit 102 subtracts the pixel value of the predicted image of the block input from the prediction image generation unit 101 from the pixel value of the image T to generate a prediction error. The subtraction unit 102 outputs the prediction error to the conversion / quantization unit 103.

The conversion / quantization unit 103 calculates the conversion coefficient by frequency conversion with respect to the prediction error input from the subtraction unit 102, and derives the quantization conversion coefficient by quantization. The conversion / quantization unit 103 outputs the quantization conversion coefficient to the entropy coding unit 104 and the inverse quantization / inverse conversion unit 105.

The conversion / quantization unit 103 includes a core conversion unit (first conversion unit, not shown), a second scaling unit (not shown), and a secondary conversion unit (second conversion unit, not shown). ing.

The core conversion unit applies the core conversion to the prediction error. The second scaling unit performs scaling by the scaling list with respect to the conversion coefficient (core conversion coefficient) after conversion by the core conversion unit. The secondary conversion unit applies the secondary conversion to the core conversion coefficient after scaling. As a result, each weight in the scaling list corresponds to the core conversion coefficient value, so that the scaling can be performed appropriately. As a result, the secondary conversion can be preferably applied.

In the (forward) secondary conversion applied in the moving image coding device 11, the processing S1-S4 of the inverse secondary conversion applied to the moving image decoding device 31 is applied in the reverse order of processing S1, S4, S3, S2. Performs almost the same processing.

In process S1, the secondary conversion unit performs the same processing as the inverse secondary conversion unit 31121 except that the input and output of the secondary conversion have lengths nStOutSize and nonZeroSize, respectively.

In process S4, the secondary conversion unit derives the coefficient v [] of the one-dimensional array of nStOutSize (or nStSize * nStSize) from the conversion coefficient d [] [] at a predetermined position in the TU.

In the process S3, the secondary conversion unit performs the following conversion from the coefficient v [] (vector V) of the one-dimensional array of nStOutSize and the conversion basis T [] [], and the one-dimensional coefficient u [] (vector F) of nonZeroSize. To get.

u [i] = Clip3 (CoeffMin, CoeffMax, Σ (secTransMatrix [j] [i] * v [j] +64) >> 7)
Here, in the secondary conversion, a matrix obtained by transposing the matrix secTransMatrix [] [] used in the inverse secondary conversion is used. In the above, by changing the subscripts [i] [j] to [j] [i], the transpose is performed using the same matrix.

In the process S2, the secondary conversion unit rearranges the one-dimensional coefficient u [] of nonZeroSize into a two-dimensional array to derive the conversion coefficient d [] [].

xC = (xSbIdx << log2StSize) + DiagScanOrder [log2StSize] [log2StSize] [x] [0]
yC = (ySbIdx << log2StSize) + DiagScanOrder [log2StSize] [log2StSize] [x] [1]
d [xC] [yC] = u [x]
An image coding device that converts the conversion coefficient for each conversion unit, the first scaling list for separation conversion, the scaling list coding unit that encodes the second scaling list for non-separation conversion, and the rest. A first conversion unit (separation conversion unit) that converts the difference and derives the conversion coefficient, and a second conversion unit (non-separation conversion unit) that converts the conversion coefficient output from the first conversion unit are provided for conversion. A scaling unit for scaling the coefficient is provided, and the scaling list coding unit encodes a value of a fixed number of elements as the second scaling list for each predetermined size. Here, the value of the number of fixed elements may be 16. Further, the predetermined sizes may be 4 and 8.

A scaling list encoding unit for encoding a first scaling list for separation conversion and a second scaling list for non-separation conversion is provided, and the scaling unit is valid for the scaling list and effective for non-separation conversion. If not, a scale factor using the first scaling list is derived. Further, when the scaling list is valid and the non-separable conversion is valid, the scale factor using the second scaling list is derived. It also derives a fixed scale factor when the scaling list is not valid. Then, scaling is performed on the conversion coefficient using the above scale factor.

Further, the scaling list encoding unit encodes the adaptation parameter set (APS), and when adaptation_paraemeter_set_id of APS indicates a scaling list for separation conversion, the first scaling list for separation conversion is encoded, and the above When adaptation_paraemeter_set_id indicates a scaling list for non-separable conversion, the second scaling list for non-separable conversion is encoded.

Further, the scaling list encoding unit includes a one-dimensional ScalingList [log2StSize] [log2StSize] [pos] encoded for each predetermined size log2StSize, and a table DiagScanOrder [log2StSize] [log2StSize] indicating the scanning order for each predetermined size. ] [] Is used to encode the second scaling list by deriving the two-dimensional ScalingFactor [log2StSize] [log2StSize] [x] [y].

In addition, when the pos is less than the fixed number of elements, the scaling list encoding unit changes the value of the ScalingList [log2StSize] [log2StSize] [pos] to the ScalingFactor [log2StSize] [log2StSize] [x] [y]. Set, otherwise use a predetermined fixed value.

In addition, when deriving the scaling factor of the non-separation conversion, the scaling unit derives the logarithmic log2StSize of the size of the separation conversion from the size of the conversion block, and the Scaling Factor [log2StSize] [log2StSize] [ Derivation of the scaling factor using matrixId] [x] [y].

Further, when deriving the scaling factor of the non-separable conversion, the scaling unit derives the logarithmic log2StSize of the size of the separation conversion from the size of the conversion block, and the scan order from the raster scan for the log2StSize and the predetermined size. The scaling factor is derived using the above one-dimensional ScalingList [log2StSize] [Raster2DiagScanPos [2] [2] [x + y * 4] specified by Raster2DiagScanPos [2] [2].

In addition, the scaling unit is a non-separable conversion ScalingList [log2StSize] [Raster2DiagScanPos [2] [2] for a region where the conversion block position (x, y) has a low frequency (for example, x <4, y <4). 2] Use the value of [x + y * 4], otherwise set it to a predetermined fixed value.

The inverse quantization / inverse conversion unit 105 is the same as the inverse quantization / inverse conversion unit 311 (FIGS. 10 and 11) in the moving image decoding apparatus 31, and the description thereof will be omitted. The calculated prediction error is output to the addition unit 106.

A quantization conversion coefficient is input to the entropy coding unit 104 from the conversion / quantization unit 103, and a coding parameter is input from the parameter coding unit 111. The coding parameter is, for example, predMode.

The entropy coding unit 104 entropy-codes the division information, prediction parameters, quantization conversion coefficient, and the like to generate a coded stream Te, and outputs the coded stream Te.

The parameter coding unit 111 includes a header coding unit 1110 (not shown), a CT information coding unit 1111, a CU coding unit 1112 (prediction mode coding unit), an inter prediction parameter coding unit 112, and an intra prediction parameter coding unit. It has 113. The CU coding unit 1112 further includes a TU coding unit 1114.

The outline operation of each module will be described below. The parameter coding unit 111 performs parameter coding processing such as header information, division information, prediction information, and quantization conversion coefficient.

The CT information coding unit 1111 encodes QT, MT (BT, TT) division information and the like from the coded data.

The CU coding unit 1112 encodes CU information, prediction information, a TU division flag, a CU residual flag, and the like.

The TU coding unit 1114 encodes the QP update information (quantization correction value) and the quantization prediction error (residual_coding) when the TU includes a prediction error.

The CT information coding unit 1111 and the CU coding unit 1112 supply the entropy coding unit 104 with syntax elements such as an inter prediction parameter, an intra prediction parameter (intra_luma_mpm_flag, intra_luma_mpm_idx, intra_luma_mpm_remainder), and a quantization conversion coefficient.

(Structure of Intra Prediction Parameter Coding Unit 113)
The intra prediction parameter coding unit 113 derives a format for coding (for example, intra_luma_mpm_idx, intra_luma_mpm_remainder, etc.) from the IntraPredMode input from the coding parameter determination unit 110. The intra prediction parameter coding unit 113 includes a configuration that is partially the same as the configuration in which the intra prediction parameter decoding unit 304 derives the intra prediction parameter.

FIG. 17 is a schematic diagram showing the configuration of the intra-prediction parameter coding unit 113 of the parameter coding unit 111. The intra prediction parameter coding unit 113 includes a parameter coding control unit 1131, a luminance intra prediction parameter derivation unit 1132, and a color difference intra prediction parameter derivation unit 1133.

IntraPredModeY and IntraPredModeC are input to the parameter coding control unit 1131 from the coding parameter determination unit 110. The parameter coding control unit 1131 determines the intra_luma_mpm_flag by referring to the mpmCandList [] of the MPM candidate list derivation unit 30421. Then, the intra_luma_mpm_flag and IntraPredModeY are output to the luminance intra prediction parameter derivation unit 1132. In addition, IntraPredModeC is output to the color difference intra prediction parameter derivation unit 1133.

The luminance intra prediction parameter derivation unit 1132 includes an MPM candidate list derivation unit 30421 (candidate list derivation unit), an MPM parameter derivation unit 11322, and a non-MPM parameter derivation unit 11323 (coding unit, derivation unit). To.

The MPM candidate list derivation unit 30421 derives mpmCandList [] by referring to the intra-prediction mode of the adjacent block stored in the prediction parameter memory 108. The MPM parameter derivation unit 11322 derives intra_luma_mpm_idx from IntraPredModeY and mpmCandList [] when intra_luma_mpm_flag is 1, and outputs it to the entropy encoding unit 104. The non-MPM parameter derivation unit 11323 derives RemIntraPredMode from IntraPredModeY and mpmCandList [] when intra_luma_mpm_flag is 0, and outputs intra_luma_mpm_remainder to the entropy encoding unit 104.

The color difference intra prediction parameter derivation unit 1133 derives intra_chroma_pred_mode from IntraPredModeY and IntraPredModeC and outputs it.

The addition unit 106 generates a decoded image by adding the pixel value of the prediction image of the block input from the prediction image generation unit 101 and the prediction error input from the inverse quantization / inverse conversion unit 105 for each pixel. The addition unit 106 stores the generated decoded image in the reference picture memory 109.

The loop filter 107 applies a deblocking filter, SAO, and ALF to the decoded image generated by the addition unit 106. The loop filter 107 does not necessarily have to include the above three types of filters, and may have, for example, a configuration of only a deblocking filter.

SAO is a filter that adds an offset according to the classification result for each sample, and ALF is a filter that uses the sum of products of the transmitted filter coefficient and the reference image (or the difference between the reference image and the target pixel).

The prediction parameter memory 108 stores the prediction parameters generated by the coding parameter determination unit 110 at predetermined positions for each target picture and CU.

The reference picture memory 109 stores the decoded image generated by the loop filter 107 at a predetermined position for each target picture and CU.

The coding parameter determination unit 110 selects one set from the plurality of sets of coding parameters. The coding parameter is the above-mentioned QT, BT or TT division information, prediction parameter, or a parameter to be coded generated in connection with these. The prediction image generation unit 101 generates a prediction image using these coding parameters.

The coding parameter determination unit 110 calculates an RD cost value indicating the magnitude of the amount of information and the coding error for each of the plurality of sets. The coding parameter determination unit 110 selects the set of coding parameters that minimizes the calculated cost value. As a result, the entropy coding unit 104 outputs the selected set of coding parameters as the coding stream Te. The coding parameter determination unit 110 stores the determined coding parameter in the prediction parameter memory 108.

A part of the moving image coding device 11 and the moving image decoding device 31 in the above-described embodiment, for example, the entropy decoding unit 301, the parameter decoding unit 302, the loop filter 305, the prediction image generation unit 308, and the inverse quantization / reverse. Conversion unit 311, Addition unit 312, Prediction image generation unit 101, Subtraction unit 102, Conversion / quantization unit 103, Entropy coding unit 104, Inverse quantization / inverse conversion unit 105, Loop filter 107, Coding parameter determination unit 110 , The parameter coding unit 111 may be realized by a computer. In that case, the program for realizing this control function may be recorded on a computer-readable recording medium, and the program recorded on the recording medium may be read by the computer system and executed. The "computer system" referred to here is a computer system built in any of the moving image coding device 11 and the moving image decoding device 31, and includes hardware such as an OS and peripheral devices. Further, the "computer-readable recording medium" refers to a portable medium such as a flexible disk, a magneto-optical disk, a ROM, or a CD-ROM, or a storage device such as a hard disk built in a computer system. Furthermore, a "computer-readable recording medium" is a medium that dynamically holds a program for a short period of time, such as a communication line when a program is transmitted via a network such as the Internet or a communication line such as a telephone line. In that case, a program may be held for a certain period of time, such as a volatile memory inside a computer system serving as a server or a client. Further, the above-mentioned program may be a program for realizing a part of the above-mentioned functions, and may be a program for realizing the above-mentioned functions in combination with a program already recorded in the computer system.

Further, a part or all of the moving image coding device 11 and the moving image decoding device 31 in the above-described embodiment may be realized as an integrated circuit such as an LSI (Large Scale Integration). Each functional block of the moving image coding device 11 and the moving image decoding device 31 may be individually converted into a processor, or a part or all of them may be integrated into a processor. Further, the method of making an integrated circuit is not limited to LSI, and may be realized by a dedicated circuit or a general-purpose processor. Further, when an integrated circuit technology that replaces an LSI appears due to advances in semiconductor technology, an integrated circuit based on this technology may be used.

Although one embodiment of the present invention has been described in detail with reference to the drawings, the specific configuration is not limited to the above, and various design changes and the like are made without departing from the gist of the present invention. It is possible to do.

[Application example]
The moving image coding device 11 and the moving image decoding device 31 described above can be mounted on and used in various devices that transmit, receive, record, and reproduce moving images. The moving image may be a natural moving image captured by a camera or the like, or an artificial moving image (including CG and GUI) generated by a computer or the like.

First, it will be described with reference to FIG. 2 that the moving image coding device 11 and the moving image decoding device 31 described above can be used for transmitting and receiving moving images.

FIG. 2 shows a block diagram showing the configuration of the transmission device PROD_A equipped with the moving image coding device 11. As shown in the figure, the transmitter PROD_A has a coding unit PROD_A1 that obtains encoded data by encoding a moving image, and a modulation signal by modulating a carrier wave with the coded data obtained by the coding unit PROD_A1. It includes a modulation unit PROD_A2 to obtain and a transmission unit PROD_A3 to transmit the modulation signal obtained by the modulation unit PROD_A2. The moving image coding device 11 described above is used as the coding unit PROD_A1.

The transmitter PROD_A has a camera PROD_A4 for capturing a moving image, a recording medium PROD_A5 for recording a moving image, an input terminal PROD_A6 for inputting a moving image from the outside, and a moving image as a source of the moving image to be input to the coding unit PROD_A1. , An image processing unit A7 for generating or processing an image may be further provided. In the figure, the configuration in which the transmitter PROD_A is provided with all of these is illustrated, but some of them may be omitted.

The recording medium PROD_A5 may be a recording of an unencoded moving image, or a moving image encoded by a recording coding method different from the transmission coding method. It may be a thing. In the latter case, a decoding unit (not shown) that decodes the coded data read from the recording medium PROD_A5 according to the coding method for recording may be interposed between the recording medium PROD_A5 and the coding unit PROD_A1.

Further, FIG. 2 shows a block diagram showing the configuration of the receiving device PROD_B equipped with the moving image decoding device 31. As shown in the figure, the receiving device PROD_B is obtained by a receiving unit PROD_B1 that receives a modulated signal, a demodulating unit PROD_B2 that obtains coded data by demodulating the modulated signal received by the receiving unit PROD_B1, and a demodulating unit PROD_B2. It includes a decoding unit PROD_B3 that obtains a moving image by decoding the encoded data. The moving image decoding device 31 described above is used as the decoding unit PROD_B3.

The receiving device PROD_B serves as a supply destination of the moving image output by the decoding unit PROD_B3, a display PROD_B4 for displaying the moving image, a recording medium PROD_B5 for recording the moving image, and an output terminal for outputting the moving image to the outside. It may also have PROD_B6. In the figure, the configuration in which the receiving device PROD_B is provided with all of these is illustrated, but some of them may be omitted.

The recording medium PROD_B5 may be used for recording an unencoded moving image, or may be encoded by a recording coding method different from the transmission coding method. You may. In the latter case, a coding unit (not shown) that encodes the moving image acquired from the decoding unit PROD_B3 according to the recording coding method may be interposed between the decoding unit PROD_B3 and the recording medium PROD_B5.

The transmission medium for transmitting the modulated signal may be wireless or wired. Further, the transmission mode for transmitting the modulated signal may be broadcasting (here, a transmission mode in which the destination is not specified in advance) or communication (here, transmission in which the destination is specified in advance). Refers to an aspect). That is, the transmission of the modulated signal may be realized by any of wireless broadcasting, wired broadcasting, wireless communication, and wired communication.

For example, a broadcasting station (broadcasting equipment, etc.) / receiving station (television receiver, etc.) of terrestrial digital broadcasting is an example of a transmitting device PROD_A / receiving device PROD_B that transmits and receives modulated signals by radio broadcasting. Further, a broadcasting station (broadcasting equipment, etc.) / receiving station (television receiver, etc.) of cable television broadcasting is an example of a transmitting device PROD_A / receiving device PROD_B that transmits and receives modulated signals by wired broadcasting.

In addition, servers (workstations, etc.) / clients (television receivers, personal computers, smartphones, etc.) for VOD (Video On Demand) services and video sharing services using the Internet are transmitters that send and receive modulated signals via communication. This is an example of PROD_A / receiver PROD_B (usually, in LAN, either wireless or wired is used as a transmission medium, and in WAN, wired is used as a transmission medium). Here, personal computers include desktop PCs, laptop PCs, and tablet PCs. Smartphones also include multifunctional mobile phone terminals.

The client of the video sharing service has a function of decoding the encoded data downloaded from the server and displaying it on the display, as well as a function of encoding the moving image captured by the camera and uploading it to the server. That is, the client of the video sharing service functions as both the transmitting device PROD_A and the receiving device PROD_B.

Next, it will be described with reference to FIG. 3 that the moving image coding device 11 and the moving image decoding device 31 described above can be used for recording and reproducing a moving image.

FIG. 3 shows a block diagram showing the configuration of the recording device PROD_C equipped with the moving image coding device 11 described above. As shown in the figure, the recording device PROD_C has a coding unit PROD_C1 that obtains coded data by encoding a moving image and a writing unit PROD_C2 that writes the coded data obtained by the coding unit PROD_C1 to the recording medium PROD_M. And have. The moving image coding device 11 described above is used as the coding unit PROD_C1.

The recording medium PROD_M may be of a type built in the recording device PROD_C, such as (1) HDD (Hard Disk Drive) or SSD (Solid State Drive), or (2) SD memory. It may be of a type that is connected to the recording device PROD_C, such as a card or USB (Universal Serial Bus) flash memory, or (3) DVD (Digital Versatile Disc: registered trademark) or BD (Blu-ray). It may be loaded in a drive device (not shown) built in the recording device PROD_C, such as Disc (registered trademark).

Further, the recording device PROD_C has a camera PROD_C3 that captures a moving image, an input terminal PROD_C4 for inputting a moving image from the outside, and a reception for receiving the moving image as a source of the moving image to be input to the coding unit PROD_C1. A unit PROD_C5 and an image processing unit PROD_C6 for generating or processing an image may be further provided. In the figure, the configuration in which the recording device PROD_C is provided with all of these is illustrated, but some of them may be omitted.

The receiving unit PROD_C5 may receive an unencoded moving image, or receives coded data encoded by a transmission coding method different from the recording coding method. It may be something to do. In the latter case, it is preferable to interpose a transmission decoding unit (not shown) for decoding the coded data encoded by the transmission coding method between the receiving unit PROD_C5 and the coding unit PROD_C1.

Examples of such a recording device PROD_C include a DVD recorder, a BD recorder, and an HDD (Hard D).
isk Drive) Recorder, etc. (In this case, the input terminal PROD_C4 or the receiving unit PROD_C5 is the main source of moving images). In addition, a camcorder (in this case, the camera PROD_C3 is the main source of moving images), a personal computer (in this case, the receiving unit PROD_C5 or the image processing unit C6 is the main source of moving images), and a smartphone (this In this case, the camera PROD_C3 or the receiving unit PROD_C5 is the main source of moving images), etc. are also examples of such a recording device PROD_C.

Further, FIG. 3 shows a block diagram showing the configuration of the reproduction device PROD_D equipped with the above-mentioned moving image decoding device 31. As shown in the figure, the playback device PROD_D includes a reading unit PROD_D1 that reads the coded data written in the recording medium PROD_M, and a decoding unit PROD_D2 that obtains a moving image by decoding the coded data read by the reading unit PROD_D1. , Is equipped. The moving image decoding device 31 described above is used as the decoding unit PROD_D2.

The recording medium PROD_M may be of a type built in the playback device PROD_D, such as (1) HDD or SSD, or (2) such as an SD memory card or USB flash memory. It may be of a type connected to the playback device PROD_D, or may be loaded into a drive device (not shown) built in the playback device PROD_D, such as (3) DVD or BD. Good.

Further, the playback device PROD_D has a display PROD_D3 for displaying the moving image, an output terminal PROD_D4 for outputting the moving image to the outside, and a transmitting unit for transmitting the moving image as a supply destination of the moving image output by the decoding unit PROD_D2. It may also have PROD_D5. In the figure, the configuration in which the playback device PROD_D is provided with all of these is illustrated, but some of them may be omitted.

The transmission unit PROD_D5 may transmit an unencoded moving image, or transmits coded data encoded by a transmission coding method different from the recording coding method. It may be something to do. In the latter case, it is preferable to interpose a coding unit (not shown) that encodes the moving image by a coding method for transmission between the decoding unit PROD_D2 and the transmitting unit PROD_D5.

Examples of such a playback device PROD_D include a DVD player, a BD player, an HDD player, and the like (in this case, the output terminal PROD_D4 to which a television receiver or the like is connected is the main supply destination of the moving image). .. In addition, a television receiver (in this case, display PROD_D3 is the main supply destination of moving images) and digital signage (also called electronic signage or electronic bulletin board, etc., and display PROD_D3 or transmitter PROD_D5 is the main supply destination of moving images. (First), desktop PC (in this case, output terminal PROD_D4 or transmitter PROD_D5 is the main supply destination of moving images), laptop or tablet PC (in this case, display PROD_D3 or transmitter PROD_D5 is video) An example of such a playback device PROD_D is a smartphone (in this case, the display PROD_D3 or the transmitter PROD_D5 is the main supply destination of the moving image) and the like (which is the main supply destination of the image).

(Hardware realization and software realization)
Further, each block of the moving image decoding device 31 and the moving image coding device 11 described above may be realized in hardware by a logic circuit formed on an integrated circuit (IC chip), or may be realized by a CPU (Central Processing). It may be realized by software using Unit).

In the latter case, each of the above devices is a CPU that executes instructions of a program that realizes each function, a ROM (Read Only Memory) that stores the above program, and a RAM (Random) that expands the above program.
Access Memory), a storage device (recording medium) such as a memory for storing the above program and various data. Then, an object of the embodiment of the present invention is a record in which the program code (execution format program, intermediate code program, source program) of the control program of each of the above devices, which is software for realizing the above-mentioned functions, is recorded so as to be readable by a computer. It can also be achieved by supplying the medium to each of the above devices and having the computer (or CPU or MPU) read and execute the program code recorded on the recording medium.

Examples of the recording medium include tapes such as magnetic tapes and cassette tapes, magnetic disks such as floppy (registered trademark) disks / hard disks, and CD-ROMs (Compact Disc Read-Only Memory) / MO disks (Magneto-Optical discs). ) / MD (Mini Disc) / DVD (Digital Versatile Disc: registered trademark) / CD-R (CD Recordable) / Blu-ray disc (Blu-ray)
Discs including optical disks such as Disc: IC cards (including memory cards) / cards such as optical cards, mask ROM / EPROM (Erasable Programmable Read-Only Memory) / EEPROM (Electrically Erasable and Programmable Read- Only Memory: Semiconductor memories such as flash ROM, or logic circuits such as PLD (Programmable logic device) and FPGA (Field Programmable Gate Array) can be used.

Further, each of the above devices may be configured to be connectable to a communication network, and the above program code may be supplied via the communication network. This communication network is not particularly limited as long as it can transmit the program code. For example, Internet, Intranet, Extranet, LAN (Local Area Network), ISDN (Integrated Services Digital Network), VAN (Value-Added Network), CATV (Community Antenna television / Cable Television) communication network, Virtual Private network (Virtual Private) Network), telephone line network, mobile communication network, satellite communication network, etc. can be used. Further, the transmission medium constituting this communication network may be any medium as long as it can transmit the program code, and is not limited to a specific configuration or type. For example, even wired such as IEEE (Institute of Electrical and Electronic Engineers) 1394, USB, power line carrier, cable TV line, telephone line, ADSL (Asymmetric Digital Subscriber Line) line, infrared data such as IrDA (Infrared Data Association) and remote control , BlueTooth (registered trademark), IEEE802.11 wireless, HDR (High Data Rate), NFC (Near Field Communication), DLNA (Digital Living Network Alliance: registered trademark), mobile phone network, satellite line, terrestrial digital broadcasting network, etc. It is also available wirelessly. The embodiment of the present invention can also be realized in the form of a computer data signal embedded in a carrier wave, in which the program code is embodied by electronic transmission.

The embodiment of the present invention is not limited to the above-described embodiment, and various modifications can be made within the scope of the claims. That is, an embodiment obtained by combining technical means appropriately modified within the scope of the claims is also included in the technical scope of the present invention.

The embodiment of the present invention is suitably applied to a moving image decoding device that decodes coded data in which image data is encoded, and a moving image coding device that generates coded data in which image data is encoded. be able to. Further, it can be suitably applied to the data structure of the coded data generated by the moving image coding device and referenced by the moving image decoding device.

31 Video decoding device
301 Entropy Decryptor
302 Parameter decoder
3020 Header decoder
3026 Scaling list decryption section
308 Prediction image generator
311 Inverse quantization / inverse conversion
312 Addition part
11 Video coding device
101 Predictive image generator
102 Subtraction section
103 Transformation / Quantization Department
104 Entropy encoding unit
105 Inverse quantization / inverse conversion part
107 Loop filter
110 Coding parameter determination unit
111 Parameter coding section
1110 Header coding part
1111 CT information coding unit
1112 CU coding unit (prediction mode coding unit)
1114 TU coding section
3111 Inverse quantization unit
3112 Inverse converter
31121 Inverse secondary conversion unit (inverse non-separation conversion unit)
31122 Scaling section
31123 Reverse core conversion unit (reverse separation conversion unit)
3113 Joint error derivation part

Claims (18)

An image decoding device that reversely converts the conversion coefficient for each conversion unit.
A scaling list decoding unit that decodes the first scaling list for separation conversion and the second scaling list for non-separation conversion.
A scaling unit that scales with respect to the decoded conversion coefficient,
A second conversion unit that applies an inverse non-separation conversion to the scaled conversion coefficient,
A first conversion unit that applies an inverse core conversion to the converted conversion coefficient or the scaled conversion coefficient is provided.
The scaling list decoding unit is an image decoding device characterized by decoding a value of a fixed number of elements as the second scaling list for each predetermined size. The image decoding apparatus according to claim 1, wherein the value of the number of fixed elements is 16. The image decoding apparatus according to claim 1, wherein the predetermined sizes are 4 and 8. A scaling list decoding unit for decoding a first scaling list for separation conversion and a second scaling list for non-separation conversion is provided.
The scaling unit derives a scale factor using the first scaling list when the scaling list is valid and the non-separable conversion is not valid.
When the scaling list is valid and the non-separable transformation is valid, the scale factor using the second scaling list is derived, and when the scaling list is not valid, the fixed scale factor is derived, and the scale factor is used. The image decoding apparatus according to claim 1, wherein scaling is performed on the conversion coefficient. The scaling list decoding unit decodes the adaptation parameter set (APS), and when adaptation_paraemeter_set_id of APS indicates a separation conversion scaling list, the first scaling list is decoded, and the adaptation_paraemeter_set_id indicates a non-separation conversion scaling list. The image decoding apparatus according to claim 1, wherein when shown, the second scaling list is decoded. The scaling list decoding unit displays a one-dimensional ScalingList [log2StSize] [log2StSize] [pos] decoded for each predetermined size log2StSize and a table DiagScanOrder [log2StSize] [log2StSize] [] showing the scanning order for each predetermined size. Decrypt the second scaling list by deriving the two-dimensional ScalingFactor [log2StSize] [log2StSize] [x] [y] by reference.
When the pos is less than the fixed number of elements, the scaling list decoding unit sets the values of the ScalingList [log2StSize] [log2StSize] [pos] to the ScalingFactor [log2StSize] [log2StSize] [x] [y]. The image decoding apparatus according to claim 1, wherein a predetermined fixed value is set in other cases. When deriving the second scaling factor, the scaling unit derives the logarithmic log2StSize of the size of the separation conversion from the size of the conversion block, and the ScalingFactor [log2StSize] [log2StSize] [matrixId specified by the log2StSize above. ] [X] [y] The image decoding apparatus according to claim 4, wherein a scaling factor is derived using [x] [y]. When deriving the scaling factor of the non-separable conversion, the scaling unit derives the log2StSize of the size of the separation conversion from the size of the conversion block, and the scan order from the raster scan for the log2StSize and the predetermined size Raster2DiagScanPos [ 2] The above one-dimensional ScalingList specified by [2] [log2StSize] [Raster2DiagScanPos [2] [2] [x + y * 4]
The image decoding apparatus according to claim 4, wherein a scaling factor is derived using the above. The scaling unit is the value of the second scaling list ScalingList [log2StSize] [Raster2DiagScanPos [2] [2] [x + y * 4] for the region where the position (x, y) of the conversion block is low frequency. The image decoding apparatus according to claim 7, wherein the image decoding device is characterized by using the above and otherwise setting a predetermined fixed value. An image coding device that converts the conversion coefficient for each conversion unit.
A scaling list coding unit that encodes a first scaling list for separation conversion and a second scaling list for non-separation conversion.
It is provided with a first conversion unit (separation conversion unit) that converts the residuals and derives the conversion coefficient, and a second conversion unit (non-separation conversion unit) that converts the conversion coefficient of the output of the first conversion unit.
A scaling unit that scales with respect to the conversion coefficient of the output of the second conversion unit,
The scaling list coding unit is an image coding device that encodes a value of a fixed number of elements as the second scaling list for each predetermined size. The image coding apparatus according to claim 10, wherein the value of the number of fixed elements is 16. The image coding apparatus according to claim 10, wherein the predetermined sizes are 4 and 8. A scaling list coding unit for encoding a first scaling list for separation conversion and a second scaling list for non-separation conversion is provided.
The scaling unit derives a scale factor using the first scaling list when the scaling list is valid and the non-separable conversion is not valid.
When the scaling list is valid and the non-separable transformation is valid, the scale factor using the second scaling list is derived, and when the scaling list is not valid, the fixed scale factor is derived, and the scale factor is used. The image coding apparatus according to claim 12, wherein the conversion coefficient is scaled. The scaling list encoding unit encodes the adaptation parameter set (APS), encodes the first scaling list when adaptation_paraemeter_set_id of APS indicates a separation conversion scaling list, and the adaptation_paraemeter_set_id is a non-separation conversion scaling list. The image coding apparatus according to claim 10, wherein the second scaling list is encoded. The scaling list encoding unit is a one-dimensional ScalingList [log2StSize] [log2StSize] [pos] encoded for each predetermined size log2StSize, and a table DiagScanOrder [log2StSize] [log2StSize] [pos] showing the scan order for each predetermined size. ] To encode the second scaling list by deriving the two-dimensional ScalingFactor [log2StSize] [log2StSize] [x] [y].
When the pos is less than the fixed number of elements, the scaling list encoding unit sets the values of the ScalingList [log2StSize] [log2StSize] [pos] to the ScalingFactor [log2StSize] [log2StSize] [x] [y]. However, the image coding apparatus according to claim 10, wherein a predetermined fixed value is used in other cases. When deriving the second scaling factor, the scaling unit derives the logarithmic log2StSize of the size of the separation conversion from the size of the conversion block, and the ScalingFactor [log2StSize] [log2StSize] [matrixId] specified by the log2StSize. ] [X] [y] The image coding apparatus according to claim 14, wherein a scaling factor is derived using [x] [y]. When deriving the second scaling factor, the scaling unit derives the logarithmic log2StSize of the size of the separation conversion from the size of the conversion block, and the raster scan order Raster2DiagScanPos [2] [2] for the log2StSize and the predetermined size. The image according to claim 14, wherein a scaling factor is derived using the one-dimensional ScalingList [log2StSize] [Raster2DiagScanPos [2] [2] [x + y * 4] specified in 2]. Encoding device. The scaling unit sets the values of the second ScalingList [log2StSize] [Raster2DiagScanPos [2] [2] [x + y * 4] for the region where the position (x, y) of the conversion block is low frequency. The image coding apparatus according to claim 17, wherein the image coding apparatus is used, and otherwise has a predetermined fixed value.

Images