3D data decoding device and 3D data encoding device

Abstract

The aim is to simplify the definition of conformance conditions and achieve high-quality encoding and decoding of 3D data by using integer arithmetic instead of floating-point arithmetic in the encoding and decoding of 3D data. [Solution] A 3D data decoding device for decoding encoded data comprises a mesh prediction unit that derives a predicted value of the base mesh normal vector from the encoded data, and a mesh decoding unit that derives the base mesh normal vector. The mesh prediction unit converts the decoded 3D normal vector into a 2D normal vector using integer arithmetic conversion processing to derive a 2D predicted normal vector. The mesh decoding unit arithmetically decodes the predicted residual of the 2D normal vector, adds the 2D predicted normal vector and the predicted residual to derive a 2D normal vector, and converts the 2D normal vector into a 3D normal vector using integer arithmetic conversion processing including division with bit shifts to derive the base mesh normal vector.

Description

Technical Field

[0001] Embodiments of the present invention relate to a 3D data encoding device and a 3D data decoding device.

Background Art

[0002] In order to efficiently transmit or record 3D data, there are a 3D data encoding device that converts 3D data into a 2D image, encodes it using a video encoding method, and generates encoded data, and a 3D data decoding device that decodes a 2D image from the encoded data and reconstructs 3D data.

[0003] Specific 3D data encoding methods include, for example, ISO / IEC 23090-5 V3C (Volumetric Video-based Coding) and V-PCC (Video-based Point Cloud Compression) of MPEG-I. V3C can encode and decode a point cloud composed of point positions and attribute information. Furthermore, it is also used for encoding and decoding multi-view video and mesh video by ISO / IEC 23090-12 (MPEG Immersive Video, MIV) and ISO / IEC 23090-29 (Video-based Dynamic Mesh Coding, V-DMC) under standardization. The latest draft document of the V-DMC method is disclosed in Non-Patent Document 1.

[0004] In these 3D data encoding methods, the geometry and attributes constituting the 3D data are encoded and decoded as images using a video encoding method such as H.265 / HEVC (High Efficiency Video Coding) or H.266 / VVC (Versatile Video Coding).

[0005] In the case of a point cloud, the geometry image is the depth on the projection plane, and the attribute image is the image in which the attributes are projected onto the projection plane.

[0006] 3D data (mesh) like that described in Non-Patent Document 1 consists of a base mesh, mesh displacement, and texture mapping image. Vertex coding schemes such as Draco can be used to encode the base mesh. Mesh displacement can be encoded either by encoding a 2D mesh displacement image using a video codec, or directly by arithmetic coding. The texture mapping image is encoded as an attribute image using a video codec. The aforementioned HEVC and VVC video codecs can be used. [Prior art documents] [Non-patent literature]

[0007] [Non-Patent Document 1] Study of technologies for Video-based mesh coding, ISO / IEC JTC 1 / SC 29 / WG 7 N0960, July 2024 [Overview of the project] [Problems that the invention aims to solve]

[0008] The 3D data encoding method described in Non-Patent Document 1 allows for the encoding and decoding of mesh displacement (mesh displacement array, mesh displacement image), mesh motion information, and base mesh that constitute 3D data (mesh) using an arithmetic encoding method. However, because the 3D data encoding method described in Non-Patent Document 1 includes floating-point arithmetic in part of the encoding and decoding process, the results may differ depending on the execution environment, which presents challenges in defining conformance conditions.

[0009] This invention facilitates the definition of conformance conditions and enables high-quality 3D data encoding and decoding by using integer arithmetic instead of floating-point arithmetic. The purpose is to encode and decode data. [Means for solving the problem]

[0010] To solve the above problems, a 3D data decoding device according to one aspect of the present invention is a 3D data decoding device that decodes encoded data, comprising: a mesh prediction unit that derives a predicted value of a base mesh normal vector from the encoded data; and a mesh decoding unit that derives the base mesh normal vector. The mesh prediction unit converts the decoded 3D normal vector into a 2D normal vector using integer arithmetic conversion processing to derive a 2D predicted normal vector. The mesh decoding unit arithmetically decodes the predicted residual of the 2D normal vector, adds the 2D predicted normal vector and the predicted residual to derive a 2D normal vector, and converts the 2D normal vector into a 3D normal vector using integer arithmetic conversion processing including division with bit shifts to derive the base mesh normal vector.

[0011] To solve the above problems, a 3D data encoding device according to one aspect of the present invention is a 3D data encoding device that encodes 3D data, comprising: a mesh prediction unit that derives a predicted value of a base mesh normal vector; and a mesh encoding unit that encodes the predicted residual of the base mesh normal vector. The mesh prediction unit converts the encoded 3D normal vector into a 2D normal vector using integer arithmetic conversion processing to derive a 2D predicted normal vector. The mesh encoding unit converts the 3D normal vector to be encoded into a 2D normal vector using integer arithmetic conversion processing, arithmetically encodes the predicted residual for the 2D predicted normal vector, and converts the 2D normal vector into a 3D normal vector using integer arithmetic conversion processing including division with bit shifts to derive an encoded 3D normal vector. [Effects of the Invention]

[0012] According to one aspect of the present invention, the complexity of 3D data reconstruction processing is reduced. Furthermore, it facilitates the definition of conformance conditions and enables high-quality encoding and decoding of 3D data. [Brief explanation of the drawing]

[0013] [Figure 1] This is a schematic diagram showing the configuration of the 3D data transmission system according to this embodiment. [Figure 2] This is a diagram showing the hierarchical structure of the data of the encoded stream. [Figure 3] This is a functional block diagram showing the schematic configuration of the 3D data decoder 31. [Figure 4] This is a functional block diagram showing the configuration of the base mesh decoder unit 303. [Figure 5] This is a functional block diagram showing the configuration of the mesh displacement decoder unit 305. [Figure 6] This is a functional block diagram showing the configuration of the mesh reconstruction unit 307. [Figure 7] This is an example of the syntax of a configuration for transmitting coordinate transformation parameters and context initialization parameters at the sequence level (ASPS). [Figure 8] This is an example of the syntax of a configuration for transmitting coordinate transformation parameters and context initialization parameters at the picture / frame level (AFPS). [Figure 9] This is a diagram for explaining the operation of the mesh reconstruction unit 307. [Figure 10] This is a functional block diagram showing the schematic configuration of the 3D data encoder 11. [Figure 11] This is a functional block diagram showing the configuration of the base mesh encoder unit 103. [Figure 12] This is a functional block diagram showing the configuration of the mesh displacement encoder unit 107. [Figure 13] This is a functional block diagram showing the configuration of the mesh separation unit 115. [Figure 14] This is a diagram for explaining the operation of the mesh separation unit 115. [Figure 15] This is an example of the syntax structure of mesh displacement. [Figure 16] This is a functional block diagram showing the configuration of the mesh decoder unit 3031. [Figure 17]This is an example of the syntax structure of the base mesh vertex positions. [Figure 18] This is an example of the syntax structure of the base mesh attributes. [Figure 19] This is a diagram showing a method for deriving the context of the syntax elements of the base mesh vertex positions. [Figure 20] This is a diagram showing a method for deriving the context of the syntax elements of the base mesh attributes. [Figure 21] This is a functional block diagram showing the configuration of the mesh encoding unit 1031.

Embodiments for Carrying Out the Invention

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

[0015] FIG. 1 is a schematic diagram showing the configuration of a 3D data transmission system 1 according to the present embodiment.

[0016] The 3D data transmission system 1 is a system that transmits an encoded stream obtained by encoding 3D data to be encoded, decodes the transmitted encoded stream, and displays the 3D data. The 3D data transmission system 1 includes a 3D data encoding device 11, a network 21, a 3D data decoding device 31, and a 3D data display device 41.

[0017] 3D data T is input to the 3D data encoding device 1 | 1.

[0018] Network 21 transmits the encoded stream Te generated by the 3D data encoding device 11 to the 3D data decoding device 31. Network 21 is the Internet, a wide area network (WAN), a local area network (LAN), or a combination thereof. Network 21 is not necessarily limited to a bidirectional communication network; it may also be a unidirectional communication network that transmits broadcast waves such as terrestrial digital broadcasting or satellite broadcasting. Furthermore, network 21 may be replaced by a storage medium that records the encoded stream Te, such as a DVD (Digital Versatile Disc: registered trademark) or a BD (Blu-ray Disc: registered trademark).

[0019] The 3D data decoding device 31 decodes each of the encoded streams Te transmitted by the network 21 and generates one or more decoded 3D data Td.

[0020] The 3D data display device 41 displays all or part of one or more decoded 3D data Td generated by the 3D data decoding device 31. The 3D data display device 41 includes a display device such as a liquid crystal display or an organic EL (electro-luminescence) display. Examples of display forms include stationary, mobile, and HMD (head-mounted display). Furthermore, if the 3D data decoding device 31 has high processing power, it displays high-resolution images, and if it has lower processing power, it displays images that do not require high processing power or display capabilities.

[0021] <operators> The operators used in this specification are listed below.

[0022] >> is a right bit shift, << is a left bit shift, & is a bitwise AND, | is a bitwise OR, |= is the OR assignment operator, and || represents logical OR.

[0023] x?y:z is a ternary operator that takes y if x is true (non-zero) and z if x is false (0). y..z represents a set of integers from y to z.

[0024] Abs(x) is a function that returns the absolute value of x.

[0025] The operator ' / ' is integer division, truncating towards zero. For example, 7 / 4 is truncated to 1, and -7 / 4 is truncated to -1.

[0026] The division operator (÷) performs division without rounding or truncation.

[0027] <Structure of the coded stream Te> Prior to a detailed description of the 3D data encoding device 11 and the 3D data decoding device 31 according to this embodiment, the data structure of the encoded stream Te generated by the 3D data encoding device 11 and decoded by the 3D data decoding device 31 will be described.

[0028] Figure 2 shows the hierarchical structure of data in the encoded stream Te. The encoded stream Te has either a V3C sample stream or a V3C unit stream data structure. The V3C sample stream includes a sample stream header and a V3C unit. The V3C unit stream includes a V3C unit.

[0029] A V3C unit includes a V3C unit header and a V3C unit payload. The V3C unit header is the Unit Type, which is an ID indicating the type of V3C unit, and takes values ​​indicated by labels such as V3C_VPS, V3C_AD, V3C_AVD, V3C_GVD, and V3C_OVD.

[0030] If the Unit Type is V3C_VPS (Video Parameter Set), the V3C unit includes the V3C parameter set.

[0031] When the Unit Type is V3C_AD (Atlas Data), the V3C unit includes the VPS ID, atlasID, sample stream NAL header, and multiple NAL units. The atlasID is an Identification ID and takes a non-negative integer value.

[0032] A NAL unit includes NALUnitType, layerID, TemporalID, and RBSP (Raw byte sequence payload).

[0033] NAL units are identified by NALUnitType, ASPS (Atlas Sequence Parameter Set), and AAPS. This includes Atlas Adaptation Parameter Set (ATLAS), Atlas Tile layer (ATLAS), and Supplemental Enhancement Information (SEI).

[0034] An ATL file includes an ATL header and an ATL data unit, which contains information such as the location and size of a patch, including patch information data.

[0035] SEI includes payloadType, which indicates the type of SEI; payloadSize, which indicates the size (in bytes) of the SEI; and sei_payload, which contains the SEI data.

[0036] If the Unit Type is V3C_AVD (Attribute Video Data), then V3C The unit includes the VPS ID, atlasID, attrIdx (attribute image ID), partIdx (partition ID), mapIdx (map ID), auxFlag (a flag indicating whether it is auxiliary data), and a video stream. The video stream is data encoded in HEVC, VVC, etc. In V-DMC, the attribute data corresponds to the texture image.

[0037] When NalUnitType is V3C_GVD (Geometry Video Data), the V3C unit includes VPS ID, atlasID, mapIdx, auxFlag, and video stream. In V-DMC, the geometry data corresponds to mesh displacement.

[0038] If the Unit Type is V3C_OVD (Occupancy Video Data), the V3C unit includes the VPS ID, atlasID, and video stream.

[0039] If the Unit Type is V3C_MD (Mesh data), the V3C unit is the VPS ID, atl Includes asID and mesh_payload. V-DMC supports base mesh.

[0040] (Configuration of the 3D data decoding device according to the first embodiment) Figure 3 is a functional block diagram showing the schematic configuration of the 3D data decoding device 31 according to the first embodiment. The 3D data decoding device 31 consists of a demultiplexing unit 301, an atlas information decoding unit 302, a base mesh decoding unit 303, a mesh displacement decoding unit 305, a mesh reconstruction unit 307, an attribute decoding unit 306, and a color space conversion unit 308. The 3D data decoding device 31 receives encoded 3D data as input and outputs atlas information, meshes, and attribute images.

[0041] The demultiplexing unit 301 receives encoded data multiplexed in a byte stream format, ISOBMFF (ISO Base Media File Format), etc., demultiplexes it, and outputs an atlas information encoded stream (V3C_AD's Atlas Data stream, NALunit), a base mesh encoded stream (V3C_MD's mesh_payload), a mesh displacement encoded stream (V3C_GVD's video stream), and an attribute video stream (V3C_AVD's video stream).

[0042] The Atlas information decoding unit 302 receives the Atlas information encoded stream output from the demultiplexing unit 301 and decodes the Atlas information.

[0043] The atlas information decoding unit 302 in Figure 3 decodes coordinate system transformation information (displacementCoordinateSystem(asps_vdmc_ext_displacement_coordinate_system, afps_vdmc_ext_displacement_coordinate_system)) indicating the coordinate system from the encoded data. Alternatively, a gating flag may be set, and each coordinate system transformation information may be decoded only when the gating flag is set to 1. The gating flag is, for example, afps_vdmc_ext_displacement_coordinate_system_enable_flag.

[0044] The base mesh decoding unit 303 decodes the base mesh encoding stream encoded using vertex coding (a 3D data compression encoding method, such as Draco) and outputs the base mesh. The base mesh will be described later.

[0045] The mesh displacement decoding unit 305 decodes the mesh displacement coding stream and outputs the mesh displacement.

[0046] The mesh reconstruction unit 307 receives the base mesh and mesh displacement as input and reconstructs the mesh in 3D space.

[0047] The attribute decoding unit 306 decodes the attribute video stream encoded with VVC, HEVC, etc., and outputs an attribute image. The attribute image is a texture image unfolded along the UV axis (a texture mapping image converted using the UV atlas method) and may be in YCbCr format. The type of codec used for encoding is indicated by ptl_profile_codec_group_idc, which is obtained by decoding the V3C parameter set of the encoded data. Alternatively, it may be indicated by the Four CC code indicated by ai_geometry_codec_id[atlasID] in the V3C parameter set. ai_geometry_codec_id[atlasID] indicates the index in the atlas ID that corresponds to the codec ID of the decoder used to decode the attribute video stream.

[0048] The color space conversion unit 308 converts the attribute image from YCbCr format to RGB format. Alternatively, the attribute video stream encoded in RGB format can be decoded, and the color space conversion can be omitted.

[0049] (Decoding the base mesh) Figure 4 is a functional block diagram showing the configuration of the base mesh decoding unit 303. The decoding unit 303 consists of a mesh decoding unit 3031, a motion information decoding unit 3032, a mesh motion compensation unit 3033, a reference mesh memory 3034, a switch 3035, and a switch 3036. The base mesh decoding unit 303 may also include a base mesh inverse quantization unit (not shown) before the base mesh output. Switches 3035 and 3036 are connected to the side that does not perform motion compensation if the base mesh to be decoded is encoded without referencing other base meshes (e.g., base meshes that have already been encoded and decoded) (intra-encoded). If the base mesh to be decoded is encoded by referencing other base meshes (inter-encoded), they are connected to the side that performs motion compensation. When motion compensation is performed, the target vertex coordinates are derived by referencing already decoded vertex coordinates and motion information.

