JP2022002356A - Moving image coding device and moving image decoding device - Google Patents

Abstract

To provide a moving image coding device and a moving image decoding device, improving a method for initializing the CABAC state of a target picture by reference to the CABAC state of a processed picture, thereby capable of improving the coding efficiency of CABAC.SOLUTION: An image decoding device for decoding coded data that are variable-length coded includes an entropy decoding unit for decoding a CABAC temporal prediction flag. A CABAC initialization unit, which initializes a CABAC state at the head of segments constituting a picture, initializes the CABAC state using a temporal prediction table holding the CABAC state when the CABAC temporal prediction flag is one, and initializes the CABAC state using an initialization table when the CABAC temporal prediction flag is zero.SELECTED DRAWING: Figure 12

Description

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

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

Specific examples of the moving image coding method include the methods proposed by H.264 / AVC and HEVC (High-Efficiency Video Coding).

In such a moving image coding method, the image (picture) constituting the moving image is a slice obtained by dividing the image and a coding tree unit (CTU: Coding Tree Unit) obtained by dividing the slice. ), A coding unit (sometimes called a Coding Unit (CU)) obtained by dividing a coding tree unit, and a conversion unit (TU:) obtained by dividing a coding unit. It is managed by a hierarchical structure consisting of (Transform Unit), and is encoded / decoded for each CU.

Further, in such a moving 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 obtained from the input image (original image). The prediction error obtained by subtraction (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-prediction) and in-screen prediction (intra-prediction).

Further, Non-Patent Document 1 is mentioned as a technique for coding and decoding moving images in recent years.

"Algorithm Description of Joint Exploration Test Model 7", JVET-G1001, Joint Video Exploration Team (JVET) of ITU-T SG 16 WP 3 and ISO / IEC JTC 1 / SC 29/WG 11, 2017-08-19

The method of initializing the CABAC state of the target picture by referring to the CABAC state of the already processed picture is stored in the prediction table for each quantization step, so in the encoder (other than fixed quantization) that uses rate control, There is a problem that the performance is not sufficient.

Further, even if the CABAC state is stored in the prediction table, it is not determined whether the corresponding picture exists in the reference picture list, so there is a problem that a picture that cannot be referred to may be referred to.

In addition, there is a problem that it is not possible to repeat whether or not to refer to the CABAC state from the prediction table for each prediction region.

In addition, there is a problem that it is not possible to repeat whether or not to refer to the CABAC state from the prediction table for each segment.

Further, when the CABAC state is stored in the prediction table for each prediction region, there is a problem that the particle size cannot be changed.

The image decoding device according to one aspect of the present invention is an image decoding device that decodes variable-length coded coded data, includes an entropy decoding unit that decodes the CABAC time prediction flag, and is a segment head that constitutes a picture. The CABAC initialization unit is provided with a CABAC initialization unit that initializes the CABAC state, and the CABAC initialization unit initializes the CABAC state using a time prediction table that holds the CABAC state when the CABAC time prediction flag is 1. , When the CABAC time prediction flag is 0, the CABAC state is initialized using the initialization table.

The entropy decoding unit further decodes the CABAC space-time prediction mode, and the CABAC initialization unit is the position in the screen at the head of the segment when the CABAC space-time prediction mode is 1 (screen division mode). It is characterized in that the CABAC state is read out from the above time prediction table and the CABAC state is initialized by using.

The image decoding device further decodes the CABAC space-time prediction mode, and when the number of screen divisions indicated by the CABAC space-time prediction mode is 2 or more, the time prediction is performed using the position in the screen at the head of the segment. It is characterized by reading the CABAC state from the table and initializing the CABAC state.

The image decoding device further decodes the segment prediction flag for each segment, and when the segment time prediction flag is 1, reads the CABAC state from the time prediction table and initializes the CABAC state. , (When the segment time prediction flag is 0, the CABAC state is initialized using the initialization table, or prediction is performed from the spatial prediction table).

The image decoding device further decodes the predicted region time prediction flag for each predicted region, and when the predicted region time prediction flag is 1, reads the CABAC state from the time prediction table to obtain the CABAC state. It is characterized by performing initialization (when the segment time prediction flag is 0, the CABAC state is initialized using the initialization table, or prediction is performed from the spatial prediction table).

An image decoding device that decodes variable-length coded coded data, including an entropy decoding unit that reads the CABAC state from the time prediction table at the beginning of the segment that constitutes the picture, and the entropy decoding unit is the target picture. It is characterized in that the entry of the time prediction table is selected for each temporal layer.
An image decoding device that decodes variable-length coded coded data, including an entropy decoding unit that stores the CABAC state in a time prediction table at the beginning of a segment that constitutes a picture, and the entropy decoding unit is the target picture. It is characterized in that the entry of the time prediction table is selected for each temporal layer of.

The image coding device according to one aspect of the present invention is an image coding device that encodes coded data by variable length coding, includes an entropy coding unit that encodes a CABAC time prediction flag, and displays a picture. At the beginning of the constituent segment, a CABAC initialization unit that initializes the CABAC state is provided, and the CABAC initialization unit uses a time prediction table that holds the CABAC state when the CABAC time prediction flag is 1, and the CABAC state is changed. It is characterized in that initialization is performed and the CABAC state is initialized using the initialization table when the CABAC time prediction flag is 0.

According to one aspect of the present invention, it is possible to improve the coding efficiency of the CABAC that encodes the binary string of the syntax element in the moving image coding / decoding process.

It is a schematic diagram which shows the structure of the image transmission system which concerns on this embodiment. It is a figure which showed the structure of the transmission device which carried out the moving image coding device which concerns on this embodiment, and the receiving device which carried out the moving image decoding device. (a) shows a transmitting device equipped with a moving image coding device, and (b) shows a receiving device equipped with a moving image decoding device. It is a figure which showed the structure of the recording apparatus which carried out the moving image coding apparatus which concerns on this embodiment, and the reproduction apparatus which provided with moving image decoding apparatus. (a) shows a recording device equipped with a moving image coding device, and (b) shows a reproducing 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 figure explaining a temporal layer and a reference picture list. It is a schematic diagram 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 a figure which shows the syntax for time prediction. It is a figure which shows the syntax for time prediction. It is a figure which shows the syntax structure of slice data. It is a figure which shows the structure of the entropy decoding part. It is a flowchart which shows the initialization process in the entropy decoding unit 301. This is another example of the flowchart showing the initialization process in the entropy decoding unit 301. It is a flowchart which shows the derivation process of the availability of a time prediction table. This is another example of a flowchart showing the process of deriving the availability of a time prediction table. It is a flowchart which shows the storage process of the CABAC state in the entropy decoding unit 301. This is another example of the flowchart showing the storage process of the CABAC state in the entropy decoding unit 301. It is a figure which shows the structure of the time prediction table. It is a figure which shows another structure of the time prediction table. It is a figure for demonstrating a prediction region. This is an example of referencing the CABAC state stored in the predicted region unit from the segment in the CTU line unit. It is a figure which shows the structure of the entropy coding part. It is a figure explaining the storage position of the CABAC state in a prediction region. It is another figure explaining the storage position of the CABAC state in a prediction region. It is another figure explaining the storage position of the CABAC state in a prediction region. It is another figure explaining the storage position of the CABAC state according to the use of WPP. It is a flowchart which shows the storage process of the CABAC state according to the use of WPP in the entropy decoding unit 301.

(First Embodiment)
Hereinafter, embodiments of the present invention will be described with reference to the drawings.

FIG. 1 is a schematic diagram 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 a moving 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 moving 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 moving 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, a high-quality image is displayed, and when the moving image decoding device 31 has only a lower processing capacity, a high processing capacity and an image that does not require a display capacity are displayed. ..

<Operator>
The operators used herein are described below.

>> is a right bit shift, << is a left bit shift, & is a bitwise AND, | is a bitwise OR, | = is an OR assignment operator, and || is a logical sum.

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 largest 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 constituting the sequence. In FIGS. 4 (a) to 4 (f), a coded video sequence that defines the sequence SEQ, a coded picture that defines the picture PICT, a coded slice that defines the slice S, and a coded slice that defines the slice data, respectively. It is a figure which shows the coded tree unit included in the data, the coded slice data, and the coded unit included in a coded tree unit.

(Coded video sequence)
The coded video sequence defines a set of data referred to by the moving image decoding device 31 in order to decode the sequence SEQ to be processed. As shown in FIG. 4A, 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 an additional extension. Information SEI (Supplemental Enhancement Information) is included.