[0050] The mesh decoding unit 3031 decodes the intra-encoded base mesh encoding stream and outputs the base mesh (base mesh vertex positions, base mesh vertex position vector). The encoding method used may include Draco or edge breaker.

[0051] The motion information decoding unit 3032 decodes the intercoded base mesh coded stream and outputs motion information (mesh motion information, mesh motion vector) for each vertex of the reference mesh described later. Entropy coding such as arithmetic coding is used as the coding method.

[0052] The mesh motion compensation unit 3033 performs motion compensation on each vertex of the reference mesh input from the reference mesh memory 3034 based on motion information, and outputs the motion-compensated mesh.

[0053] The reference mesh memory 3034 is a memory that holds the decoded mesh for reference in subsequent decoding processes.

[0054] (Decoding of mesh displacement) Figure 5 is a functional block diagram showing the configuration of the mesh displacement decoding unit 305. The mesh displacement decoding unit 305 consists of a CABAC decoding unit (arithmetic decoding unit 3051, multi-level conversion unit 3052, context selection unit 3056, context initialization unit 3057), an inverse quantization unit 3053, an inverse transformation unit 3054, and a coordinate system transformation unit 3055.

[0055] (Context-adaptive binary arithmetic coding) The arithmetic decoding unit 3051, the multi-leveling unit 3052, the context selection unit 3056, and the context initialization unit 3057 use a context-based decoding method called Context-Adaptive Binary Arithmetic Coding (CABAC). In CABAC, a binary sequence consisting of 0s and 1s is encoded and decoded bit by bit using a state variable called a context (CABAC state). All CABAC states are initialized at the beginning of the segment. The CABAC decoding unit decodes each bit of the binary sequence (Bin String) corresponding to the syntax element. When a context is used, a context index ctxInc is derived for each bit of the syntax element, the bit is decoded using the context, and the CABAC state of the context is updated. Bits that do not use a context are decoded with equal probability (EP, bypass), and the index ctxIdx that specifies the context and the update of the specified context are omitted. A context is a variable (memory area) used to hold the probability (state) of CABAC, and is identified by the value of ctxIdx (0, 1, 2, ...). When 0 and 1 are always equally probable, i.e., 0.5, 0.5, this is called EP (Equal Probability) or bypass. In this case, no context is used because there is no need to maintain a state for a specific syntax element. Alternatively, a static context can be used, where the probability is fixed at 0.5 and does not need to be updated. In this sense, it can be called static instead of bypass. An integer value such as 128 can be used to represent the probability of 0.5.

[0056] The process of decoding one bit without using the context (bypassing it) is as follows: You may also use "do". rangeTimesProb = IvlRange >> 1 binVal = ( rangeTimesProb <= ( IvlCode - IvlLow ) ) if (binVal == 0) IvlRange = rangeTimesProb else { IvlLow += rangeTimesProb IvlRange -= rangeTimesProb } The following pseudocode can also be used to perform 1-bit decoding using the context. Here, prob0 is a variable that represents the probability of the context. rangeTimesProb = IvlRange * prob0 >> 16 binVal = ( rangeTimesProb <= ( IvlCode - IvlLow ) ) if (binVal == 0) IvlRange = rangeTimesProb else { IvlLow += rangeTimesProb IvlRange -= rangeTimesProb } (Coordinate system) The coordinate systems used for mesh displacement (3D vectors) are the following two types of coordinate systems. Cartesian coordinate system (canonical): A Cartesian coordinate system defined commonly across the entire 3D space. (X,Y,Z) coordinate system. A Cartesian coordinate system where direction does not change at the same time (within the same frame, within the same tile). Local coordinate system (local): A Cartesian coordinate system defined for each region or vertex in 3D space. A Cartesian coordinate system whose direction can change at the same time (within the same frame, within the same tile). A coordinate system with normal (D), tangent (U), and bi-tangent (V) axes. That is, a Cartesian coordinate system consisting of a first axis (D) indicated by the normal vector n_vec at a certain vertex (or the face containing a certain vertex), and a second axis (U) and a third axis (V) indicated by two tangent vectors t_vec and b_vec that are orthogonal to the normal vector n_vec. n_vec, t_vec, and b_vec are 3-dimensional vectors. The (D, U, V) coordinate system may also be called the (n, t, b) coordinate system.

[0057] (Decoding and derivation of sequence-level control parameters) Here, we will explain the control parameters used in the mesh displacement decoding unit 305.

[0058] Figure 7 shows an example of syntax for transmitting coordinate system transformation parameters using sequence-level ASPS. ASPS (Atlas Sequence Parameter Set or Atlas sequence mesh information) is one of the NAL units of atlas information and contains syntax elements applied to the atlas information encoded stream. In ASPS, coordinate system transformation parameters are transmitted using the asps_vdmc_extension() syntax. The semantics of each field are as follows:

[0059] asps_vdmc_ext_subdivision_iteration_count: This parameter indicates the number of mesh subdivision iterations.

[0060] asps_vdmc_ext_displacement_coordinate_system: Coordinate system transformation information indicating the coordinate system of mesh displacement. If the value is equal to a predetermined first value (e.g., 0), it indicates the Cartesian coordinate system. If the value is equal to another second value (e.g., 1), it indicates the local coordinate system.

[0061] asps_vdmc_ext_1d_displacement_flag: This flag indicates whether the mesh displacement is one-dimensional or not. If the value is true, it indicates that the mesh displacement is one-dimensional. If the value is false, This demonstrates that the mesh displacement is three-dimensional.

[0062] (Decoding and derivation of picture / frame-level control parameters) Figure 8 shows an example of syntax for transmitting coordinate system transformation parameters using picture / frame-level AFPS. AFPS (Atlas Frame Parameter Set or Atlas frame mesh information) is one of the NAL units of atlas information and contains syntax elements applied to the atlas information encoded stream. In AFPS, coordinate system transformation parameters are transmitted using the afps_vdmc_extension() syntax. The semantics of each field are as follows:

[0063] afps_vdmc_ext_overriden_flag: This flag indicates whether or not to update the mesh displacement coordinate system. If this flag is equal to true, the mesh displacement coordinate system will be updated based on the value of afps_vdmc_ext_displacement_coordinate_system described below. If this flag is equal to false, the mesh displacement coordinate system will not be updated.

[0064] afps_vdmc_ext_subdivision_iteration_count: This parameter indicates the number of mesh subdivision iterations.

[0065] afps_vdmc_ext_displacement_coordinate_system: Coordinate system transformation information indicating the coordinate system of mesh displacement. If the value is equal to the first value (e.g., 0), it indicates the Cartesian coordinate system. If the value is equal to the second value (e.g., 1), it indicates the local coordinate system. If no syntax elements appear, the default coordinate system is assumed to be the coordinate system indicated by ASPS, based on the assumption that the value is the value decoded by ASPS.

[0066] afps_vdmc_ext_1d_displacement_flag: This flag indicates whether the mesh displacement is one-dimensional or not. A value of true indicates that the mesh displacement is one-dimensional. A value of false indicates that the mesh displacement is three-dimensional.

[0067] (Syntax structure of mesh displacement) Figure 15 shows an example of the syntax structure of mesh displacement. The semantics are as follows: Mesh displacement is a sequence of position pos and k component values ​​(coefficients), denoted by the array Qdisp[pos][k]. Displacement is a 3D signal in Cartesian coordinate system (xyz) or local coordinate system (ntb), and each component of the 3D displacement is called a component. Here, the displacement Qdisp is the value after being transformed by discrete wavelet transform, lifting transform, DCT transform, etc., and is therefore also called a coefficient. The component variable k takes values ​​of 0, 1, or 2. The variable name is not limited to k; dim can be any other variable name. The order of the QDisp indices can be reversed, that is, Qdisp[k][pos] can be used instead of Qdisp[pos][k].

[0068] diu_last_sig_coeff[k]: This is an index indicating the final position of the non-zero mesh displacement coefficient in the k component.

[0069] diu_coded_block_flag[k][b]: Indicates whether the block at index b in component k contains a non-zero mesh displacement coefficient. 1 if it does, 0 otherwise.

[0070] diu_coded_subblock_flag[k][b][s]: Indicates whether the subblock at index s of the block at index b in the k component contains a non-zero mesh displacement coefficient. 1 if it does, 0 otherwise.

[0071] diu_coeff_abs_level_gt0[k][b][s][v]: The absolute non-zero mesh displacement coefficient of the vertex at index v of the subblock at index s of the block at index b in the k component. Indicates whether the value is greater than 0. 1 if greater, 0 otherwise.

[0072] diu_coeff_abs_level_gt1[k][b][s][v]: Indicates whether the absolute value of the non-zero mesh displacement coefficient at index v of the subblock at index s in the block at index b is greater than 1 in the k component. 1 if greater, 0 otherwise. If this syntax element does not exist, it is assumed to be 0.

[0073] diu_coeff_abs_level_gt2[k][b][s][v]: Indicates whether the absolute value of the non-zero mesh displacement coefficient at index v of the subblock at index s in the block at index b is greater than 2 in the k component. 1 if greater, 0 otherwise. If this syntax element does not exist, it is assumed to be 0.

[0074] diu_coeff_abs_level_gt3[k][b][s][v]: Indicates whether the absolute value of the non-zero mesh displacement coefficient at index v of the subblock at index s in the block at index b is greater than 3 in the k component. 1 if greater, 0 otherwise. If this syntax element does not exist, it is assumed to be 0.

[0075] diu_coeff_sign[k][b][s][v]: Indicates whether the non-zero mesh displacement coefficient of the vertex at index v of the subblock at index s in the block at index b is positive or negative in the k component. For example, 1 if it is positive, and 0 otherwise (if it is negative). If this syntax element does not exist, it is assumed to be 1.

[0076] diu_coeff_abs_level_rem[k][b][s][v]: The value obtained by subtracting 4 from the absolute value of the non-zero mesh displacement coefficient at the vertex at index v of the subblock at index s in the block at index b in the k component. If this syntax element does not exist, it is assumed to be 0.

[0077] The mesh displacement decoding unit 305 decodes diu_last_sig_coeff for each component of the mesh displacement. Then, it derives the number of lods for component k, lodCount, from diu_last_sig_coeff[k].

[0078] The mesh displacement decoding unit 305 decodes the diu_coded_block_flag for each detail level (lod) of the mesh displacement. Then, it derives the number of blocks b, vertexCount, from diu_coded_block_flag[k][b].

[0079] The mesh displacement decoding unit 305 decodes diu_coded_subblock_flag for each block of mesh displacement. Then, it derives the starting position vStart of subblock s from diu_coded_subblock_flag[k][b][s].

[0080] The mesh displacement decoding unit 305 decodes diu_coeff_abs_level_gt0 for each subblock of mesh displacement, and if diu_coeff_abs_level_gt0 is a predetermined value (for example, not 0), it decodes the subsequent diu_coeff_sign and diu_coeff_abs_level_gt1.

[0081] The mesh displacement decoding unit 305 decodes the subsequent diu_coeff_abs_level_gt2 if diu_coeff_abs_level_gt1 is a predetermined value (for example, not 0).

[0082] The mesh displacement decoding unit 305 decodes the subsequent diu_coeff_abs_level_gt3 if diu_coeff_abs_level_gt2 is a predetermined value (for example, not 0).

[0083] The mesh displacement decoding unit 305 decodes the subsequent diu_coeff_abs_level_rem if diu_coeff_abs_level_gt3 is a predetermined value (for example, not 0).

[0084] (Operation of the mesh displacement decoding unit) The arithmetic decoding unit 3051 decodes the mesh displacement coding stream, which has been arithmetically coded according to the value (context) representing the random variable, and outputs a binary signal. The binary signal may be an alpha code or a k-th order exponential Golomb code. An exponential Golomb code consists of a prefix and a suffix code. The prefix is ​​an exponentially increasing value, and the suffix is ​​its remainder. When encoding and decoding the variable rem with an exponential Golomb code, the prefix and suffix of the exponential Golomb code are also called the prefix and suffix of rem.

[0085] The multi-leveling unit 3052 decodes the binary signal into a multi-level signal, which is a quantized mesh displacement Qdisp.

[0086] The context selection unit 3056 (context memory) has memory for holding contexts and derives a context used for arithmetic decoding of mesh displacements depending on the state, and updates the values ​​as necessary. In the arithmetic decoding of each coefficient of mesh displacement, the following arrays of different contexts may be used depending on the frame type ft (e.g., 0: intraframe, 1: interframe), the mesh division level lod (level of detail), and the component dim of the mesh displacement vector. The context includes a variable that indicates the probability of a binary signal occurring. ctxCodedSubBlock[numFT][numLOD][numDim] ctxCoeffGtN[numFT][numLOD][MAX_GTN+1][numDim] ctxCoeffRemPrefix[numFT][numLOD][numDim][numPrefixBin] A static context with fixed probabilities that does not undergo context updates is defined as ctxStatic. Decoding of syntax elements represented by ctxStatic may be performed without using the context. decode(ctxStatic) may be replaced with decode_bypass(), which is a bypass-only process.

[0087] Here, numFT is the number of frame types, and numFT = 2. numPrefixBin is the number of bins that use context in the prefix, and numPrefixBin = 2 may also be used. numLOD is the maximum level of detail for mesh subdivision, and may be the value of the syntax element asps_vdmc_ext_subdivision_iteration_count or afps_vdmc_ext_subdivision_iteration_count decoded from the bitstream, or numLOD may be set to 4. numLOD = asps_vdmc_ext_subdivision_iteration_count numLOD = afps_vdmc_ext_subdivision_iteration_count numDim is the dimension of the mesh displacement vector, and may be the value of the syntax element asps_vdmc_ext_1d_displacement_flag or afps_vdmc_ext_1d_displacement_flag decoded from the bitstream, or numDim may be set to 3. numDim = asps_vdmc_ext_1d_displacement_flag ? 1 : 3 numDim = afps_vdmc_ext_1d_displacement_flag ? 1 : 3 The maximum threshold value for the coefficient, MAX_GTN, is 3.

[0088] ctxCodedSubBlock[numFT][numLOD][numDim] is an array of contexts used to decode the syntax element diu_coded_subblock_flag. The arithmetic decoding unit 3051 uses the values ​​of ctxCodedSubBlock[ft][lod][dim] to decode diu_coded_subblock_flag for frame type ft, detail level lod, and mesh displacement vector dimension dim.

[0089] ctxCoeffGtN[numFT][numLOD][MAX_GTN+1][numDim] is an array of contexts used to decode the syntax element diu_coeff_abs_level_gtN (where N is replaced with 0, 1, 2, or MAX_GTN). The arithmetic decoding unit 3051 uses the value of ctxCoeffGtN[ft][lod][N][dim] to determine the frame type Decode diu_coeff_abs_level_gtN in ipft, detail level lod, and mesh displacement vector dimension dim.

[0090] The arithmetic decoding unit 3051 decodes the diu_coeff_sign in the frame type ft, detail level lod, and dimension dim of the mesh displacement vector using a bypass.

[0091] ctxCoeffRemPrefix[numFT][numLOD][numDim][numPrefixBin] is an array of contexts used to decode the syntax element diu_coeff_abs_level_rem. ctxCoeffRemPrefix[bin] indicates the context at the bin position in the binary conversion of the prefix diu_coeff_abs_level_rem. The arithmetic decoding unit 3051 uses the values ​​of ctxCoeffRemPrefix[ft][lod][dim] to decode diu_coeff_abs_level_rem with frame type ft, detail level lod, and mesh displacement vector dimension dim.

[0092] The context initialization unit 3057 initializes the context (the probability of a binary signal occurring). The context may be initialized for each frame, or for each group of frames (GoF). When the context is initialized for each frame, there is no context dependency between frames, making it easy to access any frame randomly. When the context is initialized for each GoF, the initialization frequency is lower, which improves coding efficiency compared to initializing for each frame.

[0093] (Derivation process of mesh displacement) The mesh displacement decoding unit 305 decodes the syntax elements diu_last_sig_coeff, diu_coded_block_flag, diu_coded_subblock_flag, diu_coeff_abs_level_gt0, diu_coeff_abs_level_gt1, diu_coeff_abs_level_gt2, diu_coeff_abs_level_gt3, diu_coeff_abs_level_rem, and diu_coeff_sign through the following process and derives the mesh displacement Qdisp. Here, the mesh displacement decoding unit 305 decodes diu_last_sig_coeff on a component-by-component basis. It decodes diu_coded_block_flag on an LOD-by-LOD (block-by-block) basis and diu_coded_subblock_flag on a subblock-by-sub for (k = 0; k < numDim; k++) { / / dimension (component) loop / / decode diu_last_sig_coeff diu_last_sig_coeff[k] = decodeExpGolomb(ctxStatic) dispOffset = 0 for (b = 0; b <numLOD; b++) { / / Level of Detail loop, block loop / / decode diu_coded_block_flag diu_coded_block_flag[k][b] = decode(ctxStatic) if (diu_coded_block_flag[k][b]) { numSubBlocks = dispCount[b] / subBlockSize + 1 for (s = 0; s < numSubBlocks; s++) { / / subblock loop / / decode diu_coded_subblock_flag diu_coded_subblock_flag[k][b][s] = decode(ctxCodedSubBlock[ft][b][k]) if (diu_coded_subblock_flag[k][b][s]) { for (v = 0; v < subBlockSize; v++) { / / coefficient loop within subblock value = 0 / / decode diu_coeff_abs_level_gt0 diu_coeff_abs_level_gt0[k][b][s][v] = decode(ctxCoeffGtN[ft][b][0][k]) if (diu_coeff_abs_level_gt0[k][b][s][v]) { value++ / / decode diu_coeff_sign diu_coeff_sign[k][b][s][v] = decode(ctxStatic) / / decode diu_coeff_abs_level_gt1 diu_coeff_abs_level_gt1[k][b][s][v] = decode(ctxCoeffGtN[ft][b][1][k]) if (diu_coeff_abs_level_gt1[k][b][s][v]) { value++ / / decode diu_coeff_abs_level_gt2 diu_coeff_abs_level_gt2[k][b][s][v] = decode(ctxCoeffGtN[ft][b][2][k]) if (diu_coeff_abs_level_gt2[k][b][s][v]) { value++ / / decode diu_coeff_abs_level_gt3 diu_coeff_abs_level_gt3[k][b][s][v] = decode(ctxCoeffGtN[ft][b][3][k]) if (diu_coeff_abs_level_gt3[k][b][s][v]) { / / decode diu_coeff_abs_level_rem diu_coeff_abs_level_rem[k][b][s][v] = decodeExpGolomb(ctxCoeffRemPrefix[ft][b][k]) value += (1 + diu_coeff_abs_level_rem) } } } if (diu_coeff_sign[k][b][s][v]) { value = -value } } Qdisp[dispOffset + s * subBlockSize + v][k] = value } } } } dispOffset += dispCount[b] } } Here, decode(ctx) is a function that decodes a 1-bit value with the corresponding context ctx as an argument, and decodeExpGolomb(ctxPrefix, ctxSuffix) is a function that decodes a value that has been binaryized with a k-th exponential Golomb code (e.g., k=0). ctxPrefix[n] is used as the context for the prefix bin position n, and ctxSuffix[m] is used as the context for the suffix bin position m. If no context is used for the suffix (bypass is used), simply write decodeExpGolomb(ctxPrefix). The `value++` operation increments the variable `value` by 1, so `value += 1` and `value = value` are equivalent. + 1. subBlockSize is the size of the subblock. for indicates a loop. subBlockSize may be a power of 2 from 16 to 4096. For example, 128 or 256 would also be acceptable. dispCount[b] is the number of mesh displacements at detail level b.

[0094] The inverse quantization unit 3053 performs inverse quantization based on the quantization scale value iscale and derives the mesh displacement Tdisp after transformation (e.g., wavelet transform). Tdisp may be in a Cartesian coordinate system or a local coordinate system. iscale is the quantization of each component of the mesh displacement image. This is a value derived from the meter. Tdisp[0][] = (Qdisp[0][] * iscale[0] + iscaleOffset) >> iscaleShift Tdisp[1][] = (Qdisp[1][] * iscale[1] + iscaleOffset) >> iscaleShift Tdisp[2][] = (Qdisp[2][] * iscale[2] + iscaleOffset) >> iscaleShift Here, iscaleOffset = 1 << (iscaleShift - 1). iscaleShift may be a predetermined constant, or it may be encoded at the sequence level, picture / frame level, tile / patch level, etc., and the value decoded from the encoded data may be used.

[0095] The inverse transform unit 3054 performs an inverse transform g (for example, an inverse wavelet transform) to derive the mesh displacement d. d[0][] = g(Tdisp[0][]) d[1][] = g(Tdisp[1][]) d[2][] = g(Tdisp[2][]) The coordinate system transformation unit 3055 transforms the mesh displacement (the coordinate system of the mesh displacement) into a Cartesian coordinate system based on the value of the coordinate system transformation information displacementCoordinateSystem. Specifically, when displacementCoordinateSystem==1, it transforms from the displacement in the local coordinate system to the displacement in the Cartesian coordinate system. Here, d is a 3D vector representing the mesh displacement before the coordinate system transformation. disp is a 3D vector representing the mesh displacement after the coordinate system transformation, and is in the Cartesian coordinate system. n_vec, t_vec, and b_vec are 3D vectors (in the Cartesian coordinate system) corresponding to each axis of the local coordinate system of the target region or target vertex. if (displacementCoordinateSystem == 0) { disp = d } else if (displacementCoordinateSystem == 1){ disp = d[0] * n_vec + d[1] * t_vec + d[2] * b_vec } The derivation method shown above using vector multiplication can be expressed individually in terms of scalars as follows: if (displacementCoordinateSystem == 0) { for (i = 0; i < 3; i++) {disp[i] = d[i]}} else if (displacementCoordinateSystem == 1){ for (i = 0; i < 3; i++) {disp[i] = d[0] * n_vec[i] + d[1] * t_vec[i] + d[2] * b_vec[i]} } Alternatively, you could assign the same variable name before and after the transformation by setting disp=d, and then update the value of d based on the coordinate transformation.

[0096] Alternatively, the following configuration is also acceptable. if (displacementCoordinateSystem == 0) { disp = d } else if (displacementCoordinateSystem == 1){ disp = d[0] * n_vec + d[1] * t_vec + d[2] * b_vec } else if (displacementCoordinateSystem == 2){ disp = d[0] * n_vec2 + d[1] * t_vec2 + d[2] * b_vec2 } Here, n_vec2, t_vec2, and b_vec2 are 3-dimensional vectors (in Cartesian coordinates) corresponding to each axis of the local coordinate system of the adjacent region.

[0097] Alternatively, the following configuration is also acceptable. if (displacementCoordinateSystem == 0) { disp = d } else if (displacementCoordinateSystem == 1){ disp = d[0] * n_vec3 + d[1] * t_vec3 + d[2] * b_vec3 } Here, n_vec3, t_vec3, and b_vec3 are 3D vectors (in a Cartesian coordinate system) corresponding to the axes of the local coordinate system of the target area with fluctuations suppressed. For example, the vectors of the coordinate system used for decoding are derived from the previous coordinate system and the current coordinate system as follows n_vec3 = (w * n_vec3 + (WT - w) * n_vec) >> wShift t_vec3 = (w * t_vec3 + (WT - w) * t_vec) >> wShift b_vec3 = (w * b_vec3 + (WT - w) * b_vec) >> wShift Here, for example, wShift = 2, 3, 4, WT = 1 << wShift, and w = 1..WT - 1. For example, when w = 3 and wShift = 3 n_vec3 = (3 * n_vec3 + 5 * n_vec) >> 3 t_vec3 = (3 * t_vec3 + 5 * t_vec) >> 3 b_vec3 = (3 * b_vec3 + 5 * b_vec) >> 3 Also, a configuration may be adopted such that it can be selected according to the value of the coordinate system conversion information displacementCoordinateSystem decoded from the encoded data as follows if (displacementCoordinateSystem == 0) { disp = d } else if (displacementCoordinateSystem == 1){ disp = d[0] * n_vec + d[1] * t_vec + d[2] * b_vec } else if (displacementCoordinateSystem == 6){ disp = d[0] * n_vec3 + d[1] * t_vec3 + d[2] * b_vec3 } (Decoding of the base mesh) Figure 16 is a functional block diagram showing the configuration of the mesh decoding unit 3031. The mesh decoding unit 3031 consists of a mesh prediction unit 30311, a 3D-2D conversion unit 30312, a 2D-3D conversion unit 30313, and a CABAC decoding unit (arithmetic decoding unit 3051, multi-level conversion unit 3052, context selection unit 3056, and context initialization unit 3057).

[0098] (Syntax structure of the base mesh) Figure 17 shows an example of the syntax structure for base mesh vertex positions (predicted residuals of vertex position vectors, base mesh vertex position vectors). The semantics are as follows:

[0099] The mesh prediction unit 30311 classifies the predicted position vector of the current vertex into a first classification, Fine, if the number of available predicted position vector candidates (position vectors of decoded vertices adjacent to the current vertex) is greater than or equal to a predetermined value, and into a second classification, Coarse, if the number is less than the predetermined value. Depending on the classification, the position residual may be decoded using different syntax elements of mesh_position_fine_residual[i][j] and mesh_position_coarse_residual[i][j]. Alternatively, the context of the arithmetic code may be switched depending on the classification, as described later. Alternatively, the syntax elements may not be changed depending on the classification, but the variables obtained by decoding the syntax elements may be changed. Note that the classification method is not limited to these.

[0100] mesh_position_fine_residuals_count: Indicates the size of the array mesh_position_fine_residual, which contains the predicted residuals of the Fine (Fine) predicted position 3D vector.

[0101] mesh_position_coarse_residuals_count: Indicates the size of the array mesh_position_coarse_residual, which contains the predicted residuals of the 3D vector of the predicted coarse position.

[0102] mesh_coded_position_fine_residuals_size: Indicates the byte size of the arithmetic encoded data of the predicted residuals for the Fine 3D position vector.

[0103] mesh_position_fine_residual[i][j]: 3D vector of the i-th Fine prediction position This shows the predicted residual value for the j-th dimension (component) of the model.

[0104] mesh_coded_position_coarse_residuals_size: Indicates the byte size of the arithmetic encoded data of the predicted residuals for the 3D vector of the predicted coarse position.

[0105] mesh_position_coarse_residual[i][j]: Indicates the predicted residual value of the j-th dimension (component) of the i-th course (coarse) predicted position 3D vector.

[0106] Figure 18 shows an example of the syntax structure of base mesh attributes (predicted texture coordinate residual, base mesh texture coordinate, predicted normal vector residual, base mesh normal vector). The semantics are as follows:

[0107] The mesh prediction unit 30311 classifies the predicted attributes of the current vertex as Fine if the number of available predicted attribute candidates (attributes of decoded vertices adjacent to the current vertex) is greater than or equal to a predetermined value, and as Coarse if it is less than the predetermined value. The classification method is not limited to this. Depending on the classification, the residuals of the attributes (texture coordinates, normal vectors, etc.) may be decoded into different syntax elements of mesh_attribute_fine_residual[i][j] and mesh_attribute_coarse_residual[i][j]. Alternatively, the context of the arithmetic code may be switched depending on the classification, as described later. Alternatively, the syntax elements may not be changed depending on the classification, but the variables obtained by decoding the syntax elements may be changed. Note that the classification method is not limited to this.

[0108] mesh_attribute_fine_residuals_count[i]: Indicates the size of the array mesh_attribute_fine_residual, which contains the predicted residuals of the fine N-dimensional vector for the i-th attribute.

[0109] mesh_attribute_coarse_residuals_count[i]: Indicates the size of the array mesh_attribute_coarse_residual, which contains the predicted residuals of the N-dimensional coarse vector for the i-th attribute.

[0110] mesh_coded_attribute_fine_residuals_size[i]: Indicates the byte size of the arithmetic coded data for the predicted residuals of the fine N-dimensional vector of the i-th attribute.

[0111] mesh_attribute_fine_residual[i][j][k]: Indicates the predicted residual value of the k-th dimension (component) of the j-th Fine N-dimensional vector of the i-th attribute.

[0112] mesh_coded_attribute_coarse_residuals_size[i]: Indicates the byte size of the arithmetic coded data for the predicted residuals of the N-dimensional coarse vector of the i-th attribute.

[0113] mesh_attribute_coarse_residual[i][j][k]: Indicates the predicted residual value of the k-th dimension (component) of the j-th course (coarse) N-dimensional vector of the i-th attribute.

[0114] Additionally, mesh_attribute_count indicates the number of attributes. NumComponents[i] indicates the number of components (dimensions) of the i-th attribute.

[0115] (Predicted residual of normal vector, base mesh normal vector) The normal vector (predicted normal vector, normal vector prediction residual, base mesh normal vector) may be a 3D vector, or it may be a 2D vector obtained by projecting a 3D vector onto a 2D plane (for example, an octahedral projection).

[0116] The 3D-2D conversion unit 30312 converts the normal vector prediction residual to a 3D normal vector when the normal vector prediction residual is a 2D vector. The `L` variable is converted into a 2D normal vector. The 3D-2D conversion unit 30312 does nothing if the normal vector prediction residual is a 3D vector.

[0117] The 2D-3D conversion unit 30313 converts the 2D normal vector to a 3D normal vector if the normal vector prediction residual is a 2D vector. If the normal vector prediction residual is a 3D vector, the 2D-3D conversion unit 30313 does nothing.

[0118] (Conversion from 3D vector to 2D vector) The 3D-2D conversion unit 30312 performs the following process: convert3Dto2Doctahedral.

[0119] The input to this conversion process is a 3D vector 3Dvector[i] (i=0..2) in unsigned integer format. The output of this conversion process is a 2D vector 2Dvector[i] (i=0..1) in unsigned integer format. qpOcta is a predetermined constant that indicates the bit width of the values ​​of the 3D and 2D vectors.

[0120] First, convert the values ​​of each dimension (each component) of the 3D vector to values ​​centered around zero. center[0] = 1 << ( qpOcta - 1 ) center[1] = 1 << ( qpOcta - 1 ) center[2] = 1 << ( qpOcta - 1 ) 3Dvector[0] = 3Dvector[0] - center[0] 3Dvector[1] = 3Dvector[1] - center[1] 3Dvector[2] = 3Dvector[2] - center[2].