A video parameter set VPS is a set of coding parameters common to a plurality of moving images in a moving image composed of a plurality of layers, and a set of coding parameters related to the multiple layers included in the moving image and individual layers. The set is defined.

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 SPS 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, it includes a reference value of the quantization width used for decoding a picture (pic_init_qp_minus26) and a flag (weighted_pred_flag) indicating the application of weighted prediction. There may be a plurality of PPSs. In that case, select one of a plurality of PPSs 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 Figure 4 (b) (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 having a subscript.

(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 FIG. 4 (c).

The slice header contains a set of coding parameters referred to by the moving image decoding device 31 for determining 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 are (1) I slice that uses only intra prediction for coding, (2) unidirectional prediction for coding, or P slice that uses intra prediction. (3) B slices using unidirectional prediction, bidirectional prediction, or intra prediction at the time of coding can be mentioned. 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. The picture may be divided into tiles or CTU lines in addition to slices. Encoded data separated by tiles, CTU lines, pictures, etc. is called a segment. Slices, tiles and CTU lines may be combined hierarchically. That is, the slice may be divided into tiles, the tile may be divided into slices, or the tiles may be divided into CTU lines.

(Tile and WPP)
Tiles divide the picture into segments of rectangular unit areas. WPP is an abbreviation for Wavefront Parallel Processing, and processes pictures or tiles by dividing them into segments in units of CTU lines. The segments can be decoded independently without being referenced by each other, but in the loop filter, filtering may be performed between the segments.

(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 the CTU, as shown in Figure 4 (d). A CTU is a block of fixed size (for example, 64x64) that constitutes a slice, and is sometimes called a maximum coding unit (LCU).

When the size of the CTU is expressed by CtbSizeY and the width and height of the picture are expressed by pic_width_in_luma_samples and pic_height_in_luma_samples, the width PicWidthInCtbsY and the height PicHeightInCtbsY of the picture in units of CTU size are derived below.

PicWidthInCtbsY = ceil (pic_width_in_luma_samples / CtbSizeY)
PicHeightInCtbsY = ceil (pic_height_in_luma_samples / CtbSizeY)
Assuming that the raster scan address of the target CTU is CtbAddrInRs, the X and Y coordinates in CTU units can be expressed as follows.

CtbAddrX = CtbAddrInRs% PicWidthInCtbsY
CtbAddrY = CtbAddrInRs / PicWidthInCtbsY
(Coded tree unit)
FIG. 4 (e) 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 node with a tree structure 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.

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

When cu_split_flag is 1, the coding node is divided into 4 coding nodes (Fig. 5 (b)).

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

When split_mt_flag is 1, the coded 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 (Fig. 5 (d)), and when split_mt_dir is 0, the coded node is perpendicular to the two coded nodes. It is divided (Fig. 5 (c)). Also, when split_mt_type is 1, the coding node is horizontally divided into 3 coding nodes when split_mt_dir is 1 (Fig. 5 (f)), and when split_mt_dir is 0, the coding node is 3 coding nodes. It is vertically divided into (Fig. 5 (e)). These are shown in Fig. 5 (g).

If 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. ..

(Coding unit)
As shown in FIG. 4 (f), a set of data referred to by the moving image decoding device 31 in order to decode 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 prediction mode etc. are specified in the CU header.

The prediction process may be performed in CU units or in sub-CU units that are further divided CUs. 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 four sub-CUs consisting of two horizontal divisions and two vertical divisions.

There are two types of prediction (prediction mode): intra-prediction and inter-prediction. Intra prediction refers to prediction within the same picture, and inter prediction refers to prediction processing performed between pictures different from each other (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-coded in subblock units such as 4x4.

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

(Temporal layer and reference picture list)
The reference picture list RefPicList is a list of reference pictures stored in the reference picture memory 306. FIG. 6 is a conceptual diagram showing an example of a reference picture and a reference picture list. In FIG. 6 (a), the rectangle is a picture, the arrow is a reference relationship of the picture, the horizontal axis is time, I, P, and B in the rectangle are intra pictures, single prediction pictures, bi-prediction pictures, and the numbers in the rectangle are decoded. Show the order. As shown in the figure, the decoding order of the pictures is I0, P1, B2, B3, B4, and the display order is I0, B3, B2, B4, P1.

The moving image decoding device and the moving image coding device depend only on the pictures included in the reference picture list RefPicList to decode and encode the target picture. On the contrary, the subsequent pictures can be decoded without decoding the pictures (non-referenced pictures) not included in the reference picture list RefPicList. Temporal layers are groups of pictures in the time direction, and a value called Temporal ID (Tid) is assigned to each group. By limiting the control relationship so that the picture group of the temporal layer = M refers only to the picture group of the temporal layer M or lower, for example, only the predetermined temporary layers = 0 and 1 are decoded, and the temporal layer = 2 is set. By not decoding, high-speed playback and the like become possible.

FIG. 6B shows an example of a reference picture list of picture B3 (target picture). The reference picture list is a list representing candidates for reference pictures, and one picture (slice) may have one or more reference picture lists. In the example of the figure, the target picture B3 has two reference picture lists, L0 list RefPicList0 and L1 list RefPicList1. In each CU, the reference picture index refIdxLX specifies which picture in the reference picture list RefPicListX (X = 0 or 1) is actually referenced. The figure is an example of refIdxL0 = 2 and refIdxL1 = 0. Note that LX is a description method used when the L0 prediction and the L1 prediction are not distinguished. In the following, the parameters for the L0 list and the parameters for the L1 list are distinguished by replacing LX with L0 and L1.

(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 generation unit (predicted image generator) 308, and a reverse. It includes 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 further includes a TU decoding unit 3024. These may be collectively 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.

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, examples of using CTU and CU 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, CU, may be read as a block, and a sub-CU may be read as a sub-block, and the 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, 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 the memory. Then, as the initial state of the context of the P picture or the B picture, a 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 encoding and decoding processing. The decoded code includes prediction information for generating a prediction image, prediction error for generating a difference image, and the like.

The entropy decoding unit 301 outputs the decoded code to the parameter decoding unit 302. The decoded code is, for example, a prediction mode predMode, a merge flag merge_flag, a merge index merge_idx, an inter prediction identifier inter_pred_idc, a reference picture index refIdxLX, a prediction vector index mvp_LX_idx, a difference vector mvdLX, and the like. 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 the 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. Initialize CABAC before decoding the CTU at the beginning of the segment. Further, after decoding the CTU at a predetermined position in the segment, the CABAC state is stored in the time prediction table and the spatial prediction table.

(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) 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 QP update information is a difference value from the quantized parameter predicted value qPpred, which is the predicted value of the quantized 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 transformation) The inverse quantization / inverse transformation unit 311 executes the inverse quantization / inverse transformation processing for each TU included in the target CU.

(S4000: Decoded image generation) The adder 312 decodes the target CU by adding the predicted image supplied by the predicted 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, or ALF to the decoded image to generate a decoded image.

The loop filter 305 is a filter provided in the coding loop, and is a filter that removes block distortion and ringing distortion to improve image quality. The loop filter 305 applies a filter such as a deblocking filter, a sample adaptive offset (SAO), and an adaptive loop filter (ALF) to the decoded image of the CU generated by the addition unit 312.

The reference picture memory 306 stores the decoded image of the CU generated by the addition unit 312 at a predetermined position for each target picture and the target CU.

The prediction parameter memory 307 stores the prediction parameters at a predetermined position for each CTU or CU to be decoded. Specifically, the prediction parameter memory 307 stores the parameters decoded by the parameter decoding unit 302, the prediction mode predMode decoded by the entropy decoding unit 301, and the like.

The prediction mode predMode, prediction parameters, and the like are input to the prediction image generation unit 308. Further, the prediction image generation unit 308 reads the reference picture from the reference picture memory 306. The prediction image generation unit 308 generates a block or subblock prediction image using the prediction parameter and the read reference picture (reference picture block) in the prediction mode indicated by the prediction mode predMode. Here, the reference picture block is a set of pixels on the reference picture (usually called a block because it is a rectangle), and is a region to be referred to for generating a predicted image.

The inverse quantization / inverse conversion unit 311 inversely quantizes the quantization conversion coefficient input from the entropy decoding unit 301 to obtain the conversion coefficient. This quantization transform coefficient is used for prediction errors in the coding process, such as DCT (Discrete Cosine Transform), DST (Discrete Sine Transform), and KLT (Karyhnen Loeve Transform). It is a coefficient obtained by performing frequency conversion such as and quantizing. The inverse quantization / inverse transformation unit 311 performs inverse frequency conversion such as inverse DCT, inverse DST, and inverse KLT on the obtained conversion coefficient, and calculates a prediction error. The inverse quantization / inverse transformation unit 311 outputs the prediction error to the addition unit 312.

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 it to the loop filter 305.

(Coded data and segments)
The coded data constituting the screen is composed of slices, and when tiles are used (tiles_enabled_flag = 1), the slices are further composed of tile segments. When WPP is used (entropy_coding_sync_enabled_flag = 1), the slice is further composed of segments of the CTU line. If neither tiles nor WPP are used, the slice is one segment. A segment is a unit for decoding coded data. In order to decode the CABAC data from each segment, the coded data encodes the information (entry_point_offset_minus1 [i]) indicating the head position of each segment i, and the CABAC state is initialized at the head of each segment. offset_len_minus1 is the number of bits required for fixed-length coding of entry_point_offset_minus1 [i]. For example, if it is 16, the value from 0 to 65535 can be encoded as entry_point_offset_minus1 [i]. Hereinafter, the segment may be referred to as a substream.

(Forecast region)
In FIG. 21, when the time is predicted in the CABAC state, the unit stored in the time prediction table 3014 may be the entire picture or a unit area obtained by dividing the picture. These units are called predictive regions. As shown in FIG. 21 (a), the CABAC state may be stored with the entire picture as one prediction region. In this case, the storage position of the CABAC state may be the CTU in the center of the screen as shown by the black square. The dotted line in the figure indicates a line that divides the screen into 1/2 vertically and 1/2 horizontally. As shown in FIG. 21 (b), the predicted region may be each rectangular region in which a picture or tile is divided into NumCabacPredRegions at the top and bottom. In this case, the storage position of the CABAC state may be the CTU at the lower right of the predicted region as shown by the black square. As shown in FIG. 21 (c), when the CABAC state is stored with the entire picture as one prediction region, the storage position of the CABAC state may be the CTU where the Y coordinate is the center of the picture and the X coordinate is the right edge of the screen.

(CABAC time prediction parameter)
FIG. 9 is a diagram showing a syntax configuration of CABAC time prediction parameters. The CABAC time prediction parameter consists of the CABAC time prediction flag temporary_cabac_pred_enabled_flag and the CABAC space-time prediction mode spatial_temporal_cabac_pred_mode. The former is a flag indicating whether or not to perform time prediction of the CABAC state, and the latter is a mode indicating whether or not to perform prediction in a certain unit area (prediction region unit) that divides the screen when performing time prediction. .. In this example, transmission is performed using the syntax of the picture parameter set, but the transmission is not limited to this and may be performed using the sequence parameter set. When spatial_temporal_cabac_pred_mode = 0, the CABAC state may be stored with the picture as one prediction region. spatial_temporal_cabac_pred_mode! When = 0, the picture may be divided by spatial_temporal_cabac_pred_mode (NumCabacPredRegion = spatial_temporal_cabac_pred_mod). In addition, the number of divisions NumCabacPredRegion may be determined by the following table.

region_table [] = {2, 3, 4, 6, 8}
NumCabacPredRegion ＝ region_table [spatial_temporal_cabac_pred_mode]
In this case, when spatial_temporal_cabac_pred_mode is 1, 2, 3, 4, 5, each picture is divided into 2, 3, 4, 6, and 8. The relationship between spatial_temporal_cabac_pred_mode and the number of divisions is not limited to the above.
(A) in the figure is an example of notifying the CABAC space-time prediction flag when the CABAC state is time-predicted (when temporary_cabac_pred_enabled_flag = 1). (B) in the figure is an example of notifying the CABAC time prediction mode spatial_temporal_cabac_pred_mode when WPP (entropy_coding_sync_enabled_flag) is used, and notifying the CABAC space-time prediction mode spatial_temporal_cabac_pred_mode when predicting the CABAC state.

FIG. 10 is a diagram showing the syntax structure of slices. If the slice is composed of multiple segments (tiles are enabled tiles_enabled_flag = 1 or WPP is enabled entropy_coding_sync_enabled_flag = 1), the coded data is the number of segments (num_entry_point_offsets), information indicating the start position of each segment. Includes (entry_point_offset_minus1 [i]). When the CABAC time prediction flag temporary_cabac_pred_enabled_flag is 1, a segment time prediction flag slice_temporal_cabac_pred_enabled_flag [i] indicating whether or not to perform CABAC state time prediction in segment units may be further included.

The entropy decoding unit 301 decodes the CABAC time prediction flag temporary_cabac_pred_enabled_flag. When the CABAC time prediction flag temporary_cabac_pred_enabled_flag is 1, the entropy decoding unit 301 further decodes the CABAC space-time prediction mode spatial_temporal_cabac_pred_mode. It should be noted that one syntax element cabac_pred_enabled_mode may be used instead of using syntax for two of temporary_cabac_pred_enabled_flag and spatial_temporal_cabac_pred_mode. In this case, when cabac_pred_enabled_mode = 0, the time of the CABAC state is not predicted, when 1, the screen is not divided (divided into one) and the time is predicted, and when cabac_pred_enabled_mode = 2 or more, the screen is divided into, for example, cabac_pred_enabled_mode. You may make a time prediction.

When the CABAC time prediction flag temporary_cabac_pred_enabled_flag is 1, the entropy decoding unit 301 decodes the segment time prediction flag slice_temporal_cabac_pred_enabled_flag [i] for each segment. When the tile or WPP is on, the entropy decoding unit 301 decodes the number of entry points (num_entry_point_offsets) and the information indicating the start position of each segment i (entry_point_offset_minus1 [i]), and the number of segments (number of entry points + 1). Decrypt the slice_temporal_cabac_pred_enabled_flag [i]. The first segment of the picture does not include an entry point indicating the position (decoding start position) of each segment in the coded data. That is, when there is data of segment 0, segment 1, and segment 2, the entry point is encoded only in segment 1 and segment 2. The start position of segment i corresponds to entry_point_offset_minus1 [i-1]. On the other hand, the flag of segment i is slice_temporal_cabac_pred_enabled_flag [i]. Other than that, when both the tile and WPP are off, the number of segments is 1, so one segment time prediction flag slice_temporal_cabac_pred_enabled_flag [0] is decoded. As shown in FIG. 10A, when both the tile and WPP are off, num_entry_point_offsets may derive 0, and slice_temporal_cabac_pred_enabled_flag [i] of num_entry_point_offsets + 1 segment may be decoded. In this case, there is no need to branch by the segment time prediction flag slice_temporal_cabac_pred_enabled_flag [i].

As shown in FIG. 10B, slice_temporal_cabac_pred_enabled_flag [i] of only NumCabacPredRegion may be decoded instead of the number of segments. At this time. The NumCabacPredRegion may be set to the number of divisions of the picture, or may be transmitted by, for example, PPS.

FIG. 11 is a diagram showing a syntax structure of slice data. The entropy decoding unit 301 decodes the prediction mode, the intra prediction mode, and the motion vector (merge flag, difference vector, etc.) from the slice data in the coded data in CTU units. In the figure, coding_tree_unit () indicates the coded data in CU units, end_of_subset_one_bit is a flag for whether or not it is the end of the slice, and byte_alignment () is the end of the slice and the coded data length is in byte units (8-bit units). The stuffing data for, end_of_slice_segment_flag is a flag indicating the end of the slice segment. The time prediction storage unit 3014 and the space prediction storage unit 3015 store the CABAC state at the end of the CTU, but this may be performed at the timing after the end_of_subset_one_bit is encoded.

(Structure of Entropy Decoding Unit 301)
The configuration of the entropy decoding unit 301 is shown in FIG. The entropy decoding unit 301 includes a CABAC initialization unit 3011, a CABAC decoding unit 3012, an initialization table 3013, a time prediction storage unit 3014 (time prediction table 3014), and a spatial prediction storage unit 3015 (spatial prediction table 3015). The time prediction storage unit 3014 has CABAC in the internal time prediction table 3014.
Store the state. The stored CABAC state is referred to when decoding a segment of another picture such as a segment of a subsequent picture, and is used for initializing the CABAC state. The space prediction storage unit 3015 stores the CABAC state in the internal space prediction table 3015. The stored CABAC state is referred to when decoding a segment other than the target segment, such as the segment following the target picture, and is used to initialize the CABAC state. The CABAC decoding unit 3012 has a CABAC state inside, and decodes the syntax from the coded data (bit stream) according to the CABAC state.

The entropy decoding unit 301 includes a CABAC initialization unit 3011 that initializes the CABAC state at the beginning of the segment constituting the picture, and the CABAC initialization unit 3011 holds the CABAC state when the CABAC time prediction flag is 1. The CABAC state is initialized using the time prediction table 3014, and when the CABAC time prediction flag is 0, the CABAC state is initialized using the initialization table.

(Initialization of CABAC state)
The entropy decoding unit 301 initializes the CABAC state by using the CABAC initialization unit 3011 at the beginning of the segment of the coded data. The CABAC state is, for example, StateIdx indicating a state of probability in a context unit, MpsVal indicating which of 0 and 1 has a higher probability, and a coefficient StatCoeff. The context is defined for each element of the binary string (a column consisting of 0s and 1s) that constitutes the syntax. CABAC (Context-adaptive binary arithmetic coding) can be efficiently encoded by estimating the probability of being encoded to 0 or 1 for each context and encoding the binary based on the probability. At this time, it is necessary to set the initial value of the probability StateIdx (and the high probability binary Mps), which is called CABAC initialization. The following TableStateIdx, TableMpsVal, and TableStatCoeff are tables composed of StateIdx, MpsVal, and StatCoeff.

(Example of CABAC state initialization operation)
FIG. 13 is a flowchart showing the initialization process in the entropy decoding unit 301 and the entropy coding unit 104. In this example, the case where WPP prediction is not used will be described.

S3011: The entropy decoding unit 301 and the entropy coding unit 104 determine whether or not the segment is the head of the current CTU to be processed. If it is at the beginning of the segment (Y), the process proceeds to S3012. If it is not the beginning of the segment (N), the process ends without initializing the CABAC state.

For example, the determination is made by the following formula.

(((TileId [CtbAddrInTs]! = TileId [CtbAddrRsToTs [CtbAddrInRs-1]])) || (CtbAddrInRs == slice_segment_address)
That is, when any of the following determinations is true, it is determined that the segment is at the beginning.

Tile segment head determination: The tile ID (TileId [CtbAddrInTs]) of the current CTU address (CtbAddrInTs) and the tile ID of the CTU on the left side of the current CTU (TileId [CtbAddrRsToTs [CtbAddrInRs-1]]) are different. Address (CtbAddrInRs) is equal to the slice start address (slice_segment_address).

S3012: When the CABAC time prediction flag temporary_cabac_pred_enable_flag is 1 (Y), the process proceeds to S3013. In the case of N, the process proceeds to S3018.

S3013: When the CABAC time prediction flag temporary_cabac_pred_enable_flag is 1, it is determined whether or not there is a referenceable state in the time prediction table, and if there is a referenceable state, the process proceeds to S3015.

S3015: When there is a referenceable state in the time prediction table 3014, for example, the reference state (TableStateIdxSelect, TableMpsValSelect, TableStatCoeffSelect) is set to the element of the time prediction table (TableStateIdxTemporal [stateType] [stateTid] [statePos], TableMpsValTemporal [stateType] [stateTid] [statePos], TableStatCoeffTemporal [stateType] [stateTid] [statePos]
).

TableStateIdxSelect = TableStateIdxTemporal [stateType] [stateTid] [statePos]
TableMpsValSelect = TableMpsValTemporal [stateType] [stateTid] [statePos]
TableStatCoeffSelect = TableStatCoeffTemporal [stateType] [stateTid] [statePos]
S3017: With reference to the set state (for example, TableStateIdxSelect, TableMpsValSelect, TableStatCoeffSelect), the CABAC initialization unit 3011 initializes the CABAC state of the target segment.

S3018: The CABAC initialization unit 3011 initializes the CABAC state of the target segment using the initialization table 3013.

(Another example of CABAC state initialization operation)
FIG. 14 is another example of a flowchart showing the initialization processing of the entropy decoding unit 301 and the entropy coding unit 104 in the CABAC initialization unit 3011. In this example, the case of using WPP prediction will be described.

S3011: The entropy decoding unit 301 determines whether or not the address of the current CTU to be processed is the head of the segment. If it is at the beginning of the segment (Y), the process proceeds to S3012. If it is not the beginning of the segment (N), the process ends without initializing the CABAC state.

For example, the determination is made by the following formula.

((entropy_coding_sync_enabled_flag == 1) && (CtbAddrInRs% PicWidthInCtbsY == 0)) || (TileId [CtbAddrInTs]! = TileId [CtbAddrRsToTs [CtbAddrInRs-1]]) ||
That is, when any of the following determinations is true, it is determined that the segment is at the beginning.

WPP segment head determination: WPP prediction is on (entropy_coding_sync_enabled_flag == 1) and the current CTU address (CtbAddrInRs) is at the left end of the CTU line (CtbAddrInRs% PicWidthInCtbsY == 0))
Tile segment head determination: The tile ID (TileId [CtbAddrInTs]) of the current CTU address (CtbAddrInTs) and the tile ID of the CTU on the left side of the current CTU (TileId [CtbAddrRsToTs [CtbAddrInRs-1]]) are different. Address (CtbAddrInRs) is equal to the slice start address (slice_segment_address).

S3012: When the CABAC time prediction flag temporary_cabac_pred_enabled_flag is 1 (Y), the process proceeds to S3013. In the case of N, the process proceeds to S3014.

S3013: When the CABAC time prediction flag temporary_cabac_pred_enabled_flag is 1, it is determined whether or not there is a referenceable state in the time prediction table, and if there is a referenceable state, the process proceeds to S3015. In the case of N, the process proceeds to S3014.

S3014: When WPP prediction is on (entropy_coding_sync_enabled_flag == 1) and it is determined whether or not it is other than the first segment of the slice (there is a referenceable state in the spatial prediction table 3015), and there is a referenceable state (Y). Will move to S3016. In the case of N, the process proceeds to S3018.

S3015: When there is a referenceable state in the time prediction table 3014, for example, the reference state (TableStateIdxSelect, TableMpsValSelect, TableStatCoeffSelect) used for CABAC initialization is an element of the time prediction table (TableStateIdxTemporal [stateType] [stateTid]. ] [StatePos], TableMpsValTemporal [stateType] [stateTid] [statePos], TableStatCoeffTemporal [stateType] [stateTid] [statePos]
) Is set. Here, the parameters stateType and stateTid of the target picture and the parameter statePos of the target position are used to select the entry in the time prediction table.

TableStateIdxSelect = TableStateIdxTemporal [stateType] [stateTid] [statePos]
TableMpsValSelect = TableMpsValTemporal [stateType] [stateTid] [statePos]
TableStatCoeffSelect = TableStatCoeffTemporal [stateType] [stateTid] [statePos]
S3016: When WPP prediction is on and other than the first segment of the slice (Y), for example, the spatial prediction table (TableStateIdxWpp, TableMpsValWpp) is set in the reference state (TableStateIdxSelect, TableMpsValSelect, TableStatCoeffSelect) used for CABAC initialization as follows. , TableStatCoeffWpp).

TableStateIdxSelect = TableStateIdxWpp
TableMpsValSelect = TableMpsValWpp
TableStatCoeffSelect = TableStatCoeffWpp
The spatial prediction table is a table that stores the CABAC state of already decoded segments in the same picture.

S3017: With reference to the set state (for example, TableStateIdxSelect, TableMpsValSelect, TableStatCoeffSelect), the CABAC initialization unit 3011 initializes the CABAC state of the target segment.

S3018: The CABAC initialization unit 3011 initializes the CABAC state of the target segment using the initialization table 3013.

(Time prediction judgment for each segment)
In the explanation of FIG. 13, in S3013, when the CABAC time prediction flag temporary_cabac_pred_enabled_flag is 1, the method of performing CABAC initialization using the time prediction table which is the CABAC state saved in the previously processed picture has been described. , The segment time prediction flag, which is a flag for each segment, may be used to switch whether or not to perform time prediction. In this case, when the CABAC time prediction flag temporal_cabac_pred_enabled_flag is 1 and the segment time prediction flag slice_temporal_cabac_pred_enabled_flag [i] of the target segment i is 1, the process proceeds to S3014. That is, when the segment time prediction flag slice_temporal_cabac_pred_enabled_flag [i] of the target segment is 1, the CABAC state is read from the time prediction table, the CABAC state is initialized, and when the segment time prediction flag is 0, the CABAC state is initialized. , The CABAC state is initialized using the initialization table, or the prediction is performed from the spatial prediction table.

(Time prediction judgment for each prediction region)
In the description of FIGS. 13 and 14, in S3013, when the CABAC time prediction flag temporary_cabac_pred_enabled_flag is 1, a method of performing CABAC initialization using the time prediction table 3014 which is the CABAC state saved in the previously processed picture. However, it is also possible to switch whether or not to perform time prediction by using the predicted region time prediction flag, which is a flag for each predicted region. In this case,
When the CABAC time prediction flag temporary_cabac_pred_enabled_flag is 1 and the prediction region time prediction flag slice_temporal_cabac_pred_enabled_flag [i] of the target prediction region is 1, the process proceeds to S3014. That is, when the predicted region time prediction flag slice_temporal_cabac_pred_enabled_flag [i] of the target predicted region is 1, the CABAC state is read from the time prediction table, the CABAC state is initialized, and (the predicted region time prediction flag is 0). In the case of, the CABAC state is initialized using the initialization table, or the prediction is performed from the spatial prediction table).

(How to select the time prediction table)
Hereinafter, a method of selecting a time prediction table (method of selecting an entry) referred from the time prediction storage unit 3014 of the entropy decoding unit 301 and the entropy coding unit 104 will be described. The time prediction table may be referred to in units of temporal layers. Here, the referenced temporal layer is represented by stateTid. Further, the time prediction table may be referred to in slice type units. Here, the slice type to be referenced is expressed by stateType. Further, the time prediction table may be stored or referenced in units of prediction regions indicating positions in the picture. Here, the value indicating the position of the predicted region (the index indicating the position in the referenced picture) is expressed by statePos.

FIG. 19 is a diagram showing the configuration of the time prediction table. In this example, the CABAC state is stored for each temporal layer.

For example, when storing for each temporal layer, it can be referenced by stateTid as follows.

TableStateIdxSelect = TableStateIdxTemporal [stateTid]
TableMpsValSelect = TableMpsValTemporal [stateTid]
TableStatCoeffSelect = TableStatCoeffTemporal [stateTid]
As another configuration, for example, when storing by slice type and temporal layer, it can be referred by stateType and stateTid as follows.

TableStateIdxSelect = TableStateIdxTemporal [stateType] [stateTid]
TableMpsValSelect = TableMpsValTemporal [stateType] [stateTid]
TableStatCoeffSelect = TableStatCoeffTemporal [stateType] [stateTid]
As another configuration, for example, when storing by temporal layer and position, it can be referred by stateTid and statePos as follows.

TableStateIdxSelect = TableStateIdxTemporal [stateTid] [statePos]
TableMpsValSelect = TableMpsValTemporal [stateTid] [statePos]
TableStatCoeffSelect = TableStatCoeffTemporal [stateTid] [statePos]
FIG. 20 is a diagram showing the configuration of a time prediction table. In this example, the CABAC state is stored for each slice type, temporal layer, and position.

For example, when storing by slice type, temporal layer and position, it can be referenced by stateType, stateTid and statePos as follows.

TableStateIdxSelect = TableStateIdxTemporal [stateType] [stateTid] [statePos]
TableMpsValSelect = TableMpsValTemporal [stateType] [stateTid] [statePos]
TableStatCoeffSelect = TableStatCoeffTemporal [stateType] [stateTid] [statePos]
(Time prediction table selection process)
The entropy decoding unit 301 and the entropy coding unit 104 may select an entry in the time prediction table using the slice type stateType, the temporal layer stateTid, and the reference position statePos.

The entropy decoding unit 301 and the entropy coding unit 104 may determine the reference slice type stateType using the slice type sliceType of the target picture.

stateType = sliceType
The entropy decoding unit 301 and the entropy coding unit 104 may determine the temporal layer stateTid of the reference slice by using sliceTid as the temporal layer of the target picture.

stateTid = sliceTid
The entropy decoding unit 301 and the entropy coding unit 104 may determine the reference position statePos by using the position of the target block (CtbAddrX, CtbAddrY).

N = PicHeightInCtbsY / NumCabacPredRegion
statePos = CtbAddrY / N
Here, NumCabacPredRegion is the number of regions when the picture is divided into predicted regions. You may also derive statePos depending on spatial_temporal_cabac_pred_enabled_mode.

statePos = (spatial_temporal_cabac_pred_enabled_mode)? CtbAddrY / N: 0
FIG. 22 is an example of referencing the CABAC state stored in the predicted region unit from the segment of the CTU line unit. The method of dividing the predicted region is the same as in FIG. In particular, when WPP is on, that is, an example of using a segment in units of CTU lines is shown. FIG. 22A is an example of using a picture as one prediction region. When initializing the CABAC state at the head CTU of each segment (CTU line) and using time prediction, refer to the time prediction table with statePos = 0. The time prediction table may be further stored and referred to by the temperal layer or slice type as shown in FIGS. 19 and 20. FIG. 22B is an example in which the prediction region of NumCabacPredRegion (here, NumCabacPredRegion = 4) is used for the picture, and the CABAC state is initialized at the head CTU of each segment (CTU line), and the time is predicted. When using, refer to the time prediction table of statePos = CtbAddrY / N. Where N = PicHeightInCtbsY / NumCabacPredRegion. In the figure, N = 2, and one time prediction table is referred to for every 2 CTU lines.

(Check the availability of the time prediction table)
FIG. 15 is a flowchart showing the process of deriving the availability of the time prediction table referred to in the CABAC initialization. Details of the check shown in S3013.

S30131: Checks whether the corresponding picture in the time prediction table is included in the reference picture list, and if it is included (Y), it shifts to S30134, and if it is not included, it shifts to S30135.

S30134: When the corresponding picture of the time prediction table is included in the reference picture list, the time prediction table is selected and the available flag is set to 1.

S30135: If the corresponding picture in the time prediction table is not included in the reference picture list, the available flag is set to 0.

By checking the reference picture list as in this configuration, it is guaranteed that the picture (corresponding picture) at the time of storage in the time prediction table is the picture included in the reference picture. That is, it guarantees that it does not refer to the CABAC state of pictures that are not in the referenced picture list (ie, non-referenced pictures). This has the effect of ensuring that the segment of the target picture can be decrypted by CABAC by decoding the picture only in the reference picture list.

FIG. 16 is another example of a flowchart showing the process of deriving the availability of the time prediction table. In this example, the temporal layer is further checked.

S30130: The current temporal layer currTid is set in the reference temporal layer stateTid.

S30131: Checks whether the corresponding picture of the time prediction table specified by the reference temporal layer stateTid is included in the reference picture list, and if it is included (Y), it moves to S30134 and is not included. Will move to S30132.

S30132: The reference temporal layer stateTid and the minimum temporal layer 0 are compared, and if the stateTid is larger than 0 (Y), the process proceeds to S30133, and if N, the process proceeds to S30135.

S30133: The reference temporal layer is subtracted by 1 (stateTid = stateTid-1), and the process proceeds to S30131. That is, if the search is started from the current temporal layer currTid and the corresponding picture of the time prediction table specified by a reference temporal layer is not included in the reference picture list, the reference temporal layer is a smaller temporal layer. Set to stateTid and search again.

S30134: When the corresponding picture of the time prediction table is included in the reference picture list, the time prediction table is selected and the available flag is set to 1.

S30135: If the corresponding picture in the time prediction table is not included in the reference picture list, the available flag is set to 0.

For example, it can be realized by the following pseudo code.

for (stateTid = currTid; stateTid> = 0; stateTid = stateTid ―― 1)
{
// check reference picture for the state is available in RPL
poc = TemporalStatePicOrderCount [stateType] [stateTid] [statePos]
if (IsPicIncludedInReferencePictureList (poc))
{
availableFlag = true
break;
}
}
if (stateTid <0)
{
availableFlag = false
}
Above, TemporalStatePicOrderCount [stateType] [stateTid] [statePos] is a picture (corresponding picture) containing the segment of CABAC state stored in the time prediction table specified by the reference slice type stateType, reference temporal layer stateTid, and reference position statePos. It is a POC. TemporalStatePicOrderCount [stateType] [stateTid] [statePos] is set in the storage process described later. IsPicIncludedInReferencePictureList determines whether the specified poc is included in the reference picture list. Here, if the judgment is true, set availableFlag = true.

As in this configuration, by selecting the time prediction table specified by the reference temporal layer stateTid below the current temporal layer currTid, the CABAC state of the segment closest to the current temporal layer currTid can be reused. Play. Signs that are entropy-compressed when the temporal layers are close have properties similar to those of the current segment, resulting in higher performance. Also, if there is no time prediction table specified by the reference temporal layer stateTid of the current temporal layer currTid, it is possible to refer to the time prediction table specified by the reference temporal layer stateTid different from currTid, and more. In some cases, it has the effect of being able to be initialized in a suitable CABAC state.

(Checking the reference picture list and POC)
The availability of the time prediction table for CABAC initialization determines whether the reference picture list contains the corresponding picture in the time prediction table. POC may be used to determine whether or not the corresponding picture is included in this reference picture list. For example, the following process IsPicIncludedInReferencePictureList (poc) determines whether the POC of the picture (corresponding picture) containing the CABAC state segment stored in the specified time prediction table exists in the reference picture list. The determination process of this IsPicIncludedInReferencePictureList (poc) may be the following pseudo code.

for (refIdx = 0; refIdx <num_ref_idx_l0_active_minus1 + 1; refIdx ++)
{
if (POC of RefPicListL0 [refIdx] == poc)
{
return true;
}
}
if (sliceType == B_SLICE)
{
for (refIdx = 0; refIdx <num_ref_idx_l1_active_minus1 + 1; refIdx ++)
{
if (POC of RefPicListL1 [refIdx] == poc)
{
return true;
}
}
}
return false
In the above, poc uses the POC of the picture (corresponding picture) containing the segment of the CABAC state stored in the specified time prediction table. num_ref_idx_l0_active_minus1 + 1
Is the number of elements in the L0 reference picture list RefPicList L0, and num_ref_idx_l1_active_minus1 + 1 is the number of elements in the L1 reference picture list RefPicList L1. First, the L0 reference picture list RefPicListL0 is searched in order from 0, it is determined whether the POC (POC of RefPicListL0 [refIdx]) of the element is equal to the search symmetric poc, and then the L1 reference picture list RefPicList L1 is searched in order from 0. .. If a picture with the same POC is found in the reference picture, it is set to available (true), and otherwise it is determined to be unusable (false).

(Operation of CABAC state storage processing)
FIG. 17 is a flowchart showing the storage process of the CABAC state in the entropy decoding unit 301 and the entropy coding unit 104.
C4001: It is determined whether the last syntax of the CTU is decoded and encoded (for example, the end_of_slice_segment_flag and end_of_subset_one_bit are decoded and encoded). In the last case of CTU (Y), the process proceeds to S4002, and in other cases (N), the processing is terminated without storing the CABAC state.
C4002: When the CABAC time prediction flag == 1 (Y), the process shifts to C4003. In other cases (N), the process ends.
C4003: The CABAC state at a predetermined position is stored in the time prediction table.

FIG. 18 is another example of a flowchart showing the storage process of the CABAC state in the entropy decoding unit 301 and the entropy coding unit 104.
C4001: It is determined whether the last syntax of the CTU is decoded and encoded. In the last case of CTU (Y), the process proceeds to S4002, and in other cases (N), the processing is terminated without storing the CABAC state.
C4002: When the CABAC time prediction flag == 1 and a predetermined position in the prediction region (Y), the process shifts to C4003. In other cases (N), the process proceeds to C4004. The predetermined position may be the last CTU of the predicted region. The storage position is not limited to the last CTU of the predicted region, and may be a predetermined position (for example, the center position) in the predicted region.
C4003: The CABAC state at a predetermined position is stored in the time prediction table. The determination formulas for the predetermined positions in FIGS. 17 and 18 may be, for example, as follows.

(CtbAddrX == (PicWidthInCtbsY / 2) && CtbAddrY == (PicHeightInCtbsY / 2)
The above shows the process of storing the CABAC state in the time prediction table when the X coordinate and Y coordinate (CtbAddrX, CtbAddrY) of the CTU address are the screen center (PicWidthInCtbsY / 2, PicHeightInCtbsY / 2).

As another configuration, the determination process when storing according to the CABAC space-time prediction mode spatial_temporal_cabac_pred_mode is shown. In the following, as shown in FIG. 21A, when the CABAC space-time prediction mode is 0, the center of the screen may be used.
(spatial_temporal_cabac_pred_mode == 0 && (CtbAddrX == (PicWidthInCtbsY / 2) && CtbAddrY == (PicHeightInCtbsY / 2))
Further, the present invention is not limited to the center of the screen, and may be the right edge near the center of the screen.
(spatial_temporal_cabac_pred_mode == 0 && (CtbAddrX == (PicWidthInCtbsY-1) && CtbAddrY == (PicHeightInCtbsY / 2))
Note that PicWidthInCtbsY is the picture width converted by the CTU size (the number of CTUs in the horizontal direction). On the contrary, when the CABAC space-time prediction mode is 1, when the screen is divided into NumCabacPredRegion prediction regions as shown in FIG. 21 (b), the X coordinate is the final CTU line of the NumCabacPredRegionth prediction region. May be the right edge of the screen.
(spatial_temporal_cabac_pred_mode == 1 && (CtbAddrX == (PicWidthInCtbsY-1) && (CtbAddrY% N) == (N-1))
Furthermore, the CABAC state may be stored even when it is at the lower right of the screen. That is, it may be added to the condition for storing that it is at the lower right of the screen.
(spatial_temporal_cabac_pred_mode == 1 && ((CtbAddrX == (PicWidthInCtbsY-1) && (CtbAddrY% N) == (N-1))) || CtbAddrRs == NumCtuInPic-1)
Here, NumctuInPic is the number of CTUs in the picture.
The storage destination may be as follows.

TableStateIdxTemporal [stateType] [stateTid] [statePos]
TableMpsValTemporal [stateType] [stateTid] [statePos]
TableStatCoeffTemporal [stateType] [stateTid] [statePos]
Here, the stateType, stateTid, and statePos indicating the storage destination may be set as follows.

stateType = sliceType of the current target block
stateTid = Temporal layer of the picture containing the current target block
statePos = Index indicating the position of the current target block In addition, the POC of the current picture may be stored in order to identify the picture (corresponding picture) of the segment that stores the CABAC state.

TemporalStatePicOrderCount [stateType] [stateTid] [statePos] = PicOrderCntVal
Note that TemporalStatePicOrderCount [stateType] [stateTid] [statePos] may be initialized to a value (for example, -1) that is not available at all randomly accessible pictures such as IDR pictures.
C4004: When WPP is enabled (entropy_coding_sync_enabled_flag == 1) and the segment is in a predetermined position (Y), the process proceeds to C4003. In other cases (N), the process ends.
C4005: The CABAC state at a predetermined position is stored in the spatial prediction table. The determination formula for a predetermined position may be, for example, the following formula.

(entropy_coding_sync_enabled_flag == 1) && ((CtbAddrInRs% PicWidthInCtbsY == 1) || (CtbAddrInRs> 1 && TileId [CtbAddrInTs]! = TileId [CtbAddrRsToTs [CtbAddrInRs-2]))
Here, CtbAddrInRs is the CTU address in the raster scan screen, PicWidthInCtbsY is the screen width in CTU units, TileId is the tile ID, CtbAddrInTs is the CTU address in the tile, and CtbAddrRsToTs is the raster scan CTU address CtbAddrInRs from the CTU address in the tile. It is a table for deriving.

In the above, (CtbAddrInRs% PicWidthInCtbsY == 1) is the case where the X coordinate of the CTU address, which is the address of the CTU unit, is 1 (in the case of the second CTU from the left end). (CtbAddrInRs> 1 && TileId [CtbAddrInTs]! = TileId [CtbAddrRsToTs [CtbAddrInRs-2]]) is the second CTU from the left end in the tile (CtbAddrInRs is larger than 1 and the tile ID of the CTU including the target block). Is different from the tile ID of the CTU two before the target CTU.

(Predetermined position to store)
As described in the operation step of C4003, the CABAC state at a predetermined position is stored in the time prediction table. Store when the coordinates of the CTU are equal to a predetermined position. When there are a plurality of predetermined positions in the screen, the CABAC state is stored in the reference position statePos of the prediction table each time the CTU at the predetermined position is decoded. Here, the predetermined position, that is, the storage position of the CABAC state will be described again. As described above, FIG. 21A shows a case where the center of the screen is set as the storage position as follows. Store in the time prediction table with statePos = 0.

(CtbAddrX == (PicWidthInCtbsY / 2) && CtbAddrY == (PicHeightInCtbsY / 2)
statePos = 0
In FIG. 21 (b), the CTU at the lower right of the predicted region may be a predetermined position used for storing the CABAC state. Here is an example of vertically dividing the screen into NumCabacPredRegion prediction regions.

(CtbAddrX == (PicWidthInCtbsY-1) && (CtbAddrY% N) == (N-1))
statePos = CtbAddrY / N
Here, N = PicHeightInCtbsY / NumCabacPredRegion, which is the height of the predicted region derived by dividing the screen height (PicHeightInCtbsY) by the number of divisions NumCabacPredRegion. Here, the height is expressed in CTU units. In the case of division, an appropriate round offset may be added, and N = (PicHeightInCtbsY + NumCabacPredRegion-1) / NumCabacPredRegion) or (PicHeightInCtbsY + NumCabacPredRegion / 2) / NumCabacPredRegion) may be used.

FIG. 21C is an example of storing the CABAC state with the X coordinate as the right end of the width of the predicted region and the position of 1/2 of the height of the predicted region as a predetermined position. This position will be referred to as the right end center (X right end Y center, horizontal right end vertical center).

(CtbAddrX == (PicWidthInCtbs-1) && CtbAddrY == (PicHeightInCtbsY / 2)
statePos = 0
FIG. 24A shows an example in which the CABAC state is stored by setting a predetermined position to be stored in the lower right of the screen when the predicted region is one picture. The following determination formula is used to determine the predetermined position.

(CtbAddrX == (PicWidthInCtbs-1) && CtbAddrY == (PicHeightInCtbsY-1)
statePos = 0
FIG. 24B shows an example in which the CABAC state is stored by setting a predetermined position to be stored in the case where the prediction region is one picture at the center of the right end (X center of Y right end). The following determination formula is used to determine the predetermined position.

(CtbAddrX == (PicWidthInCtbs-1) && CtbAddrY == (PicHeightInCtbsY / 2)
statePos = 0
FIG. 24C shows the CABAC state by setting a predetermined position at the lower right of the predicted region when the predicted region vertically divides the picture into NumCabacPredRegions (when dividing by the predicted region of height N). An example is shown. The following determination formula is used to determine the predetermined position.

(CtbAddrX == PicWidthInCtbs-1 && ((! LastPredRegionInPic && ((CtbAddrY% N) == N-1)) || (lastPredRegionInPic && (CtbAddrY == PicHeightInCtbsY-1))))
statePos = CtbAddrY / N
Here, lastPredRegionInPic is a value indicating whether or not the target CTU is in the last predicted region of the screen. Here, the X coordinate CtbAddrX is the rightmost coordinate (PicWidthInCtbs-1), and the CTU coordinate ((CtbAddrY% N)) is the last CTU line in the predicted region except for the last predicted region (! LastPredRegionInPic) (N). -1) is judged. In the last predicted region (lastPredRegionInPic), it is determined whether it matches the CTU line at the end of the screen (CtbAddrY == PicHeightInCtbsY-1).

Note that lastPredRegionInPic is obtained by the following derivation formula depending on whether the reference position statePos = CtbAddrY / N matches the reference position ((PicHeightInCtbsY -1) / N) of the last predicted region.

lastPredRegionInPic = ((PicHeightInCtbsY -1) / N) == (CtbAddrY / N)
N = PicHeightInCtbsY / NumCabacPredRegion
or
(PicHeightInCtbsY + NumCabacPredRegion ―― 1) / NumCabacPredRegion
FIG. 24D shows an example in which the predicted region divides the picture vertically into N pieces, a predetermined position is set in the center of the right end of the predicted region, and the CABAC state is stored. The following determination formula is used to determine the predetermined position.

(CtbAddrX == PicWidthInCtbs-1) && (CtbAddrY% N) == N / 2)
statePos = CtbAddrY / N
In the above, it is determined whether the CTU coordinates ((CtbAddrY% N)) in the predicted region are the CTU line in the center of the predicted region (N / 2).

Further, the following determination formula may be used in consideration of the possibility that the position of the central CTU line (N / 2) in the predicted region does not exist when the position exceeds the lower end of the screen.

(CtbAddrX == PicWidthInCtbs-1 && ((! LastPredRegionInPic && ((CtbAddrY% N) == N / 2)) || (lastPredRegionInPic && ((CtbAddrY% N) == N2)))
For N2, set N / 2 for N2 if the CTU line (N / 2) does not exceed the screen edge, otherwise set the screen edge line ((PicHeightInCtbs -1)% N). It may be used, and it is derived as follows.

N2 = (PicHeightInCtbs ―― 1)% N <N / 2? (PicHeightInCtbs ―― 1)% N: N / 2
FIG. 24 (e) shows an example in which when the predicted region is rectangular like a tile, a predetermined position is set at the lower right of the predicted region and the CABAC state is stored. The determination of the predetermined position is made by using the tile width -1 and the tile height -1 in the CTU unit.

FIG. 24 (f) shows an example in which when the predicted region is rectangular like a tile, a predetermined position is set in the center of the right end of the predicted region and the CABAC state is stored. The determination of the predetermined position is made by using the tile width -1 and the tile height / 2 in the CTU unit.

In the above configuration, high coding efficiency can be realized by storing the CABAC state at the lower right position of the picture or tile.

In the above configuration, high coding efficiency can be realized by storing the CABAC state at the position of the center of the right end of the picture or tile.

(CABAC state storage position considering screen boundaries)
The width and height of the screen is not always an integral multiple of the size of the CTU. For example, when the screen size is 1920x1080 and the CTU size is 128x128, the width of the screen is an integral multiple (15 times), but the height of the screen is a non-integer multiple.

1920 / 128.0 = 15.0
1080 / 128.0 = 8.4375
In the case of non-integer multiples, the moving image coding device and the moving image decoding device round up the decimals and process them as if they are an integer number of CTUs. That is, it processes a 15x9 CTU.

In addition, the moving image decoder that outputs a part of the screen (cropping window area) outputs only the area of the encoded image excluding the left, right, top, and bottom offsets conf_win_left_offset, conf_win_right_offset, conf_win_top_offset, and conf_win_bottom_offset. do. for example,
SubWidthC * conf_win_left_offset to pic_width_in_luma_samples? (SubWidthC * conf_win_right_offset + 1) in the horizontal direction and SubHeightC * conf_win_top_offset to pic_height_in_luma_samples? (SubHeightC * conf_win_bottom_offset) in the vertical direction
Is output.

Areas for rounding up to an integral multiple and areas that are not output by cropping are also encoded, but for example, they are encoded in gray (Y = Cb = Cr = 128) or black areas, so many screens are displayed. Often different from the features that occupy the part of. Thus, at the right edge of the screen when the width of the screen is not an integral multiple of the CTU, or at the bottom edge of the screen when the height is not an integral multiple of the CTU, the syntax distribution for division, prediction, and residual is normal. It does not reflect the case of the image. Therefore, it is not appropriate to use the CABAC state after encoding and decoding those areas as the CABAC state of subsequent pictures. Hereinafter, when encoding and decoding a picture having a screen size that is a non-integer multiple of the CTU, a predetermined position for storing the CABAC state in the time prediction table will be described.

As an offset when deriving a predetermined position to be stored, 2 is set when the width of the screen is not an integral multiple of CTU, and 1 is set otherwise.

offX = pic_width_in_luma_samples <CtuSize * PicWidthInCtbsY? 2: 1
Further, when the width of the CTU unit of the screen is 1, the offset cannot be set to 2, so it may be derived as follows.

offX = (PicWidthInCtbs> 1) && (pic_width_in_luma_samples <CtuSize * PicWidthInCtbsY)? 2: 1
The vertical offset offY used for deriving the predetermined position to be stored may be calculated in the same manner.

offY = pic_height_in_luma_samples <CtuSize * PicHeightInCtbsY? 2: 1
offY = (PicHeightInCtbs> 1) && (pic_height_in_luma_samples <CtuSize * PicHeightInCtbsY)? 2: 1
In addition to whether or not it is an integral multiple of the CTU, an offset may be set so as to avoid the cropping window, and a predetermined position for storage may be derived.

In this case, the size of the crop offset may be divided by the CTU size to derive the offset. A shift operation may be used.

offX = (SubWidthC * conf_win_right_offset) / CtuSize
= (SubWidthC * conf_win_right_offset) >> log2 (CtuSize)
Furthermore, it is derived from the width of the non-display area obtained by subtracting the actual screen width (pic_width_in_luma_samples-(SubWidthC * conf_win_right_offset) considering the crop offset) from the screen width (CtuSize * PicWidthInCtbsY) covered by the CTU, and the CTU size CtuSize. You may.

offX = (CtuSize * PicWidthInCtbsY-(pic_width_in_luma_samples --SubWidthC * conf_win_right_offset) + (CtuSize-1)) / CtuSize
= (CtuSize * PicWidthInCtbsY-(pic_height_in_luma_samples --SubWidthC * conf_win_right_offset) + (CtuSize-- 1)) >> log2 (CtuSize)
Of course, the vertical offset offY used for deriving the predetermined position to be stored may be calculated in the same manner.

offY = (CtuSize * PicHeightInCtbsY-(pic_height_in_luma_samples --SubWidthC *
conf_win_bottom_offset) + (CtuSize -1)) / CtuSize
offY = (CtuSize * PicHeightInCtbsY-(pic_height_in_luma_samples --SubWidthC *
conf_win_bottom_offset) + (CtuSize -1)) >> log2 (CtuSize)
FIG. 25A shows an example in which the CABAC state is stored by setting a predetermined position to be stored in the lower right of the screen when the predicted region is one picture. The following determination formula is used to determine the predetermined position.

offX = pic_width_in_luma_samples <CtuSize * PicWidthInCtbsY? 2: 1
(CtbAddrX == (PicWidthInCtbs-offX) && CtbAddrY == (PicHeightInCtbsY / 2)
statePos = 0
The following determination formula may be used.

offX = pic_width_in_luma_samples <CtuSize * PicWidthInCtbsY? 2: 1
offY = pic_height_in_luma_samples <CtuSize * PicHeightInCtbsY? 2: 1
(CtbAddrX == (PicWidthInCtbs-offX) && CtbAddrY == (PicHeightInCtbsY-offY)
statePos = 0
FIG. 25B shows an example in which the CABAC state is stored by setting a predetermined position to be stored in the case where the predicted region is one picture at the center of the right end (X center of Y right end). The following determination formula is used to determine the predetermined position.

offX = pic_width_in_luma_samples <CtuSize * PicWidthInCtbsY? 2: 1
(CtbAddrX == (PicWidthInCtbs-offX) && CtbAddrY == (PicHeightInCtbsY / 2)
statePos = 0
FIG. 25C shows a case where the predicted region vertically divides the picture into NumCabacPredRegions (when the predicted region is divided by the height N predicted region), a predetermined position is set at the lower right of the predicted region, and the CABAC state is stored. An example is shown. The following determination formula is used to determine the predetermined position.

(CtbAddrX == PicWidthInCtbs-offX && ((! LastPredRegionInPic && ((CtbAddrY% N) ==)
N-1)) || (lastPredRegionInPic && CtbAddrY == PicHeightInCtbsY-offY)));
statePos = CtbAddrY / N
Here, lastPredRegionInPic is a value indicating whether or not the target CTU is in the last predicted region of the screen. The X coordinate is the rightmost coordinate (PicWidthInCtbs-offX) considering non-integer multiples. Regarding the Y coordinate, it is determined whether the CTU coordinate ((CtbAddrY% N)) in the predicted region is the last CTU line (N-1) except for the last predicted region. Also, in the last predicted region, it is determined whether it is the lower end of the screen (PicWidthInCtbs-offY) considering non-integer multiples.

Further, it may be derived as follows.

offX = (PicWidthInCtbs> 1) && (pic_width_in_luma_samples) <CtuSize * PicWidthInCtbsY? 2: 1
offY = (PicHeightInCtbs> 1) && (pic_height_in_luma_samples) <CtuSize * PicHeightInCtbsY? 2: 1
FIG. 25 (d) shows the case where the predicted region vertically divides the picture into NumCabacPredRegions (when the predicted region is divided by the height N predicted region), the predetermined position is set in the lower right center of the predicted region and the CABAC state is stored. Here is an example of how to do it. The following determination formula is used to determine the predetermined position.

(CtbAddrX == PicWidthInCtbs-offX) && (CtbAddrY% N) == N / 2)
statePos = CtbAddrY / N
In the above, it is determined whether the CTU coordinates ((CtbAddrY% N)) in the predicted region are the central CTU line (N / 2).

Further, the following determination formula may be used in consideration of the possibility that the position of the central CTU line (N / 2) in the predicted region exceeds the lower end of the screen and does not exist.

(CtbAddrX == PicWidthInCtbs-offX && ((! LastPredRegionInPic && ((CtbAddrY% N) ==)
N / 2)) || (lastPredRegionInPic && ((CtbAddrY% N) == N2))
N2 = (PicHeightInCtbs-1)% N <N / 2? (PicHeightInCtbs-1)% N: N / 2
FIG. 25E shows an example in which the predicted region is rectangular like a tile, a predetermined position is set at the lower right of the predicted region, and the CABAC state is stored. When the tile width is an integral multiple of the CTU, the tile width -1 in the CTU unit is used for the determination of the predetermined position, and in other cases, the tile width-2 in the CTU unit is used. Further, when the tile height is an integral multiple of the CTU, the tile height -1 in the CTU unit is used, and in other cases, the tile height -2 in the CTU unit is used for determination.

FIG. 25 (f) shows an example in which the predicted region is rectangular like a tile, a predetermined position is set in the center of the right end of the predicted region, and the CABAC state is stored. When the tile width is an integral multiple of the CTU, the tile width -1 in the CTU unit is used for the determination of the predetermined position, and in other cases, the tile width-2 in the CTU unit is used. Further, when the tile height is an integral multiple of the CTU, the tile height / 2 in the CTU unit is used for determination.

According to the above configuration, the characteristics are different from the normal display area, such as the padding area expanded to fit a part of the screen or tile to an integral multiple of the CTU, and the area that is cropped at the time of output and is not actually displayed. Avoid storing the CABAC state of the area. Then, the CABAC state in the normal display area is stored and used in subsequent pictures. As a result, the prediction accuracy of the CABAC state is improved and the coding efficiency is improved.

(Storage position that fixedly considers the screen boundary)
FIG. 26 is an example in which it is not determined whether the picture or tile is an integral multiple of the CTU, and the positions of the screen width −2 and the screen height − 2 are always used. In this example, not using the position of the CTU boundary has the effect of predicting a suitable CABAC state even when the size of the picture or tile is not a multiple of the CTU.

FIG. 26A shows an example in which the predicted region is one picture and a predetermined storage position is set at the lower right of the screen. The following determination formula is used to determine the predetermined position.

(CtbAddrX == (PicWidthInCtbs-2) && CtbAddrY == (PicHeightInCtbsY-2)
statePos = 0
FIG. 26B shows an example in which the CABAC state is stored by setting a predetermined position to be stored in the case where the predicted region is one picture at the center of the right end (X center of Y right end). The following determination formula is used to determine the predetermined position.

(CtbAddrX == (PicWidthInCtbs-2) && CtbAddrY == (PicHeightInCtbsY / 2)
statePos = 0
FIG. 26 (c) shows a case where the predicted region vertically divides the picture into NumCabacPredRegions (when the predicted region is divided by the height N predicted region), a predetermined position is set at the lower right of the predicted region, and the CABAC state is stored. An example is shown. The following determination formula is used to determine the predetermined position.

(CtbAddrX == PicWidthInCtbs-2 && ((! LastPredRegionInPic && ((CtbAddrY% N) == N-1)) || (lastPredRegionInPic && CtbAddrY == PicHeightInCtbsY-2)));
statePos = CtbAddrY / N
FIG. 26 (d) shows the case where the predicted region vertically divides the picture into NumCabacPredRegions (when the predicted region is divided by the predicted region of height N), the predetermined position is set in the lower right center of the predicted region and the CABAC state is stored. Here is an example of how to do it. The following determination formula is used to determine the predetermined position.

(CtbAddrX == PicWidthInCtbs-2) && (CtbAddrY% N) == N / 2)
statePos = CtbAddrY / N
Alternatively, the following determination formula may be used.

(CtbAddrX == PicWidthInCtbs-2 && ((! LastPredRegionInPic && ((CtbAddrY% N) == N / 2)) || (lastPredRegionInPic && ((CtbAddrY% N) == N2)));
N2 = (PicHeightInCtbs ―― 1)% N <N / 2? (PicHeightInCtbs ―― 1)% N: N / 2;
FIG. 26E shows an example in which the predicted region is rectangular like a tile, a predetermined position is set at the lower right of the predicted region, and the CABAC state is stored. The determination of the predetermined position is made by using the tile width-2 in the CTU unit and the tile height-2 in the CTU unit.

FIG. 25 (f) shows an example in which the predicted region is rectangular like a tile, a predetermined position is set in the center of the right end of the predicted region, and the CABAC state is stored. The determination of the predetermined position is made by using the tile width-2 in the CTU unit and the tile height / 2 in the CTU unit.

According to the above configuration, the CABAC state at the position considering in advance the padding area expanded to fit a part of the screen or tile to an integral multiple of the CTU, the area cropped at the time of output and not actually displayed, etc. Store it and use it in subsequent pictures. As a result, the prediction accuracy of the CABAC state is improved and the coding efficiency is improved.

(Setting of storage position based on WPP usage)
FIG. 27 is another diagram illustrating the storage position of the CABAC state according to the use of WPP (CTU line unit is a segment). When the CTU line unit is a segment, the CABAC state is initialized at the left end of the CTU line, so that the CABAC state is not sufficient at the center of the segment and is often a suitable CABAC state at the right end of the segment. 27 (a) shows a case where the entire screen is a segment, and FIG. 27 (b) shows a case where a unit obtained by dividing the screen into CTU lines is used as a segment, such as when WPP is used. Further, (e) is a case where the screen is divided into tiles to form segments, and (f) is a case where the screen is further divided into tiles and the CTU line in the tiles is further divided into segments.

As shown in FIGS. 27 (a) and 27 (e), in the present embodiment, when WPP is not used (when the CTU line is not a segment), the center of the screen or tile is set as a predetermined storage position. for example
(CtbAddrX == PicWidthInCtbs / 2) && (CtbAddrY% N) == N / 2)
As shown in FIGS. 27 (b) and 27 (f), when WPP is used (when the CTU line is a segment), the right end of the screen or tile is set as a predetermined storage position. for example
(CtbAddrX == PicWidthInCtbs-1) && (CtbAddrY% N) == N / 2)
FIG. 28 is a flowchart showing the above processing.

S301: It is determined whether or not the CTU line is a segment, and if it is Y, the process shifts to S302, and the CABC state is stored at the right end of the segment. If it is N, it shifts to S303 and stores the CABC state at the center of the segment.

Further, the determination may be made using the size of the screen. That is, if the screen size or tile size (for example, width) is small, the right end may be set, and otherwise, the center may be set as a predetermined storage position.

According to the above configuration, the entropy decoding unit 301 and the entropy coding unit 104 use the right end of the segment as the storage position when the CTU line is a segment, and the center of the segment as the storage position in other cases. It is characterized by the fact that. When the CTU line is used as a segment, the CABAC state of the CTU on the right side is used for prediction as much as possible to improve the prediction accuracy of the CABAC state and the coding efficiency.

(Configuration of moving image coding device)
Next, the configuration of the moving image coding device 11 according to the present embodiment will be described. 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 predicted image generation unit 101 has the same operation as the predicted image generation unit 308 described above, and the description thereof will be omitted.

The subtraction unit 102 generates a prediction error by subtracting 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. 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 for 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 inverse quantization / inverse transformation unit 105 is the same as the inverse quantization / inverse transformation unit 311 (FIG. 7) in the moving image decoding device 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. Coding parameters include, for example, reference picture index refIdxLX, prediction vector index mvp_LX_idx, difference vector mvdLX, prediction mode predMode, and merge index merge_idx.

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

(Structure of Entropy Coding Unit 104)
FIG. 23 shows the configuration of the entropy coding unit 104. The entropy coding unit 301 includes a CABAC initialization unit 3011, a CABAC coding unit 10412, an initialization table 3013, a time prediction storage unit 3014 (time prediction table 3014), and a spatial prediction storage unit 3015 (spatial prediction table 3015). The time prediction storage unit 3014 stores the CABAC state in the internal time prediction table 3014. The stored CABAC state is referenced when encoding a segment of another picture such as a segment of a subsequent picture and is used for initializing the CABAC state. The space prediction storage unit 3015 stores the CABAC state in the internal space prediction table 3015. The stored CABAC state is referred to when encoding segments other than the target segment, such as the segment following the target picture, and is used to initialize the CABAC state. The CABAC coding unit 10412 has a CABAC state inside, encodes a syntax according to the CABAC state, and mainly uses coded data (bitstream).

Similar to the entropy decoding unit 301, the entropy coding unit 104 stores the CABAC state in the time prediction table for each prediction region. In addition, the CABAC status is read and CABAC initialization is performed by referring to the time prediction table stored in each prediction region. Since the detailed operation has already been described in the entropy decoding unit 301, the detailed operation will be omitted.

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 above configuration is an image coding device that encodes variable-length coded coded data, includes an entropy coding unit that encodes a CABAC time prediction flag, and has a CABAC state at the beginning of a segment that constitutes a picture. The CABAC initialization unit 3011 is provided, and when the CABAC time prediction flag is 1, the CABAC initialization unit 3011 initializes the CABAC state using the time prediction table 3014 that holds the CABAC state. When the CABAC time prediction flag is 0, the CABAC state is initialized using the initialization table.

Hereinafter, the schematic operation of each module will be described. 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, TU split flag split_transform_flag, CU residual flag cbf_cb, cbf_cr, cbf_luma 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 contains a prediction error.

The CT information coding unit 1111 and the CU coding unit 1112 have inter-prediction parameters (prediction mode predMode, merge flag merge_flag, merge index merge_idx, inter-prediction identifier inter_pred_idc, reference picture index refIdxLX, prediction vector index mvp_LX_idx, difference vector mvdLX), Syntax elements such as intra prediction parameters (prev_intra_luma_pred_flag, mpm_idx, rem_selected_mode_flag, rem_selected_mode, rem_non_selected_mode,) and quantization conversion coefficients are supplied to the entropy coding unit 104.

The addition unit 106 adds the pixel value of the predicted 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 to generate a decoded image. 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 be configured with only a deblocking filter, for example.

The prediction parameter memory 108 stores the prediction parameters generated by the coding parameter determination unit 110 at positions predetermined 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, a prediction parameter, or a parameter to be coded generated in connection with the prediction parameter. 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 RD cost value is, for example, the sum of the code amount and the value obtained by multiplying the squared error by the coefficient λ. The code amount is the amount of information of the coded stream Te obtained by entropy-coding the quantization error and the coding parameter. The square error is the sum of squares of the prediction error calculated by the subtraction unit 102. The coefficient λ is a real number greater than the preset zero. 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, a 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 a computer system and executed. The "computer system" referred to here is a computer system built in either the moving image coding device 11 or 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, and a storage device such as a hard disk built in a computer system. Further, a "computer-readable recording medium" is a medium that dynamically holds a program for a short 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 for realizing a part of the above-mentioned functions, and may be further realized 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 made 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 the LSI, and may be realized by a dedicated circuit or a general-purpose processor. Further, when an integrated circuit technology that replaces LSI appears due to the progress of semiconductor technology, an integrated circuit based on the 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 for transmitting, receiving, recording, and reproducing moving images. The moving image may be a natural moving image captured by a camera or the like, or an artificial moving image (CG) generated by a computer or the like.
And GUI included).

First, it will be described with reference to FIG. 2 that the above-mentioned moving image coding device 11 and moving image decoding device 31 can be used for transmission and reception of moving images.

FIG. 2A is 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 coded data by coding a moving image, and a modulation signal by modulating a carrier 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 video input terminal PROD_A6 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.

FIG. 2B is 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 demodulation unit PROD_B2 that obtains coded data by demodulating the modulated signal received by the receiving unit PROD_B1, and a demodulation unit PROD_B2. It includes a decoding unit PROD_B3 that obtains a moving image by decoding the coded data. The moving image decoding device 31 described above is used as the decoding unit PROD_B3.

The receiving device PROD_B has 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 as a supply destination of the moving image output by the decoding unit PROD_B3. It may also have PROD_B6. In the figure, the configuration in which the receiving device PROD_B includes all of them 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). It may refer 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 a modulated signal 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 a modulated signal by wired broadcasting.

In addition, servers (workstations, etc.) / clients (television receivers, personal computers, smartphones, etc.) such as 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 coded 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 above-mentioned moving image coding device 11 and moving image decoding device 31 can be used for recording and reproducing moving images.

FIG. 3A is a block diagram showing the configuration of the recording device PROD_C equipped with the above-mentioned moving image coding device 11. 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 connected to the recording device PROD_C, such as a card or USB (Universal Serial Bus) flash memory, and (3) DVD (Digital Versatile Disc: registered trademark) or BD (Blu-ray). It may be loaded into 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. The unit PROD_C5 and the 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 may receive coded data encoded by a transmission coding method different from the recording coding method. It may be something to do. In the latter case, a transmission decoding unit (not shown) that decodes the coded data encoded by the transmission coding method may be interposed 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, an HDD (Hard Disk Drive) recorder, and the like (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 the moving image), a personal computer (in this case, the receiving unit PROD_C5 or the image processing unit C6 is the main source of the moving image), a smartphone (this). If the camera PROD_C3
Alternatively, the receiver PROD_C5 is the main source of moving images) is also an example of such a recording device PROD_C.

FIG. 3B is a block 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 reproduction 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) SD memory card, USB flash memory, or the like. 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 a 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 reproduction 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 transmission 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), 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 by 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 an instruction 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 programs and various data. Then, an object of the embodiment of the present invention is a recording in which the program code (execution format program, intermediate code program, source program) of the control program of each of the above-mentioned devices, which is software for realizing the above-mentioned function, is readablely recorded 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 discs such as floppy (registered trademark) discs / hard disks, and CD-ROMs (Compact Disc Read-Only Memory) / MO discs (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 memory 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 ray 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 can also be used 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 Image decoder
301 Entropy Decoding Unit
302 Parameter decoder
3020 Header decoder
303 Inter-prediction parameter decoder
304 Intra Prediction Parameter Decoder
308 Predictive image generator
309 Inter-prediction image generator
310 Intra prediction image generator
311 Inverse quantization / inverse transformation
312 Addition part
11 Image coding device
101 Predictive image generator
102 Subtractor
103 Conversion / Quantization Department
104 Entropy coding unit
105 Inverse quantization / inverse transformation
107 Loop filter
110 Coding parameter determination unit
111 Parameter coder
112 Inter-prediction parameter coding unit
113 Intra prediction parameter coding unit
1110 Header coding part
1111 CT information coding unit
1112 CU coding unit (prediction mode coding unit)
1114 TU encoding unit 301 entropy decoding unit 3011 CABAC initialization unit 3012 CABAC decoding unit 3013 initialization table 3014 time prediction storage unit (time prediction table)
3015 Spatial prediction storage unit (spatial prediction table)
10412 CABAC coding unit

Claims (11)

An image decoding device that decodes variable-length coded coded data, has an entropy decoding unit that decodes the CABAC time prediction flag, and has a CABAC initialization unit that initializes the CABAC state at the beginning of the segment that constitutes the picture. When the CABAC time prediction flag is 1, the CABAC initialization unit initializes the CABAC state using the time prediction table that holds the CABAC state, and when the CABAC time prediction flag is 0, the initial CABAC state is initialized. An image decoding device characterized in that the CABAC state is initialized using a conversion table. The entropy decoding unit further decodes the CABAC space-time prediction mode, and the CABAC initialization unit is the position in the screen at the head of the segment when the CABAC space-time prediction mode is 1 (screen division mode). The image decoding apparatus according to claim 1, wherein the CABAC state is read from the time prediction table and the CABAC state is initialized by using the above-mentioned time prediction table. The image decoding device further decodes the CABAC space-time prediction mode, and when the number of screen divisions indicated by the CABAC space-time prediction mode is 2 or more, the time prediction is performed using the position in the screen at the head of the segment. The image decoding apparatus according to claim 1, wherein the CABAC state is read from a table and the CABAC state is initialized. The image decoding device further decodes the segment prediction flag for each segment, and when the segment time prediction flag is 1, reads the CABAC state from the time prediction table and initializes the CABAC state. , (When the segment time prediction flag is 0, the CABAC state is initialized using the initialization table, or prediction is performed from the spatial prediction table). Decoding device. The image decoding device further decodes the predicted region time prediction flag for each predicted region, and when the predicted region time prediction flag is 1, reads the CABAC state from the time prediction table to obtain the CABAC state. Claim 1 is characterized by performing initialization (when the segment time prediction flag is 0, the CABAC state is initialized using the initialization table, or prediction is performed from the spatial prediction table). The image decoder according to. An image decoding device that decodes variable-length coded coded data, including an entropy decoding unit that reads the CABAC state from the time prediction table at the beginning of the segment that constitutes the picture, and the entropy decoding unit is the target picture. The image decoding device according to claim 1, wherein an entry in the time prediction table is selected for each temporal layer. An image decoding device that decodes variable-length coded coded data, including an entropy decoding unit that stores the CABAC state in a time prediction table at a predetermined position in a segment constituting the picture. The image decoding device according to claim 1, wherein an entry in the time prediction table is selected for each temporal layer of the target picture. An image decoding device that decodes variable-length coded coded data, including an entropy decoding unit that stores the CABAC state in a time prediction table at a predetermined position in a segment constituting the picture. The image decoding device according to claim 1, wherein the CABAC state is stored at a position at the center of the right end of the picture or tile. An image decoding device that decodes variable-length coded coded data, including an entropy decoding unit that stores the CABAC state in a time prediction table at a predetermined position in a segment constituting the picture. The image decoding apparatus according to claim 1, wherein the picture width of the target picture is an integral multiple of the CTU size, or the position for storing the CABAC state is derived by using the size of the cropping window. .. An image decoding device that decodes variable-length coded coded data, including an entropy decoding unit that stores the CABAC state in a time prediction table at a predetermined position in a segment constituting the picture. The image decoding apparatus according to claim 1, wherein when the CTU line unit is a segment, the right end of the segment is the storage position, and in other cases, the center of the segment is the storage position. It is an image coding device that encodes coded data by variable length coding, has an entropy coding unit that encodes the CABAC time prediction flag, and initializes the CABAC state at the beginning of the segment that constitutes the picture. The CABAC initialization unit is provided with an initialization unit, and when the CABAC time prediction flag is 1, the CABAC state is initialized using a time prediction table that holds the CABAC state, and when the CABAC time prediction flag is 0. In addition, an image coding device characterized in that the CABAC state is initialized using an initialization table.

Images