[0121] Next, the 3D vector is normalized and converted into a 2D vector (a 2D vector projected onto an octahedron). sum = Abs( 3Dvector[0] ) + Abs( 3Dvector[1] ) + Abs( 3Dvector[2] ) if (3Dvector[2] >= 0){ 2Dvector[0] = IntRangeSum2qnBit(3Dvector[0], qpOcta, sum) 2Dvector[1] = IntRangeSum2qnBit(3Dvector[1], qpOcta, sum) else { 2Dvector[0] = IntRangeSum2qnBit( CopySign( sum - Abs( 3Dvector[1] ), 3Dvector[0] ), qpOcta, sum ) 2Dvector[1] = IntRangeSum2qnBit( CopySign( sum - Abs( 3Dvector[0] ), 3Dvector[1] ), qpOcta, sum ) }。

[0122] Here, sum is the sum of the absolute values of the values of each dimension of the 3D vector. IntRangeSum2qnBit(val, qn, sum) is a function that converts val in the range from -sum to sum into a value in the range from 0 to (1<<qn)-1. Here, after adding a predetermined value sum to val, multiplying by another predetermined integer (1<<(qn)-1), and then performing integer division by 2*sum (rounding down in the direction of 0). Here, the value of sum is added before dividing by 2*sum. val may be one component (i = 0,1) of the 3D vector, and sum may be the sum of the absolute values of each component (i = 0..2) of val. IntRangeSum2qnBit( val, qn, sum ) { return ((( val + sum ) * (( 1 << ( qn )) - 1)) + sum ) / ( 2 * sum ) }。 IntRangeSum2qnBit may be a function that returns 1 << (qn - 1) when the value of sum is 0. IntRangeSum2qnBit( val, qn, sum ) { if ( sum == 0 ) return 1 << ( qn - 1 ) return ((( val + sum ) * (( 1 << ( qn )) - 1)) + sum ) / ( 2 * sum ) } Alternatively, the sum = 0 (3Dvector[0] = 3Dvector[1] = 3Dvector[2] = 0) may be prohibited. That is, the mesh prediction unit 30311 may be configured to prohibit the zero vector as the predicted value of the base mesh normal vector. As a condition for bitstream conformance, there must be no cases where 3Dvector[0]==0, 3Dvector[1]==0, and 3Dvector[2]==0. Furthermore, a decoding device or encoding device that decodes a bitstream that satisfies such bitstream conformance is used. As a condition for bitstream conformance, it may also be that 3Dvector[0]!=0, 3Dvector[1]!=0, or 3Dvector[2]!=0.

[0123] The `CopySign(mag, sgn)` function sets the sign of `mag` to the sign of `sgn`. In other words, if the sign of `sgn` is positive, the sign of `mag` becomes positive, and if the sign of `sgn` is negative, the sign of `mag` becomes negative. CopySign(mag, sgn) { return (sgn >=0 ) ? +mag : -mag }.

[0124] Alternatively, it can be converted into a two-dimensional vector using the following process. if (3Dvector[2] >= 0){ 2Dvector[0] = IntRangeSum2qnBit(3Dvector[0], qpOcta, sum) 2Dvector[1] = IntRangeSum2qnBit(3Dvector[1], qpOcta, sum) else { 2Dvector[0] = IntRangeSum2qnBit(( sum - Abs( 3Dvector[1] )) * ( 3Dvector[0] >= 0 ? 1 : -1 ), qpOcta, sum ) 2Dvector[1] = IntRangeSum2qnBit(( sum - Abs( 3Dvector[0] )) * ( 3Dvector[1] >= 0 ? 1 : -1 ), qpOcta, sum ) }.

[0125] Using the sum of the absolute values ​​of each component of the 3D vector 3Dvector, if the third component 3Dvector[2] of the 3D vector is 0 or greater, the first component 2Dvector[0] of the 2D vector can be obtained by adding sum to the first component 3Dvector[0] of the 3D vector, multiplying by a predetermined integer, adding sum, and then performing integer division by 2*sum. The same process can be performed on the second component 3Dvector[1] to obtain the second component 2Dvector[1] of the 2D vector. If the third component 3Dvector[2] of the 3D vector is less than 0, the first component 2Dvector[0] of the 2D vector can be obtained by subtracting the second component 3Dvector[1] of the 3D vector from sum and performing the same process. The second component 2Dvector[1] of the 2D vector can be obtained by subtracting the first component 3Dvector[0] of the 3D vector from sum and performing the same process. When subtracting, you may change the sign so that if the 3D vector is positive, the result will be positive, and if it is negative, the result will be negative.

[0126] As described above, by converting from a 3D vector to a 2D vector using integer arithmetic instead of floating-point arithmetic (such as floating-point division), the complexity of the process can be reduced. Furthermore, since the same result is obtained regardless of the execution environment, the conditions for conformance can be easily defined.

[0127] (Conversion from 2D vector to 3D vector) The 2D-3D conversion unit 30313 performs the following process, convert2DoctahedralTo3D.

[0128] The input to this conversion process is a 2D vector 2Dvector[i] (i=0..1) in unsigned integer format. The output of this conversion process is a 3D vector 3Dvector[i] (i=0..2) in unsigned integer format. qpOcta is the bit width of the values ​​of the 3D and 2D vectors.

[0129] First, the values ​​in each dimension of the 2D vector (the 2D vector projected onto an octahedron) are converted to values ​​centered on zero. Then, the inverse transformation of the octahedron projection is performed to convert it into a 3D vector with values ​​centered on zero. center = 1 << ( qpOcta - 1 ) 3Dvector[0] = 2Dvector[0] - center 3Dvector[1] = 2Dvector[1] - center 3Dvector[2] = center - 1 - ( Abs( 2Dvector[0] ) + Abs( 2Dvector[1] )) if (3Dvector[2] < 0) { temporary_x = 3Dvector[0] 3Dvector[0] = CopySign( center - 1 - Abs( 3Dvector[1] ), temporary_x ) 3Dvector[1] = CopySign( center - 1 - Abs( temporary_x ) ), 3Dvector[1] ) }.

[0130] The third component 3Dvector[2] of a 3D vector 3Dvector may also be obtained by subtracting the sum of the absolute values ​​of 2Dvector[0] and 2Dvector[1] from the value of center-1. If the third component 3Dvector[2] of the 3D vector is less than 0, the first component 3Dvector[0] of the 3D vector may be obtained by subtracting the absolute value of 3Dvector[1] (=2Dvector[1]-center) from center-1 and converting the sign so that it has the same sign as the original 3Dvector[0]. Similarly, the second component 3Dvector[1] of the 3D vector may be obtained by subtracting the absolute value of the original 3Dvector[0] (=2Dvector[0]-center) from center-1 and converting the sign so that it has the same sign as 3Dvector[1].

[0131] Next, normalization is performed to convert it into a 3D vector in the range of 0 to (1 << qpOcta) - 1. norm = isqrt(( 3Dvector[0] * 3Dvector[0] + 3Dvector[1] * 3Dvector[1] + 3Dvector[2] * 3Dvector[2] ) << 2 ) >> 1 3Dvector[0] = (( 3Dvector[0] * center ) / norm ) + center 3Dvector[1] = (( 3Dvector[1] * center ) / norm ) + center 3Dvector[2] = (( 3Dvector[2] * center ) / norm ) + center.

[0132] Norm represents the magnitude of a 3D vector and is the square root of the sum of the squares of each component of the 3D vector. The first component of the 3D vector, 3Dvector[0], can also be obtained by multiplying it by center, dividing by norm, and then adding center. The second component, 3Dvector[1], and the third component, 3Dvector[2], can be obtained by the same process. Here, isqrt() is a function that derives the square root using integer arithmetic.

[0133] Normalization can also be performed by rounding during division as follows: norm = isqrt(( 3Dvector[0] * 3Dvector[0] + 3Dvector[1] * 3Dvector[1] + 3Dvector[2] * 3Dvector[2] ) << 2 ) >> 1 3Dvector[0] = (( 3Dvector[0] * center + ( norm >> 1)) / norm ) + center 3Dvector[1] = (( 3Dvector[1] * center + ( norm >> 1)) / norm ) + center 3Dvector[2] = (( 3Dvector[2] * center + ( norm >> 1)) / norm ) + center.

[0134] Alternatively, the 2D-3D conversion unit 30313 may convert a 2D vector (2D normal vector) to a 3D vector by a process that includes division with bit shifts, as shown below. Here, division with bit shifts includes a process that derives a 3D vector from a 2D vector, performs division according to the magnitude norm of the 3D vector, and then performs a right bit shift using the shift value shift.

[0135] The 2D-3D conversion unit 30313 converts a 2D vector into a 3D vector based on a predetermined value scale and a shift value shift. Specifically, it derives a 3D vector from the 2D vector based on the difference between the components of the 2D vector and the predetermined value scale, and then multiplies the derived 3D vector by scale. The value obtained by dividing a 3D vector by its magnitude (norm) is right-shifted by a predetermined shift value (shift), and then a predetermined offset (center) is added to derive the result. The scale may be 2 to the power of an exponent minus 1 (for example, 15, 31, 63, 127, 255, etc.).

[0136] First, the values ​​in each dimension of the 2D vector (the 2D vector projected onto an octahedron) are converted to values ​​centered on zero. Then, the inverse transformation of the octahedron projection is performed to convert it into a 3D vector with values ​​centered on zero. scale = (1 << qpOcta) - 1 3Dvector[0] = 2 * 2Dvector[0] - scale 3Dvector[1] = 2 * 2Dvector[1] - scale 3Dvector[2] = scale - ( Abs( 2Dvector[0] ) + Abs( 2Dvector[1] )) if (3Dvector[2] < 0) { temporary_x = 3Dvector[0] 3Dvector[0] = CopySign( scale - Abs( 3Dvector[1] ), temporary_x ) 3Dvector[1] = CopySign( scale - Abs( temporary_x ) ), 3Dvector[1] ) }.

[0137] The third component 3Dvector[2] of a 3D vector 3Dvector may also be obtained by subtracting the sum of the absolute values ​​of 2Dvector[0] and 2Dvector[1] from the value of scale. If the third component 3Dvector[2] of the 3D vector is less than 0, the first component 3Dvector[0] of the 3D vector may be obtained by subtracting the absolute value of 3Dvector[1] (=2 * 2Dvector[1] - scale) from scale and converting the sign so that it has the same sign as the original 3Dvector[0]. Similarly, the second component 3Dvector[1] of the 3D vector may be obtained by subtracting the absolute value of the original 3Dvector[0] (=2 * 2Dvector[0] - scale) from scale and converting the sign so that it has the same sign as 3Dvector[1].

[0138] Next, normalization is performed to convert it into a 3D vector in the range of 0 to (1 << qpOcta) - 1. norm = isqrt(( 3Dvector[0] * 3Dvector[0] + 3Dvector[1] * 3Dvector[1] + 3Dvector[2] * 3Dvector[2] ) << 2 ) >> 1 3Dvector[0] = ((((( 3Dvector[0] * scale ) / 2 ) << shift ) / norm ) >> shift ) + center 3Dvector[1] = ((((( 3Dvector[1] * scale ) / 2 ) << shift ) / norm ) >> shift ) + center 3Dvector[2] = ((((( 3Dvector[2] * scale ) / 2 ) << shift ) / norm ) >> shift ) + center.

[0139] Here, shift is the bit shift amount when performing division by norm, for example, shift = It may also be 1. The 2D-3D conversion unit 30313 converts the 3D vector by multiplying it by an integer value scale, dividing it by an integer value norm by truncation, and then adding a predetermined integer value center based on the value obtained by right-shifting using a predetermined constant.

[0140] If shift=1, the following process may be used. 3Dvector[0] = ((( 3Dvector[0] * scale ) / norm ) >> 1) + center 3Dvector[1] = ((( 3Dvector[1] * scale ) / norm ) >> 1) + center 3Dvector[2] = ((( 3Dvector[2] * scale ) / norm ) >> 1) + center.

[0141] If shift=2, the following process may be used. 3Dvector[0] = (((( 3Dvector[0] * scale ) << 1) / norm ) >> 2) + center 3Dvector[1] = (((( 3Dvector[1] * scale ) << 1) / norm ) >> 2) + center 3Dvector[2] = (((( 3Dvector[2] * scale ) << 1) / norm ) >> 2) + center.

[0142] Normalization can also be performed by rounding during division as follows: norm = isqrt(( 3Dvector[0] * 3Dvector[0] + 3Dvector[1] * 3Dvector[1] + 3Dvector[2] * 3Dvector[2] ) << 2 ) >> 1 3Dvector[0] = ((((( 3Dvector[0] * scale ) / 2 ) << shift ) + ( norm >> 1 )) / norm ) >> shift ) + center 3Dvector[1] = ((((( 3Dvector[1] * scale ) / 2 ) << shift ) + ( norm >> 1 )) / norm ) >> shift ) + center 3Dvector[2] = ((((( 3Dvector[2] * scale ) / 2 ) << shift ) + ( norm >> 1 )) / norm ) >> shift ) + center.

[0143] Here, shift may be variable depending on the range of values ​​of the 3D normal vector 3Dvector[]. For example, the 2D-3D conversion unit 30313 may derive the shift value shift by selecting one of several options depending on the profile, level, or syntax value.

[0144] Alternatively, the 2D-3D conversion unit 30313 may derive the value of shift by the difference obtained by subtracting the logarithm of the size of the 3D vector from a predetermined constant, as follows. shift = qpOcta - Ceil( log2( Abs( 3Dvector[] ))) Here, Ceil(x) is a function that returns the smallest integer greater than or equal to x. log2(x) is a function that returns the base-2 logarithm of x. Alternatively, qpOcta=16 can be used. If qpOcta=16, the entire process can be implemented using 32-bit arithmetic, thus maintaining precision without increasing computational complexity.

[0145] Here, the isqrt function may also be derived by right-shifting the product of the input x (or the value x0 obtained by right-shifting the input x) and the output of the irsqrt function of x by a predetermined value and adding a predetermined constant of 1, as shown below.

[0146] isqrt(x) { if (x <= (1 << 46)) return 1 + ((x * irsqrt(x)) >> 40) else { x0 = (x + 65536) >> 16; return 1 + ((x0 * irsqrt(x0)) >> 32) } }.

[0147] The irsqrt function may also be defined as follows:

[0148] irsqrt(a64) { if (!a64) return 0 shift = -3 while (a64 & 0xffffffff00000000) { a64 >>= 2 Shift -- } a = a64 while (!(a & 0xc0000000)) { a <<= 2 shift++ } idx = (a >> 25) - 32 r = k3timesR[idx] - ((kRcubed[idx] * a) >> 32) ar = (r * a) >> 32 s = 0x30000000 - ((r * ar) >> 32) r = (r * s) >> 32 if (shift > 0) return r << shift else return r >> - shift }.

[0149] k3timesR

[96] = { 3196059648, 3145728000, 3107979264, 3057647616, 3019898880, 2969567232 2931818496, 2894069760, 2868903936, 2831155200, 2793406464, 2768240640 2730491904, 2705326080, 2667577344, 2642411520, 2617245696, 2592079872 2566914048, 2541748224, 2516582400, 2491416576, 2466250752, 2441084928 2428502016, 2403336192, 2378170368, 2365587456, 2340421632, 2327838720 2302672896, 2290089984, 2264924160, 2252341248, 2239758336, 2214592512 2202009600, 2189426688, 2164260864, ​​2151677952, 2139095040, 2126512128 2113929216, 2101346304, 2088763392, 2076180480, 2051014656, 2038431744 2025848832, 2013265920, 2000683008, 2000683008, 1988100096, 1962934272 1962934272, 1950351360, 1937768448, 1925185536, 1912602624, 1900019712 1900019712, 1887436800, 1874853888, 1862270976, 1849688064, 1849688064 1837105152, 1824522240, 1811939328, 1811939328, 1799356416, 1786773504, 1786773504, 1774190592, 1761607680, 1761607680, 1749024768, 1736441856, 1736441856, 1723858944, 1723858944, 1711276032, 1698693120, 1698693120, 1686110208, 1686110208, 1673527296, 1660944384, 1660944384, 1648361472, 1648361472, 1635778560, 1635778560, 1623195648, 1623195648, 1610612736}.

[0150] kRcubed

[96] = { 4195081216, 3999986688, 3857709056, 3673323520, 3538940928, 3364924416, 3238224896, 3114735616, 3034196992, 2915990528, 2800922624, 2725880832, 2615890944, 2544223232, 2439185408, 2370818048, 2303728640, 2237913088, 2173355008, 2110061568, 2048008192, 1987165184, 1927563264, 1869150208, 1840392192, 1783783424, 1728321536, 1701024768, 1647311872, 1620883456, 1568898048, 1543306240, 1492993024, 1468236800, 1443762176, 1395656704, 1372007424, 1348605952, 1302626304, 1280060416, 1257736192, 1235650560, 1213861888, 1192294400, 1171008512, 1149979648, 1108673536, 1088379904, 1068352512, 1048567808, 1029031936, 1029036032, 1009729536, 971888640, 971882496, 953319424, 934993920, 916897792, 899011584, 881389568, 881392640, 864009216, 846846976, 829900800, 813182976, 813201408, 796721152, 780459008, 764412928, 764417024, 748601344, 732995584, 733017088, 717624320, 702468096, 702466048, 687520768, 672786432, 672787456, 658258944, 658256896, 643947520, 629854208, 629862400, 615976960, 615952384, 602276864, 588779520, 588804096, 575512576, 575526912, 562433024, 562439168, 549556224, 549564416, 536876032}.

[0151] As described above, by converting from a 2D vector to a 3D vector using integer arithmetic instead of floating-point arithmetic (such as floating-point division), the complexity of the process can be reduced. Furthermore, since the same result is obtained regardless of the execution environment, compliance with standards can be easily achieved. The conditions for conformance can be defined.

[0152] (Operation of the mesh decoding unit) The mesh prediction unit 30311 predicts the position vector of the current vertex based on the decoded vertex position vectors and derives the predicted position vectors BmVertexPosFinePred (fine predicted position vector) and BmVertexPosCoarsePred (course predicted position vector).

[0153] The mesh prediction unit 30311 predicts the attributes of the current vertex based on the decoded vertex attributes (texture coordinates, normal vectors), and derives the predicted attributes BmVertexAttrFinePred (fine prediction attribute) and BmVertexAttrCoarsePred (course prediction attribute).

[0154] The mesh prediction unit 30311 may convert the decoded 3D normal vector into a 2D normal vector using the integer arithmetic conversion process described above, and derive a 2D predicted normal vector.

[0155] The basic operation of the CABAC decoding unit (arithmetic decoding unit 3051, multi-leveling unit 3052, context selection unit 3056, context initialization unit 3057) is the same as the operation of the CABAC decoding unit of the mesh displacement decoding unit 305. In arithmetic decoding of the predicted residuals (coefficients) of each vertex position vector and the predicted residuals (coefficients) of attributes, the predicted residuals (coefficients) may be decoded by dividing them into a binaryization consisting of a prefix and a suffix (e.g., exponential Golomb coding, Rice coding). Depending on the prefix / suffix of the predicted residuals (coefficients) (e.g., prefix / suffix part of exponential Golomb coding), fine / coarse, vertex position / attribute, etc., the following arrays of different contexts (the number of elements in the array is shown in []) may be used. The context includes a variable that indicates the probability of a binary signal occurring. ctxCoeffRemPrefixPosFine[nbPfxCtxFine] ctxCoeffRemSuffixPosFine[nbSfxCtxFine] ctxCoeffRemPrefixPosCoarse[nbPfxCtxCoarse] ctxCoeffRemSuffixPosCoarse[nbSfxCtxCoarse] ctxCoeffRemPrefixAttrFine[mesh_attribute_count][nbPfxCtxFine] ctxCoeffRemSuffixAttrFine[mesh_attribute_count][nbSfxCtxFine] ctxCoeffRemPrefixAttrCoarse[mesh_attribute_count][nbPfxCtxCoarse] ctxCoeffRemSuffixAttrCoarse[mesh_attribute_count][nbSfxCtxCoarse] Here, mesh_attribute_count is the number of attributes (texture coordinates, normal vectors, etc.) for each vertex, and is decoded from the sequence-level parameter set (ASPS).

[0156] Here, nbPfxCtxFine, nbSfxCtxFine, nbPfxCtxCoarse, and nbSfxCtxCoarse are the number of contexts, and are fixed values, for example, nbPfxCtxFine = N1 nbSfxCtxFine = N1 nbPfxCtxCoarse = N2 nbSfxCtxCoarse = N2 Here, we can also set N1 >= N2, where the course value is smaller. For example, we can use {N1=6, N2=3}, {N1=5, N2=4}, or {N1=4, N2=4}.

[0157] Alternatively, you can set different values ​​for the prefix and suffix. nbPfxCtxFine = N1A nbSfxCtxFine = N1B nbPfxCtxCoarse = N2A nbSfxCtxCoarse = N2B Here, we can also set N1A >= N1B and N1A >= N1B, where the suffix is ​​smaller. For example, we can set {N1A=6, N1B=5}, {N2A=6, N2B=5} or {N1A=5, N1B=5}, {N2A=5, N2B=5}.

[0158] Alternatively, you can set the same value for both Fine and Course. nbPfxCtxFine = NA nbSfxCtxFine = NB nbPfxCtxCoarse = NA nbSfxCtxCoarse = NB Here, we can also assume that NA >= NB, where the suffix is ​​smaller. For example, {NA=6, You can also use {NB=3}, {NA=5, NB=4}, or {N1=4, N2=4}. You may also set different values ​​for vertex position and attributes.

[0159] ctxCoeffRemPrefixPosFine[nbPfxCtxFine] is an array of contexts used to decode the prefix of the syntax element mesh_position_fine_residual[i][j]. The arithmetic decoding unit 3051 uses the value of ctxCoeffRemPrefixPosFine[min(nbPfxCtxFine - 1, BinIdxPfx)] to decode the bin of the index BinIdxPfx in the binification of the prefix of mesh_position_fine_residual[i][j]. Here, the index is a variable from 0 to bin length N-1 that indicates the bit position of the bin sequence. If the bin sequence is bin0, bin1, bin2, ..., binN-1, then the bins with index BinIdxPfx=0, 1, 2, ..., N-1 correspond to bin0, bin1, bin2, ..., binN-1.

[0160] ctxCoeffRemSuffixPosFine[nbSfxCtxFine] is an array of contexts used to decode the suffix of the syntax element mesh_position_fine_residual[i][j]. The arithmetic decoding unit 3051 uses the value of ctxCoeffRemSuffixPosFine[min(nbSfxCtxFine - 1, BinIdxSfx)] to decode the bin of the index BinIdxSfx in the binaryization of the suffix of mesh_position_fine_residual[i][j].

[0161] ctxCoeffRemPrefixPosCoarse[nbPfxCtxCoarse] is an array of contexts used to decode the prefix of the syntax element mesh_position_coarse_residual[i][j]. The arithmetic decoding unit 3051 uses the value of ctxCoeffRemPrefixPosCoarse[min(nbPfxCtxCoarse - 1, BinIdxPfx)] to decode the bin of the index BinIdxPfx in the binariization of the prefix mesh_position_coarse_residual[i][j].

[0162] ctxCoeffRemSuffixPosCoarse[nbSfxCtxCoarse] is an array of contexts used to decode the suffix of the syntax element mesh_position_coarse_residual[i][j]. The arithmetic decoding unit 3051 uses the value of ctxCoeffRemSuffixPosCoarse[min(nbSfxCtxCoarse - 1, BinIdxSfx)] to decode the bin of the index BinIdxSfx in the binariization of the suffix of mesh_position_coarse_residual[i][j].

[0163] ctxCoeffRemPrefixAttrFine[i][nbPfxCtxFine] is an array of contexts used to decode the prefix of the syntax element mesh_attribute_fine_residual[i][j][k]. The arithmetic decoding unit 3051 uses the value of ctxCoeffRemPrefixAttrFine[i][min(nbPfxCtxFine - 1, BinIdxPfx)] to decode the bin of the index BinIdxPfx in the binariization of the prefix mesh_attribute_fine_residual[i][j][k].

[0164] ctxCoeffRemSuffixAttrFine[i][nbSfxCtxFine] is an array of contexts used for decoding the suffix of the syntax element mesh_attribute_fine_residual[i][j][k]. The arithmetic decoder 3051 uses the value of ctxCoeffRemSuffixAttrFine[i][min(nbSfxCtxFine - 1, BinIdxSfx)] to decode the bin of index BinIdxSfx in the binarization of the suffix of mesh_attribute_fine_residual[i][j][k].

[0165] ctxCoeffRemPrefixAttrCoarse[i][nbPfxCtxCoarse] is an array of contexts used for decoding the prefix of the syntax element mesh_attribute_coarse_residual[i][j][k]. The arithmetic decoder 3051 uses the value of ctxCoeffRemPrefixAttrCoarse[i][min(nbPfxCtxCoarse - 1, BinIdxPfx)] to decode the bin of index BinIdxPfx in the binarization of the prefix of mesh_attribute_coarse_residual[i][j][k].

[0166] ctxCoeffRemSuffixAttrCoarse[i][nbSfxCtxCoarse] is an array of contexts used for decoding the suffix of the syntax element mesh_attribute_coarse_residual[i][j][k]. The arithmetic decoder 3051 uses the value of ctxCoeffRemSuffixAttrCoarse[i][min(nbSfxCtxCoarse - 1, BinIdxSfx)] to decode the bin of index BinIdxSfx in the binarization of the suffix of mesh_attribute_coarse_residual[i][j][k].

[0167] (Configuration that uses context for some bins of prefix / suffix) FIG. 19 shows the setting of the context used by the mesh decoding unit 3031. The mesh decoding unit 3031 (context selection unit 3056) uses, as context, a part of the beginning of the prefix of mesh_position_fine_residual[i][j] (for example, M, where M = numPrefixCtxBinsFine) bins (BinIdxPfx <= numPrefixCtxBinsFine - 1), bypasses the other bins of the prefix (BinIdxPfx > numPrefixCtxBinsFine - 1), uses, as context, a part of the beginning of the suffix (for example, N, where N = numSuffixCtxBinsFine) bins (BinIdxSfx <= numSuffixCtxBinsFine - 1), and may decode by bypassing the other bins of the suffix (BinIdxSfx > numSuffixCtxBinsFine - 1).

[0168] Here, numPrefixCtxBinsFine and numSuffixCtxBinsFine are the number of bins to be context-encoded in the prefix and suffix (the maximum number of bins to be encoded using context), and the fixed values nbPfxCtxFine and nbSfxCtxFine already described are used to numPrefixCtxBinsFine = nbPfxCtxFine numSuffixCtxBinsFine = nbSfxCtxFine may be the case. Alternatively, they may be values larger than nbPfxCtxFine and nbSfxCtxFine, respectively. For example, numPrefixCtxBinsFine = nbPfxCtxFine * 2 numSuffixCtxBinsFine = nbSfxCtxFine * 2 Or numPrefixCtxBinsFine = nbPfxCtxFine + NN numSuffixCtxBinsFine = nbSfxCtxFine + NN This is also acceptable. (NN=1,2,3, etc.) If BinIdxPfx <= numPrefixCtxBinsFine - 1, the arithmetic decoding unit 3051 uses the value of ctxCoeffRemPrefixPosFine[min(nbPfxCtxFine - 1, BinIdxPfx)] to decode the bin of the index BinIdxPfx in the binarization of the prefix mesh_position_fine_residual[i][j]. If BinIdxPfx > numPrefixCtxBinsFine - 1, the arithmetic decoding unit 3051 decodes the bin of the index BinIdxPfx in the binarization of the prefix mesh_position_fine_residual[i][j] using a bypass.

[0169] If BinIdxSfx <= numSuffixCtxBinsFine - 1, the arithmetic decoding unit 3051 uses the value of ctxCoeffRemSuffixPosFine[min(nbSfxCtxFine - 1, BinIdxSfx)] to decode the bin of the index BinIdxSfx in the binaridization of the suffix of mesh_position_fine_residual[i][j]. If BinIdxSfx > numSuffixCtxBinsFine - 1, the arithmetic decoding unit 3051 decodes the bin of the index BinIdxSfx in the binaridization of the suffix of mesh_position_fine_residual[i][j] using a bypass.

[0170] The mesh decoding unit 3031 (context selection unit 3056) may decode by using the following method: select the bin(BinIdxPfx <= numPrefixCtxBinsCoarse - 1) of the first part of the prefixes in mesh_position_coarse_residual[i][j] (e.g., M prefixes, M=numPrefixCtxBinsCoarse) as the context, and bypass the other bin(BinIdxPfx > numPrefixCtxBinsCoarse - 1) of the prefixes; select the bin(BinIdxSfx <= numSuffixCtxBinsCoarse - 1) of the first part of the suffixes (e.g., N suffixes, N=numSuffixCtxBinsCoarse) as the context, and bypass the other bin(BinIdxSfx > numSuffixCtxBinsCoarse - 1) of the suffixes.

[0171] Here, numPrefixCtxBinsCoarse and numSuffixCtxBinsCoarse are the number of bins to context-encode in the prefix / suffix, and using the fixed values ​​nbPfxCtxCoarse and nbSfxCtxCoarse already explained... numPrefixCtxBinsCoarse = nbPfxCtxCoarse numSuffixCtxBinsCoarse = nbSfxCtxCoarse It may also be a value greater than nbPfxCtxCoarse and nbSfxCtxCoarse, respectively. For example, numPrefixCtxBinsCoarse = nbPfxCtxCoarse * 2 numSuffixCtxBinsCoarse = nbSfxCtxCoarse * 2 or numPrefixCtxBinsCoarse = nbPfxCtxCoarse + NN numSuffixCtxBinsCoarse = nbSfxCtxCoarse + NN This is also acceptable. (NN=1,2,3, etc.) That's fine.

[0172] If BinIdxPfx <= numPrefixCtxBinsCoarse - 1, the arithmetic decoding unit 3051 uses the value of ctxCoeffRemPrefixPosCoarse[min(nbPfxCtxCoarse - 1, BinIdxPfx)] to decode the bin of the index BinIdxPfx in the binaryization of the prefix mesh_position_coarse_residual[i][j]. If BinIdxPfx > numPrefixCtxBinsCoarse - 1, the arithmetic decoding unit 3051 decodes the bin of the index BinIdxPfx in the binaryization of the prefix mesh_position_coarse_residual[i][j] using a bypass.

[0173] If BinIdxSfx <= numSuffixCtxBinsCoarse - 1, the arithmetic decoding unit 3051 uses the value of ctxCoeffRemSuffixPosCoarse[min(nbSfxCtxCoarse - 1, BinIdxSfx)] to decode the bin of the index BinIdxSfx in the binaridization of the suffix of mesh_position_coarse_residual[i][j]. If BinIdxSfx > numSuffixCtxBinsCoarse - 1, the arithmetic decoding unit 3051 decodes the bin of the index BinIdxSfx in the binaridization of the suffix of mesh_position_coarse_residual[i][j] using a bypass.

[0174] Figure 20 shows the context settings used by the mesh decoding unit 3031. The mesh decoding unit 3031 (context selection unit 3056) may decode using a portion of the leading bins of the prefix of mesh_attribute_fine_residual[i][j][k] as the context and the remaining bins of the prefix as the bypass, or using a portion of the leading bins of the suffix as the context and the remaining bins of the suffix as the bypass.

[0175] If BinIdxPfx <= numPrefixCtxBinsFine - 1, the arithmetic decoding unit 3051 uses the value of ctxCoeffRemPrefixAttrFine[i][min(nbPfxCtxFine - 1, BinIdxPfx)] to decode the bin of the index BinIdxPfx in the binaryization of the prefix mesh_attribute_fine_residual[i][j][k]. If BinIdxPfx > numPrefixCtxBinsFine - 1, the arithmetic decoding unit 3051 decodes the bin of the index BinIdxPfx in the binaryization of the prefix mesh_attribute_fine_residual[i][j][k] using a bypass.

[0176] If BinIdxSfx <= numSuffixCtxBinsFine - 1, the arithmetic decoding unit 3051 uses the value of ctxCoeffRemSuffixAttrFine[i][min(nbSfxCtxFine - 1, BinIdxSfx)] to decode the bin of the index BinIdxSfx in the binaryization of the suffix of mesh_attribute_fine_residual[i][j][k]. If BinIdxSfx > numSuffixCtxBinsFine - 1, the arithmetic decoding unit 3051 decodes the bin of the index BinIdxSfx in the binaryization of the suffix of mesh_attribute_fine_residual[i][j][k] using a bypass.

[0177] The mesh decoding unit 3031 (context selection unit 3056) may decode using a portion of the leading bins of the prefix of mesh_attribute_coarse_residual[i][j][k] as the context and the other bins of the prefix as the bypass, or using a portion of the leading bins of the suffix as the context and the other bins of the suffix as the bypass.

[0178] If BinIdxPfx <= numPrefixCtxBinsCoarse - 1, the arithmetic decoding unit 3051 uses the value of ctxCoeffRemPrefixAttrCoarse[i][min(nbPfxCtxCoarse - 1, BinIdxPfx)] to decode the bin of the index BinIdxPfx in the binaryization of the prefix mesh_attribute_coarse_residual[i][j][k]. If BinIdxPfx > numPrefixCtxBinsCoarse - 1, the arithmetic decoding unit 3051 decodes the bin of the index BinIdxPfx in the binaryization of the prefix mesh_attribute_coarse_residual[i][j][k] using a bypass.

[0179] If BinIdxSfx <= numSuffixCtxBinsCoarse - 1, the arithmetic decoding unit 3051 uses the value of ctxCoeffRemSuffixAttrCoarse[i][min(nbSfxCtxCoarse - 1, BinIdxSfx)] to decode the bin of the index BinIdxSfx in the binaryization of the suffix of mesh_attribute_coarse_residual[i][j][k]. If BinIdxSfx > numSuffixCtxBinsCoarse - 1, the arithmetic decoding unit 3051 decodes the bin of the index BinIdxSfx in the binaryization of the suffix of mesh_attribute_coarse_residual[i][j][k] using a bypass.

[0180] According to the above, even when the value to be ExpGolomb-encoded becomes large, only a maximum of numPrefixCtxBinsFine / numSuffixCtxBinsFine / numPrefixCtxBinsCoarse / numPrefixCtxBinsCoarse contexts are used, so the complexity can be reduced compared to using contexts for all bins of the residual. Also, it can be encoded more efficiently than when bypassing is used for all bins.

[0181] (Configuration for limiting the number of context-encoded bins to be decoded) To reduce the complexity of context encoding, the number of context-encoded bins may be limited. Specifically, the mesh decoding unit 3031 (context selection unit 3056) counts the number of bins decoded by context encoding in the prefix / suffix of each syntax element of mesh_position_fine_residual / mesh_position_coarse_residual / mesh_attribute_fine_residual / mesh_attribute_coarse_residual for a predetermined unit (for example, for each predetermined number of vertices). And when the value is greater than or equal to a predetermined value, each bin of the prefix / suffix may be switched from decoding using a context to decoding without using a context (bypass, using a static context).

[0182] According to the above, the maximum value (worst case) of the number of bins to be context-encoded can be reduced.

[0183] (Sharing of contexts) In the above configuration, independent contexts are used for vertex position / attribute, fine / coarse, and prefix / suffix, but some contexts may be shared. Here, sharing the contexts of A and B means that in the mesh decoding unit 3031, A This means that the syntax elements corresponding to B, such as vertices and attributes, are encoded and decoded using the same context (a single context array). Instead of ctxCoeffRemA[] and ctxCoeffRemB[], you may also use ctxCoeffRemA[] or ctxCoeffRemB[], or ctxCoeffRem[] of the same size.

[0184] For example, some or all of the following may be applied to vertex positions / attributes. 1) Share ctxCoeffRemPrefixPosFine[nbPfxCtxFine] and ctxCoeffRemPrefixAttrFine[mesh_attribute_count][nbPfxCtxFine]. (For example, use ctxCoeffRemPrefixFine[nbPfxCtxFine]) 2) Share ctxCoeffRemSuffixPosFine[nbSfxCtxFine] and ctxCoeffRemSuffixAttrFine[mesh_attribute_count][nbSfxCtxFine]. 3) Share ctxCoeffRemPrefixPosCoarse[nbPfxCtxCoarse] and ctxCoeffRemPrefixAttrCoarse[mesh_attribute_count][nbPfxCtxCoarse]. 4) Share ctxCoeffRemSuffixPosCoarse[nbSfxCtxCoarse] and ctxCoeffRemSuffixAttrCoarse[mesh_attribute_count][nbSfxCtxCoarse].

[0185] Alternatively, some or all of the following may apply to fine / course: 5) Share ctxCoeffRemPrefixPosFine[nbPfxCtxFine] and ctxCoeffRemPrefixPosCoarse[nbPfxCtxCoarse]. 6) Share ctxCoeffRemSuffixPosFine[nbSfxCtxFine] and ctxCoeffRemSuffixPosCoarse[nbSfxCtxCoarse]. 7) Share ctxCoeffRemPrefixAttrFine[mesh_attribute_count][nbPfxCtxFine] and ctxCoeffRemPrefixAttrCoarse[mesh_attribute_count][nbPfxCtxCoarse]. 8) Share ctxCoeffRemSuffixAttrFine[mesh_attribute_count][nbSfxCtxFine] and ctxCoeffRemSuffixAttrCoarse[mesh_attribute_count][nbSfxCtxCoarse]. Sharing the context between A and B here means that in the mesh decoding unit 3031, for example, the same context (a single context array) is used for encoding and decoding for fine and coarse.

[0186] Alternatively, you may apply some or all of the following to prefixes / suffixes: 9) Share ctxCoeffRemPrefixPosFine[nbPfxCtxFine] and ctxCoeffRemSuffixPosFine[nbSfxCtxFine]. 10) Share ctxCoeffRemPrefixPosCoarse[nbPfxCtxCoarse] and ctxCoeffRemSuffixPosCoarse[nbSfxCtxCoarse]. 11) Share ctxCoeffRemPrefixAttrFine[mesh_attribute_count][nbPfxCtxFine] and ctxCoeffRemSuffixAttrFine[mesh_attribute_count][nbSfxCtxFine]. 12) Share ctxCoeffRemPrefixAttrCoarse[mesh_attribute_count][nbPfxCtxCoarse] and ctxCoeffRemSuffixAttrCoarse[mesh_attribute_count][nbSfxCtxCoarse]. Sharing the contexts of A and B here means that in the mesh decoding unit 3031, the same context (a single context array) is used for encoding and decoding, for example, for the prefix and suffix.

[0187] Alternatively, the following may be applied to the suffix: 13) ctxCoeffRemSuffixPosFine[nbSfxCtxFine], ctxCoeffRemSuffixPosCoarse[nbSfxCtxCoarse], ctxCoeffRemSuffixAttrFin Share e[mesh_attribute_count][nbSfxCtxFine], ctxCoeffRemSuffixAttrCoarse[mesh_attribute_count][nbSfxCtxCoarse].

[0188] According to the above, the memory used in the context can be significantly reduced without decreasing encoding efficiency. It is possible.

[0189] (Mesh derivation process) The mesh decoding unit 3031 decodes the syntax element mesh_position_fine_residual from the encoded data through the following process and derives the base mesh vertex position vector prediction residual BmVertexPosFinePredResidual. if (mesh_position_fine_residuals_count > 0) { for (j = 0; j < 3; j++) { / / dimension (component) loop for (i = 0; i < mesh_position_fine_residuals_count; i++) { / / decode mesh_position_fine_residual[i][j] value = decodeTUExpGolombS(ctxCoeffRemPrefixPosFine, ctxCoeffRemSuffixPosFine) BmVertexPosFinePredResidual[i][j] = value } } } The mesh decoding unit 3031 decodes the syntax element mesh_position_coarse_residual from the encoded data through the following process and derives the base mesh vertex position vector prediction residual BmVertexPosCoarsePredResidual. if (mesh_position_coarse_residuals_count > 0) { for (j = 0; j < 3; j++) { / / dimension (component) loop for (i = 0; i < mesh_position_coarse_residuals_count; i++) { / / decode mesh_position_coarse_residual[i][j] value = decodeTUExpGolombS(ctxCoeffRemPrefixPosCoarse, ctxCoeffRemSuffixPosCoarse) BmVertexPosCoarsePredResidual[i][j] = value } } } The mesh decoding unit 3031 decodes the syntax element mesh_attribute_fine_residual from the encoded data through the following process and derives the base mesh attribute prediction residual (texture coordinate prediction residual, normal vector prediction residual) BmVertexAttrFinePredResidual. for (i = 0; i < mesh_attribute_count; i++) { if (mesh_attribute_fine_residuals_count[i] > 0) { for (j = 0; j < mesh_attribute_fine_residuals_count[i]; j++) { for (k = 0; k < NumComponents[i]; k++) { / / dimension (component) loop / / decode mesh_attribute_fine_residual[i][j][k] value = decodeTUExpGolombS(ctxCoeffRemPrefixAttrFine[i], ctxCoeffRemSuffixAttrFine[i]) BmVertexAttrFinePredResidual[i][j][k] = value } } } } The mesh decoding unit 3031 decodes the syntax element mesh_attribute_coarse_residual from the encoded data through the following process and derives the base mesh attribute prediction residual (texture coordinate prediction residual, normal vector prediction residual) BmVertexAttrCoarsePredResidual. for (i = 0; i < mesh_attribute_count; i++) { if (mesh_attribute_coarse_residuals_count[i] > 0) { for (j = 0; j < mesh_attribute_coarse_residuals_count[i]; j++) { for (k = 0; k < NumComponents[i]; k++) { / / dimension (component) loop / / decode mesh_attribute_coarse_residual[i][j][k] Value = decodeTUExpGolombS(ctxCoeffRemPrefixAttrCoarse[i], ctxCoeffRemSuffixAttrCoarse[i]) BmVertexAttrCoarsePredResidual[i][j][k] = value } } } } The mesh decoding unit 3031 may, if the normal vector prediction residual is a two-dimensional vector, add the two-dimensional prediction normal vector and the prediction residual to derive a two-dimensional normal vector, and then use the integer arithmetic conversion process described above to convert the two-dimensional normal vector into a three-dimensional normal vector to derive (reconstruct) a three-dimensional normal vector.

[0190] If the normal vector prediction residual is a two-dimensional vector, the mesh decoding unit 3031 may further arithmetically decode a second prediction residual (the difference between the original three-dimensional normal vector and the reconstructed three-dimensional normal vector), add it to the reconstructed three-dimensional normal vector, and derive (reconstruct) the final three-dimensional normal vector. This configuration allows for even higher quality decoding of the normal vector of the base mesh.

[0191] (Prediction and derivation of the normal vector) The mesh decoding unit 3031 uses decodeOctahedral, described later, to take the attribute index attrIndex and the corner index c to be predicted as input and derives the arrays of the corrected VertexMarkingArray, AuxiliaryStartIndex[attrIndex], AuxiliaryDeltaIndex[attrIndex], and AttrValues[attrIndex].

[0192] Here, PreviousCorner is the following function: PreviousCorner( corner ) { return( corner < 0 ) ? -1 : ( corner % 3 ? corner - 1 : corner + 2 ) }.

[0193] Here, GetVertexIndex is the following function. GetVertexIndex( cornerToVertexArray, corner ) { return ( corner < 0 ) ? -1 : cornerToVertexArray[ corner ] }.

[0194] Floor(x) is a function that returns the largest integer less than or equal to x.

[0195] The Round(x) function returns an integer obtained by rounding x to the first decimal place. Round( x ) = Sign( x ) * Floor( Abs(x) + 0.5 ).

[0196] The Sign(x) function returns 1 if x is greater than 0, 0 if x is equal to 0, and -1 if x is less than 0. Sign( x ) = 1 (x > 0), 0 (x = 0), -1 (x < 0).

[0197] Clip3(x, y, z) is a function that returns x if the value of z is less than x, y if the value of z is greater than or equal to y, and z otherwise (the value of z is greater than or equal to x and less than or equal to y).

[0198] The function `normalize(x)` converts the input x into a vector of length 1.

[0199] `mesh_attribute_prediction_method` is a syntax that indicates the method for predicting attributes to be decoded from encoded data, and can take one of the following values: `MESH_NORMAL_DELTA`, `MESH_NORMAL_MPARA`, or `MESH_NORMAL_CROSS`.

[0200] `decodeOctahedral` is a function that decodes the predicted residual of the octahedral-projected 2D normal vector (described later) to derive (reconstruct) the 3D normal vector. maxParallelograms = 4 v = auxV[c] If mV[v] is greater than 0, the normal vector of vertex v has already been predicted, so the following processing is omitted. mV[v] = 1 predNorm[0] = 0 predNorm[1] = 0 predNorm[2] = 0 altC = c onSeam = ( hasOwnIndices ? ( auxO[NextCorner( altC )] == -2 ) : 0 ) nextC = NextCorner( O[NextCorner( altC )] ) while ( nextC >= 0 && nextC != c && !onSeam ) { altC = nextC onSeam = ( hasOwnIndices ? ( auxO[NextCorner( altC )] == -2 ) : 0 ) nextC = NextCorner( pO[NextCorner( altC )] ) } isBoundary = (!onSeam && nextC != c ) count = 0 startC = altC if ( mesh_attribute_prediction_method == MESH_NORMAL_MPARA ){ give { if (count >= maxParalleCeilrams) break; oppoV = (hasOwnIndices && auxO[altC] == -2 ) ? -1 : GetVertexIndex( auxV , pO[altC] ) prevV = GetVertexIndex( auxV , PreviousCorner( altC ) ) nextV = GetVertexIndex( auxV , NextCorner( altC ) ) if( (oppoV > -1 && prevV > -1 && nextV > -1 ) && ( ( mV[oppoV] > 0 ) && ( mV[prevV] > 0 ) && ( mV[nextV] > 0 ) ) { predictNormPara(attrIndex, altC, auxV, predNorm) ++count } onSeam = ( hasOwnIndices ? ( auxO[PreviousCorner( altC )] == -2 ) : 0 ) altC = PreviousCorner( pO[PreviousCorner( altC )] ) } while (altC >= 0 && altC != startC && !onSeam) } if ( mesh_attribute_prediction_method == MESH_NORMAL_CROSS ){ do { prevV = GetVertexIndex( auxV , PreviousCorner( altC ) ) nextV = GetVertexIndex( auxV , NextCorner( altC ) ) if( prevV > -1 && nextV > -1 ) { predictNormCross( altC, pV, predNorm) ++count } onSeam = ( hasOwnIndices ? ( auxO[PreviousCorner( altC )] == -2 ) : 0 ) altC = PreviousCorner( pO[PreviousCorner( altC )] ) } while (altC >= 0 && altC != startC && !onSeam) } if( count > 0 ) { if ( mesh_attribute_prediction_method == MESH_NORMAL_MPARA ){ predNorm[0] = Round( predNorm[0] ÷ count + Floor( mesh_attribute_min[index][0] ÷ stepNorm + 0.5) predNorm[1] = Round( predNorm[1] ÷ count + Floor( mesh_attribute_min[index][1] ÷ stepNorm + 0.5) predNorm[2] = Round( predNorm[2] ÷ count + Floor( mesh_attribute_min[index][2] ÷ stepNorm + 0.5) } predNorm = normalize( predNorm ) predNorm[0] = Clip3( 0, 1 << qn -1, Floor( ( predNorm[0] - mesh_attribute_min[index][0] ) ÷ stepNorm + 0.5 ) ) predNorm[1] = Clip3( 0, 1 << qn -1, Floor( ( predNorm[1] - mesh_attribute_min[index][1] ) ÷ stepNorm + 0.5 ) ) predNorm[2] = Clip3( 0, 1 << qn -1, Floor( ( predNorm[2] - mesh_attribute_min[index][2] ) ÷ stepNorm + 0.5 ) ) if ( mesh_normal_octahedral_flag[attrIndex] ) { residual = mesh_attribute_residual[attrIndex][auxDeltaIndex] decodeOctahedral( attrIndex, predNorm, residual, auxNorm[v] ) } else { auxNorm[0] = mesh_attribute_residual[attrIndex][auxDeltaIndex][0] + predNorm[0] auxNorm[1] = mesh_attribute_residual[attrIndex][auxDeltaIndex][1] + predNorm[1] auxNorm[2] = mesh_attribute_residual[attrIndex][auxDeltaIndex][2] + predNorm[2] } auxDeltaIndex = auxDeltaIndex + 1 return } prevV = GetVertexIndex( auxV , PreviousCorner( c ) ) nextV = GetVertexIndex( auxV , NextCorner( c ) ) if( prevV > -1 && mV[prevV] > -1 ) { if( mesh_normal_octahedral_flag[attrIndex] ) { prediction = auxNorm[prevV] residual = mesh_attribute_coarse_residual[attrIndex][auxDeltaCoarseIndex] decodeOctahedral( attrIndex, prediction, residual, auxNorm[v] ) } else { auxNorm[v][0] = mesh_attribute_coarse_residual[attrIndex][auxDeltaCoarseIndex][0] + auxNorm[prevV][0] auxNorm[v][1] = mesh_attribute_coarse_residual[attrIndex][auxDeltaCoarseIndex][1] + auxNorm[prevV][1] auxNorm[v][2] = mesh_attribute_coarse_residual[attrIndex][auxDeltaCoarseIndex][2] + auxNorm[prevV][2] } auxDeltaCoarseIndex = auxDeltaCoarseIndex + 1 return } if( nextV > -1 && MV[nextV] > -1 ) { if ( mesh_normal_octahedral_flag[attrIndex] ) { prediction = auxNorm[nextV] residual = mesh_attribute_coarse_residual[attrIndex][auxDeltaCoarseIndex] decodeOctahedral( attrIndex, prediction, residual, auxNorm[v] ) } else { auxNorm[v][0] = mesh_attribute_coarse_residual[attrIndex][auxDeltaCoarseIndex][0] + auxNorm[nextV][0] auxNorm[v][1] = mesh_attribute_coarse_residual[attrIndex][auxDeltaCoarseIndex][1] + auxNorm[nextV][1] auxNorm[v][2] = mesh_attribute_coarse_residual[attrIndex][auxDeltaCoarseIndex][2] + auxNorm[nextV][2] } auxDeltaCoarseIndex = auxDeltaCoarseIndex + 1 return } if( isBoundary ) { b = PreviousCorner( startC ) bV = GetVertexIndex( pV, b ) if ( mV[bV] > -1 ) { if ( mesh_normal_octahedral_flag[attrIndex] ) { prediction = auxNorm[bV] residual = mesh_attribute_coarse_residual[attrIndex][auxDeltaCoarseIndex] decodeOctahedral( attrIndex, prediction, residual, auxNorm[v] ) } else { auxNorm[v][0] = mesh_attribute_coarse_residual[attrIndex][auxDeltaCoarseIndex][0] + auxNorm[bV][0] auxNorm[v][1] = mesh_attribute_coarse_residual[attrIndex][auxDeltaCoarseIndex][0] + auxNorm[bV][1] auxNorm[v][2] = mesh_attribute_coarse_residual[attrIndex][auxDeltaCoarseIndex][2] + auxNorm[bV][2] } auxDeltaCoarseIndex = auxDeltaCoarseIndex + 1 return } } auxNorm[v][0] = mesh_attribute_start[attrIndex][auxStartIndex][0] auxNorm[v][1] = mesh_attribute_start[attrIndex][auxStartIndex][1] auxNorm[v][2] = mesh_attribute_start[attrIndex][auxStartIndex][2] auxStartIndex = auxStartIndex + 1.

[0201] (Decode the octahedral normal) The mesh decoding unit 3031 performs the following operations using the 3D-2D conversion unit 30312's process convert3Dto2Doctahedral and the 2D-3D conversion unit 30313's process convert2DoctahedralTo3D: it derives the 3D normal vector reconstructed from the attribute index attrIndex of the target to be predicted, the 3D predicted normal vector prediction, and the 2D octahedral representation of the first normal residual residual residual. Here, if the flag second_residual_flag is true, the second normal residual secondRes is added. decodeOctahedral( ​​attrIndex, prediction, residual, reconstructed ) { pred2D = convert3Dto2Doctahedral( ​​attrIndex, prediction ) rec_2D = pred2D + residual rec_3D_without_second_residual = convert2DoctahedralTo3D( attrIndex, rec_2D ) if( second_residual_flag ) { reconstructed[0] = rec_3D_without_second_residual[0] + secondRes[attrIndex][normSecondResidualIndex][0] reconstructed[1] = rec_3D_without_second_residual[1] + secondRes[attrIndex][normSecondResidualIndex][1] reconstructed[2] = rec_3D_without_second_residual[2] + secondRes[attrIndex][normSecondResidualIndex][2] normSecondResidualIndex = normSecondResidualIndex + 1 else { reconstructed = rec_3D_without_second_residual } return reconstructed }.

[0202] Here, decodeTUExpGolombS() is a process that arithmetically decodes the offset, prefix, suffix, and sign of the predicted residual value using the given context. Alternatively, the binaryization obtained by concatenating the truncated unary code (TU) with the maximum value maxOffset, the k-th exponential Golomb code (ExpGolumb), and the code (S) may be decoded as follows. First, parse (decode) the truncated unary encoded offset. offset = 0 for(BinIdxTu = 0; offset < maxOffset && dec_aebin() == 1; BinIdxTu++) offset++ Next, if offset == maxOffset, the unary encoded prefix is ​​parsed (decoded). prefix=0 if(offset == maxOffset) { for (BinIdxPfx = ​​0; dec_aebin() != 0; BinIdxPfx++) prefix++ } Next, if offset == maxOffset, parse (decode) the suffix. suffix = 0 if(offset == maxOffset) { for(BinIdxSfx = 0; BinIdxSfx < k + prefix; BinIdxSfx++) suffix = (suffix << 1) + dec_aebin() } The output is a signed integer `val`, which is parsed as follows: if(offset > 0) { sign = Dec_aebin() absVal = offset + (1 << (prefix + k)) + suffix - (1 << k) val = sign ? - absVal : absVal else { val = 0 } Here, dec_aebin() indicates that one bin will be decoded.

[0203] The mesh decoding unit 3031 derives the base mesh vertex position vectors BmVertexPosFine and BmVertexPosCoarse through the following process. BmVertexPosFine = BmVertexPosFinePred + BmVertexPosFinePredResidual BmVertexPosCoarse = BmVertexPosCoarsePred + BmVertexPosCoarsePredResidual Alternatively, the following formula may also be used. BmVertexPosFine[i][j] = BmVertexPosFinePred[i][j] + BmVertexPosFinePredResidual[i][j] i=0..mesh_position_fine_residuals_count-1, j=0..2 BmVertexPosCoarse[i][j] = BmVertexPosCoarsePred[i][j] + BmVertexPosCoarsePredResidual[i][j] i=0..mesh_position_coarse_residuals_count-1, j=0..2 The mesh decoding unit 3031 derives the base mesh attributes BmVertexAttrFine and BmVertexAttrCoarse through the following process. BmVertexAttrFine = BmVertexAttrFinePred + BmVertexAttrFinePredResidual BmVertexAttrCoarse = BmVertexAttrCoarsePred + BmVertexAttrCoarsePredResidual Alternatively, the following formula may also be used. BmVertexAttrFine[i][j][k] = BmVertexAttrFinePred[i][j][k] + BmVertexAttrFinePredResidual[i][j][k] i=0.. mesh_attribute_count-1, j=0.. mesh_attribute_fine_residuals_count-1, k=0.. NumComponents[i]-1 BmVertexAttrCoarse[i][j][k] = BmVertexAttrCoarsePred[i][j][k] + BmVertexAttrCoarsePredResidual[i][j][k] i=0.. mesh_attribute_count-1, j=0.. mesh_attribute_coarse_residuals_count-1, k=0.. NumComponents[i]-1 (Mesh reconstruction) Figure 6 is a functional block diagram showing the configuration of the mesh reconstruction unit 307. The mesh reconstruction unit 307 consists of a mesh division unit 3071 and a mesh deformation unit 3072.

[0204] The mesh division unit 3071 divides the base mesh output from the base mesh decoding unit 303 and generates divided meshes.

[0205] Figure 9(a) shows a part of the base mesh (a triangle), which is composed of vertices v1, v2, and v3. v1, v2, and v3 are 3D vectors. The mesh division unit 3071 generates and outputs a divided mesh by adding new vertices v12, v13, and v23 in the middle of each side of the triangle (Figure 9(b)). v12 = (v1 + v2) / 2 v13 = (v1 + v3) / 2 v23 = (v2 + v3) / 2 The following is also acceptable. v12 = (v1 + v2 + 1) >> 1 v13 = (v1 + v3 + 1) >> 1 v23 = (v2 + v3 + 1) >> 1 The mesh deformation unit 3072 receives the divided mesh and the mesh displacement, and the mesh displacement d12, A deformed mesh is generated and output by adding d13 and d23 (Figure 9(c)). The mesh displacement is the output of the mesh displacement decoding unit 305 (coordinate system transformation unit 3055). d12, d13, and d23 are the mesh displacements corresponding to the vertices v12, v13, and v23 added by the mesh division unit 3071. v12' = v12 + d12 v13' = v13 + d13 v23' = v23 + d23 Note that d12 = disp[0][], d23 = disp[1][], and d23 = disp[3][] are also acceptable.

[0206] (Configuration of the 3D data encoding device according to the first embodiment) Figure 10 is a functional block diagram showing the schematic configuration of the 3D data encoding device 11 according to the first embodiment. The 3D data encoding device 11 consists of an atlas information encoding unit 101, a base mesh encoding unit 103, a base mesh decoding unit 104, a mesh displacement update unit 106, a mesh displacement encoding unit 107, a mesh displacement decoding unit 108, a mesh reconstruction unit 109, an attribute update unit 110, a padding unit 111, a color space conversion unit 112, an attribute encoding unit 113, a multiplexing unit 114, and a mesh separation unit 115. The 3D data encoding device 11 takes atlas information, a base mesh, mesh displacement, a mesh, and an attribute image as input as 3D data and outputs encoded data.

[0207] The Atlas information encoding unit 101 encodes the Atlas information and outputs an Atlas information encoded stream.

[0208] The base mesh encoding unit 103 encodes the base mesh and outputs a base mesh encoded stream. The encoding method used is typically Draco.

[0209] The base mesh decoding unit 104 is the same as the base mesh decoding unit 303, so its explanation is omitted.

[0210] The mesh displacement update unit 106 adjusts the mesh displacement based on the (original) base mesh and the decoded base mesh, and outputs the updated mesh displacement.

[0211] The mesh displacement coding unit 107 codes the updated mesh displacement and outputs a mesh displacement coding stream.

[0212] The mesh displacement decoding unit 108 is the same as the mesh displacement decoding unit 305, so its explanation is omitted.

[0213] The mesh reconstruction unit 109 is the same as the mesh reconstruction unit 307, so its description is omitted.

[0214] The attribute update unit 110 receives the (original) mesh, the reconstructed mesh output from the mesh reconstruction unit 109 (mesh deformation unit 3072), and the attribute image as input, updates the attribute image to match the position (coordinates) of the reconstructed mesh, and outputs the updated attribute image.

[0215] The padding unit 111 receives an attribute image as input and performs padding on areas where the pixel value is empty.

[0216] The color space conversion unit 112 performs a color space conversion from RGB format to YCbCr format.

[0217] The attribute encoding unit 113 encodes the attribute image in YCbCr format output from the color space conversion unit 112 and outputs an attribute video stream. The encoding method used may include VVC or HEVC.

[0218] The multiplexing unit 114 multiplexes the atlas information encoded stream, base mesh encoded stream, mesh displacement encoded stream, and attribute video stream and outputs them as encoded data. The multiplexing method used is a byte stream format, ISOBMFF, etc.

[0219] (Operation of the mesh separation unit) The mesh separation unit 115 generates a base mesh and mesh displacement from the mesh.

[0220] Figure 13 is a functional block diagram showing the configuration of the mesh separation unit 115. The mesh separation unit 115 consists of a mesh thinning unit 1151, a mesh division unit 1152, and a mesh displacement extraction unit 1153.

[0221] The mesh thinning unit 1151 generates a base mesh by thinning out some vertices from the mesh.

[0222] Figure 14(a) shows a portion of the mesh, where the mesh consists of vertices v1, v2, v3, v4, v5, It consists of v6. v1, v2, v3, v4, v5, and v6 are each 3D vectors. The mesh thinning unit 1151 generates and outputs a base mesh by thinning out vertices v4, v5, and v6 (Figure 14(b)).

[0223] The mesh division unit 1152, like the mesh division unit 3071, divides the base mesh and generates a divided mesh (Figure 14(c)). v4' = (v1 + v2) / 2 v5' = (v1 + v3) / 2 v6' = (v2 + v3) / 2 The mesh displacement derivation unit derives and outputs the displacements d4, d5, and d6 of vertices v4, v5, and v6 for vertices v4', v5', and v6', respectively, as mesh displacements, based on the mesh and the subdivided mesh (Figure 14(d)). d4 = v4 - v4' d5 = v5 - v5' d6 = v6 - v6' (Encoding of the base mesh) Figure 11 is a functional block diagram showing the configuration of the base mesh coding unit 103. The base mesh coding unit 103 consists of a mesh coding unit 1031, a mesh decoding unit 1032, a motion information coding unit 1033, a motion information decoding unit 1034, a mesh motion compensation unit 1035, a reference mesh memory 1036, a switch 1037, and a switch 1038. The base mesh coding unit 103 may also include a base mesh quantization unit (not shown) after the input of the base mesh. Switches 1037 and 3038 are connected to the side that does not perform motion compensation when the base mesh is coded without referencing other base meshes (e.g., already coded base meshes) (intra coding). Instead, they are connected to the side that performs motion compensation when the base mesh is coded by referencing other base meshes (inter coding).

[0224] The mesh coding unit 1031 has an intra coding function, intra-codes the base mesh, and outputs a base mesh coded stream. The coding method used is Draco, among others.

[0225] The mesh decoding unit 1032 is the same as the mesh decoding unit 3031, so its description is omitted.

[0226] The motion information coding unit 1033 has an intercoding function, intercodes the base mesh, and outputs a base mesh coded stream. Entropy coding such as arithmetic coding is used as the coding method.

[0227] The motion information decoding unit 1034 is the same as the motion information decoding unit 3032, so its explanation is omitted.

[0228] The mesh motion compensation unit 1035 is the same as the mesh motion compensation unit 3033, so its explanation is omitted.

[0229] The reference mesh memory 1036 is the same as the reference mesh memory 3034, so its description is omitted.

[0230] (Encoding of mesh displacement) Figure 12 is a functional block diagram showing the configuration of the mesh displacement coding unit 107. The mesh displacement coding unit 107 consists of a coordinate system transformation unit 1071, a transformation unit 1072, a quantization unit 1073, a binarization unit 1074, an arithmetic coding unit 1075, a context selection unit 1076, and a context initialization unit 1077.

[0231] The coordinate system transformation unit 1071 transforms the coordinate system of the mesh displacement from the Cartesian coordinate system to the coordinate system that encodes the displacement (e.g., the local coordinate system) based on the value of the coordinate system transformation information displacementCoordinateSystem. Here, disp is a 3D vector representing the mesh displacement before the coordinate system transformation, d is a 3D vector representing the mesh displacement after the coordinate system transformation, and n_vec, t_vec, and b_vec are 3D vectors (in the Cartesian coordinate system) representing each axis of the local coordinate system. if (displacementCoordinateSystem == 0) { d = disp } else if (displacementCoordinateSystem == 1){ d = (disp * n_vec, disp * t_vec, disp * b_vec) } The mesh displacement coding unit 107 may update the value of displacementCoordinateSystem at the sequence level, or at the picture / frame level. The initial value is 0, which indicates a Cartesian coordinate system.

[0232] When updating the displacementCoordinateSystem at the sequence level, use the syntax shown in Figure 7. Set asps_vdmc_ext_displacement_coordinate_system to 0 for the Cartesian coordinate system and 1 for the local coordinate system.

[0233] To change the displacementCoordinateSystem at the picture / frame level, use the syntax shown in Figure 8. Set afps_vdmc_ext_displacement_coordinate_system_enable_flag to 1 if you want to update the coordinate system, and 0 if you don't. Set afps_vdmc_ext_displacement_coordinate_system to 0 for the Cartesian coordinate system, and 1 for the local coordinate system.

[0234] The transformation unit 1072 performs a transformation f (for example, a wavelet transform) and derives the transformed mesh displacement Tdisp. Tdisp[0][] = f(d[0][]) Tdisp[1][] = f(d[1][]) Tdisp[2][] = f(d[2][]) The quantization unit 1073 performs quantization based on the quantization scale value scale derived from the quantization parameters of each component of the mesh displacement, and derives the quantized mesh displacement Qdisp. Qdisp[0][] = Tdisp[0][] / scale[0] Qdisp[1][] = Tdisp[1][] / scale[1] Qdisp[2][] = Tdisp[2][] / scale[2] Alternatively, the scale value can be approximated by a power of 2, and Qdisp can be derived using the following formula. scale[i] = 1 << scale2[i] Qdisp[0][] = Tdisp[0][] >> scale2[0] Qdisp[1][] = Tdisp[1][] >> scale2[1] Qdisp[2][] = Tdisp[2][] >> scale2[2] The binarization unit 1074 encodes the quantized mesh displacement Qdisp, which is a multi-level signal, into a binary signal. The binary signal may be a k-th exponential Golomb code.

[0235] The arithmetic coding unit 1075 arithmetically codes the binary signal and outputs a mesh displacement coded stream.

[0236] The context selection unit 1076 is the same as the context selection unit 3056, so its explanation is omitted.

[0237] Note that a static context with fixed probabilities that does not update is defined as ctxStatic. Syntax elements represented by ctxStatic may be encoded without using a context. encode(ctxStatic) may also use encode_bypass(), which is a bypass-only process.

[0238] The context initialization unit 1077 is the same as the context initialization unit 3057, so its explanation is omitted. This section explains an example using context, but it is also possible to bypass-encode some syntax elements without using context. Bypass encoding reduces the memory and processing load of the context. For example, the syntax elements diu_last_sig_coeff, diu_coded_block_flag, and diu_coeff_abs_level_rem may be bypass-encoded without using a context. By bypassing these syntax elements, the memory and processing load of the context are reduced while maintaining encoding efficiency.

[0239] The mesh displacement coding unit 107 encodes the mesh displacement Qdisp by the following process. for (k = 0; k < numDim; k++) { / / dimension (component) loop / / encode diu_last_sig_coeff encodeExpGolomb(diu_last_sig_coeff[k], ctxStatic) if (!lastSig) continue dispOffset = 0 for (b = 0; b <numLOD; b++) { / / Level of Detail loop, block loop / / encode diu_coded_block_flag encode(diu_coded_block_flag[k][b], ctxStatic) numBlocks = dispCount[b] / subBlockSize + 1 for (s = 0; s < numBlocks; s++) { / / subblock loop / / encode diu_coded_subblock_flag encode(diu_coded_subblock_flag[k][b][s], ctxCodedSubBlock[ft][b][k]) for (v = 0; v < subBlockSize; v++) { / / coefficient loop within subblock / / encode diu_coeff_abs_level_gt0 d = Qdisp[dispOffset + s * subBlockSize + v][k] encode(d != 0, ctxCoeffGtN[ft][b][0][k]) if (!d) continue / / encode diu_coeff_sign encode(d < 0, ctxStatic) d = Abs(d) - 1 / / encode diu_coeff_abs_level_gt1 encode(d != 0, ctxCoeffGtN[ft][b][1][k]) if (!d) continue d = Abs(d) - 1 / / encode diu_coeff_abs_level_gt2 encode(d != 0, ctxCoeffGtN[ft][b][2][k]) if (!d) continue d = Abs(d) - 1 / / encode diu_coeff_abs_level_gt3 encode(d != 0, ctxCoeffGtN[ft][b][3][k]) if (!d) continue / / encode diu_coeff_abs_level_rem encodeExpGolomb(--d, ctxCoeffRemPrefix[ft][b][k]) } } dispOffset += dispCount[b] } } In pseudocode, `continue` means to skip the subsequent actions and jump to the beginning of the loop (the next iteration). Here, encode() and encodeExpGolomb() are functions that arithmetically encode a binary sequence of a 1-bit value and a k-th exponential Golomb code, respectively, with a value and a corresponding context as arguments. dispCount[b] is the number of mesh displacements at detail level b. lastSig is a flag indicating whether the current coefficient is the last non-zero coefficient in the subblock in scan order. lastSig=0 indicates that the current coefficient is not the last non-zero coefficient in the subblock in scan order. lastSig=1 indicates that the current coefficient is the last non-zero coefficient in the subblock in scan order.

[0240] (Encoding of the base mesh) Figure 21 is a functional block diagram showing the configuration of the mesh coding unit 1031. The mesh coding unit 1031 consists of a mesh prediction unit 10311, a 3D-2D conversion unit 10312, a 2D-3D conversion unit 10313, a binarization unit 1074, an arithmetic coding unit 1075, a context selection unit 1076, and a context initialization unit 1077.

[0241] The mesh prediction unit 10311 is the same as the mesh prediction unit 30311, so its explanation is omitted.

[0242] The 3D-2D conversion unit 10312 is the same as the 3D-2D conversion unit 30312, so its description is omitted.

[0243] The 2D-3D conversion unit 10313 is the same as the 2D-3D conversion unit 30313, so its description is omitted.

[0244] The mesh coding unit 1031 encodes the vertex position vector prediction residual BmVertexPosFinePredResidual (= BmVertexPosFine - BmVertexPosFinePred) of the base mesh by the following process. for (j = 0; j < 3; j++) { for (i = 0; i < mesh_position_fine_residuals_count; i++) { value = BmVertexPosFinePredResidual[i][j] encodeTUExpGolombS(value, ctxCoeffRemPrefixPosFine, ctxCoeffRemSuffixPosFine) } } The mesh coding unit 1031 encodes the vertex position vector prediction residual BmVertexPosCoarsePredResidual (= BmVertexPosCoarse - BmVertexPosCoarsePred) of the base mesh by the following process. for (j = 0; j < 3; j++) { for (i = 0; i < mesh_position_coarse_residuals_count; i++) { value = BmVertexPosCoarsePredResidual[i][j] encodeTUExpGolombS(value, ctxCoeffRemPrefixPosCoarse, ctxCoeffRemSuffixPosCoarse) } } The mesh coding unit 1031 encodes the base mesh attribute prediction residual BmVertexAttrFinePredResidual (= BmVertexAttrFine - BmVertexAttrFinePred) by the following process. for (i = 0; i < mesh_attribute_count; i++) { for (k = 0; k < NumComponents[i]; k++) { for (j = 0; j < mesh_attribute_fine_residuals_count; j++) { value = BmVertexAttrFinePredResidual[i][j][k] encodeTUExpGolombS(value, ctxCoeffRemPrefixAttrFine[i], ctxCoeffRemSuffixAttrFine[i]) } } } The mesh coding unit 1031 encodes the base mesh attribute prediction residual BmVertexAttrCoarsePredResidual (= BmVertexAttrCoarse - BmVertexAttrCoarsePred) by the following process. for (i = 0; i < mesh_attribute_count; i++) { for (k = 0; k < NumComponents[i]; k++) { for (j = 0; j < mesh_attribute_coarse_residuals_count; j++) { value = BmVertexAttrCoarsePredResidual[i][j][k] encodeTUExpGolombS(value, ctxCoeffRemPrefixAttrCoarse[i], ctxCoeffRemSuffixAttrCoarse[i]) } } } The mesh coding unit 1031 may, when the normal vector prediction residual is a two-dimensional vector, convert the three-dimensional normal vector to be coded into a two-dimensional normal vector using the integer arithmetic conversion process described above, and then arithmetically encode the prediction residual for the two-dimensional prediction normal vector.

[0245] The mesh coding unit 1031 may, if the normal vector prediction residual is a two-dimensional vector, use the above-described integer arithmetic conversion process to convert the two-dimensional normal vector into a three-dimensional normal vector and derive (reconstruct) the encoded three-dimensional normal vector.

[0246] The mesh coding unit 1031 may, if the normal vector prediction residual is a two-dimensional vector, further arithmetically encode a second prediction residual (the difference between the original three-dimensional normal vector and the reconstructed three-dimensional normal vector). This configuration allows for even higher quality encoding of the normal vector of the base mesh.

[0247] Here, encodeTUExpGolombS() is the process of arithmetic encoding the offset, prefix, suffix, and sign of the predicted residual values ​​using the given context.

[0248] Although one embodiment of this invention has been described in detail above with reference to the drawings, the specific configuration is not limited to that described above, and various design changes can be made without departing from the spirit of this invention.

[0249] [Application Examples] The 3D data encoding device 11 and the 3D data decoding device 31 described above can be installed and used in various devices that transmit, receive, record, and reproduce 3D data. The 3D data may be natural 3D data captured by a camera or the like, or artificial 3D data (including CG and GUI) generated by a computer or the like.

[0250] The embodiments of the present invention are not limited to those described above, and various modifications are possible within the scope of the claims. That is, embodiments obtained by combining technical means that have been appropriately modified within the scope of the claims are also included in the technical scope of the present invention. [Industrial applicability]

[0251] Embodiments of the present invention can be suitably applied to a 3D data decoding device that decodes encoded data obtained by encoding 3D data, and a 3D data encoding device that generates encoded data obtained by encoding 3D data. Furthermore, it can be suitably applied to the data structure of encoded data generated by the 3D data encoding device and referenced by the 3D data decoding device. [Explanation of Symbols]

[0252] 11 3D Data Encoding Device 101 Atlas Information Coding Unit 103 Base Mesh Coding Unit 1031 Mesh coding section 10311 Mesh prediction unit 10312 3D-2D conversion section 10313 2D-3D conversion section 1032 Mesh Decoding Unit 1033 Motion Information Encoding Unit 1034 Motion Information Decoding Unit 1035 Mesh motion compensation unit 1036 Reference Mesh Memory 1037 Switch 1038 Switch 104 Base Mesh Decoding Unit 106 Mesh displacement update section 107 Mesh Displacement Coding Unit 1071 Coordinate System Transformation Unit 1072 Conversion Unit 1073 Quantization section 1074 Binarization section 1075 Arithmetic encoder 1076 Context Selection Section 1077 Context Initialization Unit 108 Mesh displacement decoding unit 109 Mesh Reconstruction Section 110 Attribute Update Section 111 Padding section 112 Color Space Conversion Unit 113 Attribute Encoding Section 114 Multiplexer 115 Mesh separation section 1151 Mesh thinning section 1152 Mesh division section 1153 Mesh displacement derivation section 21 Network 31 3D Data Decoder 301 Demultiplexer 302 Atlas Information Decoding Unit 303 Base Mesh Decoding Unit 3031 Mesh Decoding Unit 30311 Mesh prediction unit 30312 3D-2D conversion section 30313 2D-3D conversion section 3032 Motion Information Decoding Unit 3033 Mesh motion compensation unit 3034 Reference Mesh Memory 3035 Switch 3036 Switch 305 Mesh displacement decoding unit 3051 Arithmetic Decoding Unit 3052 Multilevel conversion section 3053 Inverse quantization section 3054 Inverse Transformer 3055 Coordinate System Transformation Unit 3056 Context Selection Section 3057 Context Initialization Unit 307 Mesh Reconstruction Section 306 Attribute Decoding Unit 3071 Mesh division section 3072 Mesh deformation area 308 Color Space Conversion Unit 41 3D Data Display Device

Claims

1. A 3D data decoding device for decoding encoded data comprises a mesh prediction unit that derives a predicted value of the base mesh normal vector from the encoded data, and a mesh decoding unit that derives the base mesh normal vector. The above mesh prediction unit converts the decoded 3D normal vector into a 2D normal vector using integer arithmetic conversion processing, and derives a 2D predicted normal vector. The 3D data decoding device is characterized by the above mesh decoding unit arithmetically decoding the predicted residual of the 2D normal vector, adding the above 2D predicted normal vector and the above predicted residual to derive the 2D normal vector, and converting the above 2D normal vector into a 3D normal vector using a conversion process with integer operations including division with bit shifts to derive the above base mesh normal vector.

2. The 3D data decoding device according to claim 1 is characterized in that the mesh decoding unit derives a 3D vector from a 2D normal vector, performs division according to the magnitude norm of the 3D vector, and then performs a right bit shift using the shift value shift to derive the 3D vector.

3. The 3D data decoding device according to claim 1 is characterized in that the mesh decoding unit derives a 3D vector from a 2D vector based on the difference between the components of the 2D normal vector and a predetermined value scale, multiplies the derived 3D vector by scale, divides it by the magnitude value of the 3D vector norm, right-shifts it by a predetermined shift value shift, and adds a predetermined offset center to derive the result.

4. The 3D data decoding device according to claim 1, characterized in that the bit shift is variable according to the range of values ​​of the three-dimensional normal vector.

5. The 3D data decoding device according to claim 1 or 2, characterized in that the mesh prediction unit prohibits the use of zero vectors as predicted values ​​for the base mesh normal vector.

6. A 3D data encoding device for encoding 3D data comprises a mesh prediction unit that derives a predicted value of the base mesh normal vector, and a mesh encoding unit that encodes the predicted residual of the base mesh normal vector. The above mesh prediction unit converts the encoded 3D normal vector into a 2D normal vector using integer arithmetic conversion processing, and derives a 2D predicted normal vector. The above mesh coding unit is a 3D data coding device characterized by converting the 3D normal vector to be coded into a 2D normal vector using integer arithmetic conversion processing, arithmetic coding the predicted residual for the 2D predicted normal vector, and converting the 2D normal vector into a 3D normal vector using integer arithmetic conversion processing including division with bit shifts to derive the coded 3D normal vector.

7. The 3D data encoding device according to claim 6, characterized in that the bit shift value is variable according to the range of the three-dimensional normal vector value.

8. The 3D data encoding device according to claim 6 or 7, characterized in that the mesh prediction unit prohibits the use of zero vectors as predicted values ​​for the base mesh normal vector.

Images