Three-dimensional data decoding device and three-dimensional data encoding device

Abstract

To improve the coding efficiency of mesh displacement, mesh motion information, and base mesh in three-dimensional data coding / decoding using arithmetic coding, thereby achieving high-quality coding / decoding of three-dimensional data.SOLUTION: A three-dimensional data decoding device that decodes encoded data includes an arithmetic decoding unit that arithmetically decodes mesh displacement from the encoded data, and the arithmetic decoding unit decodes a leading portion of a residual prefix of an absolute value of a coefficient of the mesh displacement using a context.SELECTED DRAWING: Figure 5

Description

[Technical field]

[0001] An embodiment of the present invention relates to a 3D data encoding device and a 3D data decoding device. [Background technology]

[0002] In order to efficiently transmit or record 3D data, there are 3D data encoding devices that convert the 3D data into a 2D image, encode it using a video encoding method, and generate encoded data, and 3D data decoding devices that decode the encoded data into a 2D image and reconstruct the 3D data.

[0003] Specific examples of 3D data encoding methods include MPEG-I's ISO / IEC 23090-5 V3C (Volumetric Video-based Coding) and V-PCC (Video-based Point Cloud Compression). V3C can encode and decode point clouds consisting of point positions and attribute information. Furthermore, it is also used for encoding and decoding multi-viewpoint images and mesh images by ISO / IEC 23090-12 (MPEG Immersive Video, MIV) and ISO / IEC 23090-29 (Video-based Dynamic Mesh Coding, V-DMC), which is currently being standardized. The latest draft document of the V-DMC method is disclosed in Non-Patent Document 1.

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

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

[0006] 3D data (mesh) such as that in Non-Patent Document 1 consists of a base mesh, mesh displacement, and texture mapping image. A vertex coding method such as Draco can be used to code the base mesh. The mesh displacement can be coded by coding the mesh displacement image, which is a two-dimensional representation of the mesh displacement, with a video codec, or by directly coding it using arithmetic coding. The texture mapping image is coded as an attribute image with a video codec. The video codec can be the above-mentioned HEVC or VVC. [Prior art documents] [Non-patent literature]

[0007] [Non-Patent Document 1] WD 4.0 of V-DMC (MDS23075_WG07_N00680_clean), ISO / IEC JTC 1 / SC 29 / WG 7 N0680, July 2023 Summary of the Invention [Problem to be solved by the invention]

[0008] In the 3D data coding method in Non-Patent Document 1, mesh displacement (mesh displacement sequence, mesh displacement image), mesh motion information, and base meshes that constitute 3D data (mesh) can be coded and decoded using an arithmetic coding method. When mesh displacement, mesh motion information, and base meshes are arithmetically coded, the performance depends on syntax elements and contexts, and there is a problem that coding efficiency is poor.

[0009] An object of the present invention is to improve the coding efficiency of mesh displacement and mesh motion information in 3D data coding and decoding using arithmetic coding, thereby enabling high-quality coding and decoding of 3D data. [Means for solving the problem]

[0010] In order to solve the above problem, a 3D data decoding device according to one embodiment of the present invention is a 3D data decoding device that decodes encoded data, and is characterized in that it includes an arithmetic decoding unit that arithmetically decodes mesh displacements from the encoded data, and the arithmetic decoding unit decodes a leading portion of a residual prefix of an absolute value of a coefficient of the mesh displacement using a context.

[0011] In order to solve the above problem, a 3D data encoding device according to one embodiment of the present invention is a 3D data encoding device that encodes 3D data, and includes an arithmetic encoding unit that arithmetically encodes mesh displacements, and the arithmetic encoding unit encodes a leading portion of a residual prefix of an absolute value of a coefficient of the mesh displacement using a context. Effect of the Invention

[0012] According to one aspect of the present invention, the encoding efficiency of mesh displacement and mesh motion information is improved, and 3D data can be encoded and decoded with high quality. [Brief description of the drawings]

[0013] [Figure 1] 1 is a schematic diagram showing the configuration of a 3D data transmission system according to an embodiment of the present invention. [Diagram 2] FIG. 2 is a diagram showing a hierarchical structure of data in an encoded stream. [Diagram 3] FIG. 2 is a functional block diagram showing a schematic configuration of a 3D data decoding device 31. [Figure 4] FIG. 2 is a functional block diagram showing a configuration of a base mesh decoding unit 303. [Diagram 5] FIG. 2 is a functional block diagram showing the configuration of a mesh displacement decoding unit 305. [Figure 6] FIG. 2 is a functional block diagram showing the configuration of a mesh reconstruction unit 307. [Figure 7] This is an example of a syntax for transmitting coordinate transformation parameters and context initialization parameters at the sequence level (ASPS). [Figure 8]13 is an example of a syntax for transmitting coordinate transformation parameters and context initialization parameters at the picture / frame level (AFPS). [Figure 9] FIG. 13 is a diagram for explaining the operation of the mesh reconstructing unit 307. [Figure 10] 1 is a functional block diagram showing a schematic configuration of a 3D data encoding device 11. FIG. [Figure 11] FIG. 2 is a functional block diagram showing a configuration of a base mesh encoding unit 103. [Figure 12] FIG. 2 is a functional block diagram showing a configuration of a mesh displacement encoding unit 107. [Figure 13] FIG. 2 is a functional block diagram showing the configuration of a mesh separation unit 115. [Figure 14] 11 is a diagram for explaining the operation of the mesh separating unit 115. FIG. [Figure 15] 1 is an example of a syntax structure for mesh displacement. [Figure 16] A diagram showing the syntax structure of mesh displacement and a method for deriving context elements. [Figure 17] FIG. 13 illustrates how the context of a mesh displacement syntax element is derived. [Figure 18] FIG. 13 is a functional block diagram showing a configuration of a motion information decoding unit 3032. [Figure 19] 1 is an example of a syntax structure of motion information. [Figure 20] FIG. 2 illustrates a method for deriving a context element of the motion information syntax. [Figure 21] FIG. 13 is a functional block diagram showing a configuration of a motion information encoding unit 1033. DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS

[0014] Hereinafter, an embodiment 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 this 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 It includes a 3D data display device 41.

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

[0018] The network 21 transmits the encoded stream Te generated by the 3D data encoding device 11 to the 3D data decoding device 31. The network 21 is the Internet, a wide area network (WAN), a local area network (LAN), or a combination of these. The network 21 is not necessarily limited to a bidirectional communication network, and may be a unidirectional communication network that transmits broadcast waves such as terrestrial digital broadcasting and satellite broadcasting. Furthermore, the network 21 may be replaced by a storage medium on which the encoded stream Te is recorded, 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 pieces of 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. Display forms include stationary, mobile, HMD, and the like. Furthermore, when the 3D data decoding device 31 has high processing power, it displays high quality images, and when it has only lower processing power, it displays images that do not require high processing power or display power.

[0021] <operator> 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 || indicates 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 (zero). Let y..z denote the set of integers from y to z.

[0024] <Structure of the coding stream Te> Before going into 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.

[0025] 2 is a diagram showing a hierarchical structure of data in an encoded stream Te. The encoded stream Te has the data structure of either a V3C sample stream or a V3C unit stream. The V3C sample stream includes a sample stream header and a V3C unit. The V3C unit stream includes a V3C unit.

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

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

[0028] If the Unit Type is V3C_AD (Atlas Data), the V3C unit includes a VPS ID, an atlasID, a sample stream nal header, and multiple NAL units. The atlasID is an ID (Idenfication). Yes, takes an integer value of 0 or greater.

[0029] A NAL unit contains a NALUnitType, a layerID, a TemporalID, and a RBSP (Raw byte sequence payload).

[0030] NAL units are identified by NALUnitType, and are classified as ASPS (Atlas Sequence Parameter Set), AAPS (Atlas Adaptation Parameter Set), ATL (Atlas Tile layer), SEI (Supplemental Enhancement Information), etc.

[0031] The ATL includes an ATL header and an ATL data unit, and the ATL data unit includes information such as the position and size of a patch, such as patch information data.

[0032] The SEI includes payloadType, which indicates the type of SEI, payloadSize, which indicates the size (number of bytes) of the SEI, and sei_payload, which is the data of the SEI.

[0033] If Unit Type is V3C_AVD (Attribute Video Data), V3C The unit includes the VPS ID, atlasID, attrIdx, which is the ID of the attribute image, partIdx, which is the partition ID, mapIdx, which is the map ID, auxFlag, which indicates whether the data is auxiliary data, and the video stream. The video stream is data encoded by HEVC, VVC, etc. In V-DMC, the attribute data corresponds to the texture image.

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

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

[0036] If the Unit Type is V3C_MD (Mesh data), the V3C unit contains the VPS ID, atlasID, and mesh_payload. In V-DMC, it corresponds to the base mesh.

[0037] (Configuration of 3D data decoding device according to the first embodiment) 3 is a functional block diagram showing a schematic configuration of a 3D data decoding device 31 according to the first embodiment. The 3D data decoding device 31 is composed 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 inputs encoded data of 3D data, and outputs atlas information, meshes, and attribute images.

[0038] The demultiplexing unit 301 inputs 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 Atlas Data stream, NAL unit), a base mesh encoded stream (V3C_MD mesh_payload), a mesh displacement encoded stream (V3C_GVD video stream), and an attribute video stream (V3C_AVD video stream).

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

[0040] The atlas information decoding unit 302 in FIG. 3 decodes the 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 provided, and each piece of coordinate system transformation information may be decoded only when the gating flag is 1. The gating flag may be, for example, afps_vdmc_ext_displacement_coordinate_system_enable_flag.

[0041] The base mesh decoder 303 decodes the base mesh coded stream that has been coded using vertex coding (a 3D data compression coding method, for example, Draco), and outputs a base mesh. The base mesh will be described later.

[0042] The mesh displacement decoding unit 305 decodes the mesh displacement coded stream and outputs the mesh displacement.

[0043] A mesh reconstructing unit 307 receives the base mesh and the mesh displacement, and reconstructs the mesh in the 3D space.

[0044] The attribute decoding unit 306 decodes the attribute video stream encoded by VVC, HEVC, or the like, and outputs an attribute image. The attribute image may be a texture image expanded on the UV axis (a texture mapping image converted by the UV atlas method) in YCbCr format. The type of codec used for encoding is indicated by ptl_profile_codec_group_idc obtained by decoding the V3C parameter set of the encoded data. It may also be indicated by the Four CC code indicated by ai_geometry_codec_id[atlasID] of the V3C parameter set. ai_geometry_codec_id[atlasID] indicates an index in the atlas ID corresponding to the codec ID of the decoder used to decode the attribute video stream.

[0045] A color space conversion unit 308 converts the color space of the attribute image from the YCbCr format to the RGB format. Note that an attribute video stream coded in the RGB format may be decoded and color space conversion may be omitted.

[0046] (Decoding the base mesh) FIG. 4 is a functional block diagram showing the configuration of the base mesh decoding unit 303. The base mesh decoding unit 303 is composed 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 be configured to include a base mesh inverse quantization unit (not shown) before the output of the base mesh. When the base mesh to be decoded is coded (intra-coded) without referring to other base meshes (for example, base meshes that have already been coded and decoded), the switches 3035 and 3036 are connected to the side that does not perform motion compensation. On the other hand, when the base mesh to be decoded is coded (inter-coded) with reference to other base meshes, the switches 3035 and 3036 are connected to the side that performs motion compensation. When motion compensation is performed, the target vertex coordinates are derived by referring to the already decoded vertex coordinates and motion information.

[0047] The mesh decoding unit 3031 decodes the intra-coded base mesh coded stream and outputs the base mesh (base mesh vertex positions, base mesh vertex position vectors). Draco, Edge Breaker, or the like is used as the coding method.

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

[0049] 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 the motion information, and outputs a motion-compensated mesh.

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

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

[0052] (Context-Adaptive Binary Arithmetic Coding) The arithmetic decoding unit 3051, the multi-value conversion unit 3052, the context selection unit 3056, and the context initialization unit 3057 use a decoding method using a context called Context-Adaptive Binary Arithmetic Coding (CABAC). In CABAC, a binary string consisting of 0 and 1 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 a segment. The CABAC decoding unit decodes each bit of a binary string (Bin String) corresponding to a 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 updating of the index ctxIdx that specifies the context and the identified context is omitted. A context is a variable (memory area) for holding the probability (state) of CABAC, and is identified by the value of ctxIdx (0, 1, 2, ...). When 0 and 1 are always equally probable, in other words, when they are 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 hold a state for a specific syntax element. It is also possible to use a static context where the probability is fixed at 0.5 and does not need to be updated. In this sense, it may be called static rather than bypass. An integer value such as 128 may be used to indicate a probability of 0.5.

[0053] The process of decoding one bit without using a context (bypassing) may use the following pseudo code. rangeTimesProb = IvlRange >> 1 binVal = ( rangeTimesProb <= ( IvlCode - IvlLow ) ) if (binVal == 0) IvlRange = rangeTimesProb else { IvlLow += rangeTimesProb IvlRange -= rangeTimesProb } The process of decoding one bit using a context may use the following pseudo code: Here, prob0 is a variable indicating 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 following two types of coordinate systems are used for mesh displacement (3D vector). Cartesian coordinate system (canonical): A rectangular coordinate system that is commonly defined throughout the entire 3D space. (X,Y,Z) coordinate system. A rectangular coordinate system whose 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, the same tile). A coordinate system with normal (D), tangent (U), and bi-tangent (V) axes. In other words, it is a Cartesian coordinate system consisting of the first axis (D) indicated by the normal vector n_vec at a vertex (a surface that contains a vertex), and the second axis (U) and third axis (V) indicated by two tangent vectors t_vec and b_vec that are perpendicular to the normal vector n_vec. n_vec, t_vec, and b_vec are three-dimensional vectors. The (D, U, V) coordinate system may also be called the (n, t, b) coordinate system.

[0054] (Decoding and deriving sequence-level control parameters) Here, the control parameters used in the mesh displacement decoding unit 305 will be described.

[0055] Figure 7 shows an example of syntax for transmitting coordinate system transformation parameters in 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 that are applied to the atlas information coded stream. In ASPS, coordinate system transformation parameters are transmitted using the asps_vdmc_extension() syntax. The semantics of each field are as follows:

[0056] asps_vdmc_ext_subdivision_iteration_count: A parameter indicating the number of mesh division iterations.

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

[0058] asps_vdmc_ext_1d_displacement_flag: A flag indicating whether the mesh displacement is one-dimensional. If the value is true, it indicates that the mesh displacement is one-dimensional. If the value is false, it indicates that the mesh displacement is three-dimensional.

[0059] (Decoding and derivation of picture / frame level control parameters) Figure 8 shows an example of the syntax for transmitting coordinate system transformation parameters in AFPS at the picture / frame level. AFPS (Atlas Frame Parameter Set or Atlas frame mesh information) is one of the NAL units of atlas information and contains syntax elements that are 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:

[0060] afps_vdmc_ext_overriden_flag: A flag indicating whether to update the coordinate system of the mesh displacement. If this flag is true, the coordinate system of the mesh displacement is updated based on the value of afps_vdmc_ext_displacement_coordinate_system described below. If this flag is false, the coordinate system of the mesh displacement is not updated.

[0061] afps_vdmc_ext_subdivision_iteration_count: A parameter indicating the number of mesh division iterations.

[0062] afps_vdmc_ext_displacement_coordinate_system: Coordinate system transformation information indicating the coordinate system of the 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 the syntax element is not present, The value is assumed to be decoded by ASPS and the default coordinate system is the coordinate system indicated by ASPS.

[0063] afps_vdmc_ext_1d_displacement_flag: A flag indicating whether the mesh displacement is one-dimensional. If the value is true, it indicates that the mesh displacement is one-dimensional. If the value is false, it indicates that the mesh displacement is three-dimensional.

[0064] (Mesh displacement syntax structure) Figure 15 shows an example of the syntax structure of mesh displacement. The semantics are as follows. Mesh displacement is a sequence of values ​​(coefficients) of the position pos and k components (k components), and is indicated by the array Qdisp[pos][k]. Displacement is a three-dimensional signal in the Cartesian coordinate system (xyz) or the local coordinate system (ntb), and each component of the three-dimensional displacement is called a component. The displacement Qdisp here is also called a coefficient because it is a value after transformation by discrete wavelet transformation, lifting transformation, DCT transformation, etc. The component variable k takes the values ​​0, 1, and 2. The variable name is not limited to k, and dim can be another variable name. The order of the indexes of QDisp can be reversed, that is, Qdisp[k][pos] can be used instead of Qdisp[pos][k].

[0065] diu_last_sig_coeff[k]: an index indicating the last position of a non-zero mesh displacement coefficient in the kth component.

[0066] diu_coded_block_flag[k][b]: indicates whether the block with index b in the kth component contains a non-zero mesh displacement coefficient: 1 if so, 0 if not.

[0067] diu_coded_subblock_flag[k][b][s]: indicates whether the subblock with index s of the block with index b in the kth component contains a non-zero mesh displacement coefficient: 1 if so, 0 if not.

[0068] diu_coeff_abs_level_gt0[k][b][s][v]: Indicates whether the absolute value of the non-zero mesh displacement coefficient of the vertex with index v of the subblock with index s of the block with index b in the kth component is greater than 0. 1 if it is greater, 0 if it is not.

[0069] diu_coeff_abs_level_gt1[k][b][s][v]: Indicates whether the absolute value of the non-zero mesh displacement coefficient of the vertex with index v of the subblock with index s of the block with index b in the kth component is greater than 1. If it is greater, it is set to 1, otherwise it is set to 0. If this syntax element is not present, it is inferred to be 0.

[0070] diu_coeff_abs_level_gt2[k][b][s][v]: Indicates whether the absolute value of the non-zero mesh displacement coefficient of the vertex with index v of the subblock with index s of the block with index b in the kth component is greater than 2. If it is greater, it is set to 1, otherwise it is set to 0. If this syntax element is not present, it is inferred to be 0.

[0071] diu_coeff_abs_level_gt3[k][b][s][v]: Indicates whether the absolute value of the non-zero mesh displacement coefficient of the vertex with index v of the subblock with index s of the block with index b in the kth component is greater than 3. If it is greater, it is set to 1, otherwise it is set to 0. If this syntax element is not present, it is inferred to be 0.

[0072] diu_coeff_sign[k][b][s][v]: indicates whether the non-zero mesh displacement coefficient of the vertex with index v of the subblock with index s of the block with index b in the kth component is positive or not. If it is positive, it is set to 1, otherwise (if it is negative), it is set to 0. If this syntax element is not present, it is inferred to be 1.

[0073] diu_coeff_abs_level_rem[k][b][s][v]: The absolute value of the non-zero mesh displacement coefficient of the vertex with index v of the sub-block with index s of the block with index b in the kth component minus 4. If this syntax element is not present, it is inferred to be 0.

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

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

[0076] The mesh displacement decoding unit 305 decodes diu_coded_subblock_flag for each block of the mesh displacement, and derives the start position vStart of the subblock s from diu_coded_subblock_flag[k][b][s].

[0077] The mesh displacement decoding unit 305 decodes diu_coeff_abs_level_gt0 for each sub-block of the mesh displacement, and if diu_coeff_abs_level_gt0 is a predetermined value (for example, other than 0), decodes the subsequent diu_coeff_sign and diu_coeff_abs_level_gt1.

[0078] When diu_coeff_abs_level_gt1 is a predetermined value (for example, other than 0), the mesh displacement decoding unit 305 decodes the subsequent diu_coeff_abs_level_gt2.

[0079] When diu_coeff_abs_level_gt2 is a predetermined value (for example, other than 0), the mesh displacement decoding unit 305 decodes the subsequent diu_coeff_abs_level_gt3.

[0080] If diu_coeff_abs_level_gt3 is a predetermined value (for example, other than 0), the mesh displacement decoding unit 305 decodes the subsequent diu_coeff_abs_level_rem.

[0081] (Operation of Mesh Displacement Decoding Unit) The arithmetic decoding unit 3051 decodes the mesh displacement coded stream that has been arithmetically coded according to a value (context) indicating a random variable, and outputs a binary signal. The binary signal may be an alpha code or a k-th order Exp-Golomb code. The exponential-Golomb code is composed of a prefix and a suffix code. The prefix is ​​a value that increases exponentially, and the suffix is ​​the remainder. When the variable rem is coded and decoded using the exponential-Golomb code, the prefix and suffix of the exponential-Golomb code are also called the prefix and suffix of rem.

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

[0083] The context selection unit 3056 (context memory) has a memory for holding contexts, derives a context used for arithmetic decoding of mesh displacements according to the state, and updates the value as necessary. In arithmetic decoding of each coefficient of mesh displacements, the following different context arrays may be used according to 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 indicating the occurrence probability of a binary signal. ctxCodedSubBlock[numFT][numLOD][numDim] ctxCoeffGtN[numFT][numLOD][MAX_GTN+1][numDim] ctxCoeffRemPrefix[numFT][numLOD][numDim][numPrefixBin] Note that a static context with a fixed probability that is not updated is defined as ctxStatic. The syntax element indicated by ctxStatic may be decoded without using a context. For decode(ctxStatic), a process dedicated to bypass may be used as decode_bypass().

[0084] Here, numFT is the number of frame type types, and numFT = 2. numPrefixBin is the number of bins that use context in the prefix, and numPrefixBin = 2 may be used. numLOD is the maximum number of levels of detail of mesh division, and the value of the syntax element asps_vdmc_ext_subdivision_iteration_count or afps_vdmc_ext_subdivision_iteration_count decoded from the bitstream may be used, or numLOD=4 may be used. numLOD = asps_vdmc_ext_subdivision_iteration_count numLOD = afps_vdmc_ext_subdivision_iteration_count numDim is the number of dimensions of the mesh displacement vector, and may use 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=3. numDim = asps_vdmc_ext_1d_displacement_flag ? 1 : 3 numDim = afps_vdmc_ext_1d_displacement_flag ? 1 : 3 The maximum value of the threshold for the coefficients, MAX_GTN, is 3.

[0085] ctxCodedSubBlock[numFT][numLOD][numDim] is a context array used for decoding 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 in the frame type ft, the level of detail lod, and the dimension dim of the mesh displacement vector.

[0086] ctxCoeffGtN[numFT][numLOD][MAX_GTN+1][numDim] is a context array used for decoding the syntax element diu_coeff_abs_level_gtN (N is replaced with 0, 1, 2, MAX_GTN). The arithmetic decoding unit 3051 uses the values ​​of ctxCoeffGtN[ft][lod][N][dim] to decode diu_coeff_abs_level_gtN in the frame type ft, the level of detail lod, and the dimension dim of the mesh displacement vector.

[0087] The arithmetic decoding unit 3051 uses a bypass to decode diu_coeff_sign for the frame type ft, the level of detail lod, and the dimension dim of the mesh displacement vector.

[0088] ctxCoeffRemPrefix[numFT][numLOD][numDim][numPrefixBin] is an array of contexts used for decoding the syntax element diu_coeff_abs_level_rem. ctxCoeffRemPrefix[bin] indicates a context at the bin position in the binarization of the prefix of 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 in the frame type ft, the level of detail lod, and the dimension dim of the mesh displacement vector.

[0089] The context initialization unit 3057 initializes the context (probability of occurrence of a binary signal). The context may be initialized for each frame, or may be initialized for each set of one or more frames (Group of Frames, GoF). When the context is initialized for each frame, there is no context dependency between frames, so random access to any frame can be easily performed. When the context is initialized for each GoF, the initialization is performed less frequently, so that the coding efficiency can be improved more than when the context is initialized for each frame.

[0090] (Mesh displacement derivation process) 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 processing, 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 a LOD basis (block-by-block basis) and decodes diu_coded_subblock_flag on a subblock-by-subBlockSize basis. When diu_coded_subblock_flag is a predetermined value, it decodes the mesh displacement coefficients in the subblock. 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 using the corresponding context ctx as an argument, and decodeExpGolomb(ctxPrefix, ctxSuffix) is a function that decodes a value binarized with k-th order Golomb code (e.g., k=0). ctxPrefix[n] is used as the context for bin position n of the prefix, and ctxSuffix[m] is used as the context for bin position m of the suffix. When no context is used for the suffix (when a bypass is used), simply write decodeExpGolomb(ctxPrefix). value++ is an operation that increments the variable value by 1, value += 1, value = value + 1. subBlockSize is the size of the subblock. for indicates a loop. subBlockSize may be any value between 16 and 4096, inclusive, which is an exponential power of 2. For example, 128, 256 are acceptable. dispCount[b] is the number of mesh displacements at level of detail b.

[0091] The mesh displacement decoding unit 305 may derive the value of the mesh displacement from 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_level_sign as follows, instead of the method of the pseudo code above. The value is stored in QDisp.

[0092] absCoeff = 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 value = absCoeff * (1 - 2 * diu_coeff_sign) Alternatively, the mesh displacement decoding unit 305 may decode the syntax elements diu_last_sig_coeff, diu_coded_block_flag, diu_coded_subblock_flag, diu_coeff_abs_level_gtN, diu_coeff_abs_level_rem, and diu_coeff_sign through the following process to derive the mesh displacement Qdisp. 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]) { / / decode diu_coeff_sign diu_coeff_sign[k][b][s][v] = decode(ctxStatic) N = 1 maxGtN = 3 while (N <= maxGtN) { value++ / / decode diu_coeff_abs_level_gtN (N=1..maxGtN) diu_coeff_abs_level_gtN[k][b][s][v] = decode(ctxCoeffGtN[ft][b][N][k]) if (!diu_coeff_abs_level_gtN[k][b][s][v]) break N++ } if (diu_coeff_abs_level_gtN[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[k][b][s][v]) } if (diu_coeff_sign[k][b][s][v]) { value = -value } } Qdisp[dispOffset + s * subBlockSize + v][k] = value } } } } dispOffset += dispCount[b] } } In pseudocode, break means to skip subsequent operations and exit from the nearest loop.

[0093] Note that maxGtN is not limited to 3, and for example, maxGtN=2 may be used to encode / decode the syntax elements diu_coeff_abs_level_gt0, diu_coeff_abs_level_gt1, and diu_coeff_abs_level_gt2, or maxGtN=4 may be used to encode / decode the syntax elements diu_coeff_abs_level_gt0, diu_coeff_abs_level_gt1, diu_coeff_abs_level_gt2, diu_coeff_abs_level_gt3, and diu_coeff_abs_level_gt4.

[0094] (Configuration that uses context for some bins in the prefix) Fig. 16(a) is an example of a syntax structure of mesh displacement. The difference from Fig. 15 is that it does not have the syntax elements gt2 (diu_coeff_abs_level_gt2) and gt3 (diu_coeff_abs_level_gt3). If diu_coeff_abs_level_gt1 is true, the mesh displacement decoding unit 305 decodes diu_coeff_abs_level_gt2 and gt3. eff_abs_rem is decoded. FIG. 16(b) shows the setting of the context used by the mesh displacement decoding unit 305. The mesh displacement decoding unit 305 decodes diu_coeff_abs_level_gt0 and diu_coeff_abs_level_gt1 as contexts, diu_coeff_sign as bypass, a part of the beginning of the prefix of diu_coeff_abs_level_rem as context, the rest of the prefix as bypass, and the suffix of diu_coeff_abs_level_rem as bypass. In particular, different contexts may be set for bin=0 and bin=1 of the prefix, and bin>=2 and onward of the prefix may be bypassed. Also, different contexts may be set for bin=0 (bin0), bin=1 (bin1), and bin=2 (bin2) of the prefix, and bin>=3 and onward of the prefix may be bypassed. According to the above, even if the value to be ExpGolomb encoded becomes large, only a maximum of two (or three) contexts are used, so the complexity can be reduced compared to using contexts for all bins for the residual (diu_coeff_abs_level_rem). It can also be more efficient than using bypass for all bins.

[0095] Fig. 17 shows another setting of the context used by the mesh displacement decoding unit 305. The mesh displacement decoding unit 305 decodes by bypassing diu_last_sig_coeff and diu_coded_block_flag, bypassing diu_coded_subblock_flag and diu_coeff_abs_level_gt0, bypassing diu_coeff_sign, bypassing a part of the beginning of the prefix of diu_coeff_abs_level_gt1, diu_coeff_abs_level_gt2, diu_coeff_abs_level_gt3, and diu_coeff_abs_level_rem, bypassing the rest of the prefix, and bypassing the suffix of diu_coeff_abs_level_rem. In particular, the context may be set to bin=0 of the prefix, and the bin>=1 and subsequent parts of the prefix may be bypassed (Fig. 17(a)). Alternatively, different contexts may be assigned to bin=0 and bin=1 of the prefix, and bin>=2 and onward of the prefix may be bypassed (FIG. 17(b)).

[0096] In FIG. 17, the context ctxCodedSubBlock[ft][lod][dim] with CtxTbl=0 is used to decode diu_coded_subblock_flag. The context ctxCoeffGtN[ft][lod][CtxInc][dim] with CtxTbl=1 is used to decode diu_coeff_abs_level_gtN (CtxInc is replaced with N). The context ctxCoeffRemPrefix[ft][lod][dim][CtxInc] with CtxTbl=2 is used to decode the prefix of diu_coeff_abs_level_rem. (Configuration for limiting the number of context coding bins to be decoded) In order to reduce the complexity of the context coding, the number of context-coded bins may be limited. Specifically, the mesh displacement decoding unit 305 counts the number of bins decoded by context coding in the syntax element of diu_coeff_abs_level_rem for each subblock (subBlockSize) in a predetermined unit. Then, when the counted value is equal to or greater than a predetermined value maxContextInBlock, each bin of diu_coeff_abs_level_rem may be switched from decoding using a context to decoding without using a context (bypass, using a static context). The pseudocode of this example is shown below.

[0097] for (s = 0; s < numSubBlocks; s++) { / / subblock loop countCtx = 0 / / 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]) { / / decode diu_coeff_sign diu_coeff_sign[k][b][s][v] = decode(ctxStatic) N = 1 maxGtN = 3 while (N <= maxGtN) { value++ / / decode diu_coeff_abs_level_gtN (N=1..maxGtN) diu_coeff_abs_level_gtN[k][b][s][v] = decode(ctxCoeffGtN[ft][b][N][k]) if (!diu_coeff_abs_level_gtN[k][b][s][v]) break N++ } if (diu_coeff_abs_level_gtN[k][b][s][v]) { / / decode diu_coeff_abs_level_rem if (countCtx < maxContextInBlock) { diu_coeff_abs_level_rem[k][b][s][v] = decodeExpGolomb(ctxCoeffRemPrefix[ft][b][k]) countCtx += 2 } else { diu_coeff_abs_level_rem[k][b][s][v] = decodeExpGolomb(ctxStatic) } value += (1 + diu_coeff_abs_level_rem[k][b][s][v]) } if (diu_coeff_sign[k][b][s][v]) { value = -value } } Qdisp[dispOffset + s * subBlockSize + v][k] = value }} } According to the above, when maxContextInBlock=subBlockSize / 4, the maximum value (worst case) of the number of bins to be context-coded can be reduced from 6*subBlockSize to subBlockSize*(4+1 / 4).

[0098] Also, the number of times bins are decoded using the context including diu_coeff_abs_level_gt1, diu_coeff_abs_level_gt2, and diu_coeff_abs_level_gt3 in addition to diu_coeff_abs_level_rem may be counted, and if the value is less than a predetermined value maxContextInBlock, diu_coeff_abs_level_gt2 and diu_coeff_abs_level_gt3 may be decoded, and the prefix of diu_coeff_abs_level_rem may be decoded using the context. In other cases, diu_coeff_abs_level_gt2 and diu_coeff_abs_level_gt3 are not decoded, and diu_coeff_abs_level_rem is decoded by bypassing all of it, including the prefix. The pseudocode for this example is shown below.

[0099] for (s = 0; s < numSubBlocks; s++) { / / subblock loop countCtx = 0 / / 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]) { / / decode diu_coeff_sign diu_coeff_sign[k][b][s][v] = decode(ctxStatic) N = 1 maxGtN = 3 while (N <= maxGtN && countCtx < maxContextInBlock) { value++ / / decode diu_coeff_abs_level_gtN diu_coeff_abs_level_gtN[k][b][s][v] = decode(ctxCoeffGtN[ft][b][N][k]) if (!diu_coeff_abs_level_gtN[k][b][s][v]) break N++ countCtx += 1 } if (diu_coeff_abs_level_gtN[k][b][s][v]) { / / decode diu_coeff_abs_level_rem if (countCtx < maxContextInBlock) { diu_coeff_abs_level_rem[k][b][s][v] = decodeExpGolomb(ctxCoeffRemPrefix[ft][b][k]) countCtx += 2 } else { diu_coeff_abs_level_rem[k][b][s][v] = decodeExpGolomb(ctxStatic) } value += (1 + diu_coeff_abs_level_rem[k][b][s][v]) } if (diu_coeff_sign[k][b][s][v]) { value = -value } } Qdisp[dispOffset + s * subBlockSize + v][k] = value } } } According to the above, when maxContextInBlock=subBlockSize / 4, the maximum number of bins to be context-coded (worst case) can be reduced from 6*subBlockSize to subBlockSize*(1+1 / 4). Also, by changing "&& countCtx < maxContextInBlock" to "&& (N == 1 || countCtx < maxContextInBlock)", diu_coeff_abs_level_gt0 and diu_coeff_abs_level_gt1 may always use context. In this case, the number of times bins are decoded using context is counted and limited, including diu_coeff_abs_level_gt2 and diu_coeff_abs_level_gt3 in addition to diu_coeff_abs_level_rem.

[0100] The inverse quantization unit 3053 performs inverse quantization based on the quantization scale value iscale, and derives the mesh displacement Tdisp after transformation (for example, wavelet transformation). Tdisp may be in a Cartesian coordinate system or a local coordinate system. iscale is a value derived from the quantization parameter of each component of the mesh displacement image. 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 may be a value encoded at the sequence level, picture / frame level, tile / patch level, etc., and decoded from the encoded data.

[0101] The inverse transform unit 3054 performs an inverse transform g (eg, 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 conversion unit 3055 converts the mesh displacement (coordinate system of the mesh displacement) into the Cartesian coordinate system based on the value of the coordinate system conversion information displacementCoordinateSystem. Specifically, when displacementCoordinateSystem==1, the displacement in the local coordinate system is converted into the displacement in the Cartesian coordinate system. Here, d is a three-dimensional vector indicating the mesh displacement before the coordinate system conversion. disp is a three-dimensional vector indicating the mesh displacement after the coordinate system conversion, and is a Cartesian coordinate system. n_vec, t_vec, and b_vec are three-dimensional vectors (in the Cartesian coordinate system) corresponding to each axis of the local coordinate system of the target area 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 for vector multiplication can be expressed individually as 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]} } Note that a configuration may be adopted in which disp=d is used, the same variable name is assigned before and after the transformation, and the value of d is updated by the coordinate transformation.

[0102] Alternatively, the following configuration may be used. 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 three-dimensional vectors (in the Cartesian coordinate system) corresponding to each axis of the local coordinate system of the adjacent region.

[0103] Also, the following configuration may be used. 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 Cartesian coordinate system) corresponding to each axis 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 used where it can be selected according to the value of the coordinate system conversion information displacementCoordinateSystem decoded from the encoded data as in the following configuration. 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 } (Motion information decoding) 18 is a functional block diagram showing a configuration of the motion information decoding unit 3032. The motion information decoding unit 3032 includes a motion information prediction unit 30321 and a CABAC decoding unit (an arithmetic decoding unit 3051, a multi-value conversion unit 3052, a context selection unit 3056, and a context initialization unit 3057).

[0104] (Syntax structure of motion information) 19 is an example of the syntax structure of motion information (motion vector prediction residual, mesh motion vector). The semantics are as follows:

[0105] sismu_derived_mv_present_flag[subMeshID]: indicates whether sismu_mv_signalled_flag exists. 1 if it exists, 0 if it does not.

[0106] sismu_mv_signalled_flag[subMeshID][v]: indicates whether or not there is a motion vector for the vertex with index v. If this syntax element does not exist, sismu_mv_signalled_flag[subMeshID][v] is estimated to be 1.

[0107] When sismu_mv_signalled_flag is other than 0, the motion information decoding unit 3032 decodes the syntax elements sismu_mv_residual_abs_gt0, sismu_mv_residual_sign, sismu_mv_residual_abs_gt1, and sismu_mv_residual_abs_rem.

[0108] sismu_mv_pred_mode_group[subMeshID][g]: indicates the prediction method for motion vectors of the group with index g in the submesh subMeshID.

[0109] sismu_mv_residual_abs_gt0[subMeshID][v][k]: Indicates whether the absolute value of the k component of the motion vector prediction residual of the vertex of index v in submesh subMeshID is greater than 0. If it is greater, it is set to 1; if not, it is set to 0. If this syntax element does not exist, it is assumed to be 0.

[0110] sismu_mv_residual_sign[subMeshID][v][k]: indicates whether the k component of the motion vector prediction residual of the vertex of index v in the submesh subMeshID is a positive number. 1 if positive, Otherwise (if negative), 0. If this syntax element is not present, 1 is inferred.

[0111] sismu_mv_residual_abs_gt1[subMeshID][v][k]: Indicates whether the absolute value of the k component of the motion vector prediction residual of the vertex of index v in submesh subMeshID is greater than 1. If it is greater, it is set to 1; if not, it is set to 0. If this syntax element does not exist, it is assumed to be 0.

[0112] sismu_mv_residual_abs_rem[subMeshID][v][k]: This indicates the absolute value of the k component of the motion vector prediction residual of the vertex with index v in the submesh subMeshID minus 2. If this syntax element does not exist, it is assumed to be 0.

[0113] The motion information decoding unit 3032 decodes sismu_derived_mv_present_flag if the number of vertices vertexCount of the submesh subMeshID is positive.

[0114] The motion information decoding unit 3032 decodes sismu_mv_signalled_flag for each vertex i of the submesh if sismu_derived_mv_present_flag is a predetermined value (for example, other than 0).

[0115] The motion information decoding unit 3032 decodes sismu_mv_pred_mode_group for each group g of sub-meshes.

[0116] The motion information decoding unit 3032 decodes sismu_mv_residual_abs_gt0 for each submesh group g, each index v, and each component k of the motion vector prediction residual, and if sismu_mv_residual_abs_gt0 is a predetermined value (for example, other than 0), decodes the subsequent sismu_mv_residual_sign and sismu_mv_residual_abs_gt1.

[0117] The motion information decoding unit 3032 decodes the subsequent sismu_mv_residual_abs_rem for each submesh group g, each index v, and each component k of the motion vector prediction residual when sismu_mv_residual_abs_gt1 is a predetermined value (eg, other than 0).

[0118] As with the syntax structure of mesh displacement, sismu_mv_residual_abs_gt2[subMeshID][v][k] and sismu_mv_residual_abs_gt3[subMeshID][v][k] may also be used.

[0119] (Operation of the motion information decoding unit) The motion information prediction unit 30321 predicts a motion vector corresponding to a current vertex based on a motion vector corresponding to a decoded vertex and a prediction method indicated by sismu_mv_pred_mode_group (a prediction method indicated by predIndex, described later), and derives a predicted motion vector MvPred.

[0120] The basic operation of the CABAC decoding unit (arithmetic decoding unit 3051, multi-value conversion unit 3052, context selection unit 3056, and context initialization unit 3057) is similar to that of the CABAC decoding unit of the mesh displacement decoding unit 305. In the motion vector prediction method and arithmetic decoding of the prediction residual, etc., the following different context arrangements may be used depending on the components (dimensions) of the motion vector, etc. The context includes the following variables indicating the occurrence probability of a binary signal. ctxMvPred ctxMvCoeffGtN[MAX_GTN+1][numDim] ctxMvCoeffRemPrefix[numPrefixBin] Here, numDim is the number of dimensions of the motion vector, and may be set to numDim=3. The maximum value MAX_GTN of the threshold for the coefficient may be set to 1. numPrefixBin is the number of bins that use the context in the prefix, and may be set to numPrefixBin=2.

[0121] ctxMvPred is a context used for decoding the syntax element sismu_mv_pred_mode_group. The arithmetic decoding unit 3051 decodes sismu_mv_pred_mode_group using the value of ctxMvPred.

[0122] The arithmetic decoding unit 3051 decodes the sismu_mv_residual_sign in the dimension k of the motion vector without using a context.

[0123] ctxMvCoeffGtN[MAX_GTN+1][numDim] is a context array used for decoding the syntax element sismu_mv_residual_abs_gtN (N is replaced with 0 or 1). The arithmetic decoding unit 3051 decodes sismu_mv_residual_abs_gtN in dimension k of the motion vector using the value of ctxMvCoeffGtN[N][k].

[0124] ctxMvCoeffRemPrefix[numPrefixBin] is an array of contexts used for decoding the syntax element sismu_mv_residual_abs_rem. ctxMvCoeffRemPrefix[bin] indicates a context at a bin position in the binarization of the prefix of sismu_mv_residual_abs_rem. The arithmetic decoding unit 3051 decodes each bin of the prefix of sismu_mv_residual_abs_rem of the motion vector using the value of ctxMvCoeffRemPrefix[bin].

[0125] (Motion information derivation process) The motion information decoding unit 3032 decodes the syntax elements sismu_mv_pred_mode_group, sismu_mv_residual_sign, sismu_mv_residual_abs_gt0, sismu_mv_residual_abs_gt1, and sismu_mv_residual_abs_rem from the encoded data and derives the motion vector prediction residual MvPredResidual by the following processing. groupSize = bmsps_inter_mesh_motion_group_size_minus1 + 1 groupCount = (vertexCount - 1) / groupSize + 1 vStart = 0 for (g = 0; g < groupCount; g++) { / / decode sismu_mv_pred_mode_group predIndex = decode(ctxMvPred) if (sismu_mv_signalled_flag[subMeshId][v]) { for (v = vStart; v < vStart + groupSize; v++) { / / vertex loop for (k = 0; k < 3; k++) { / / dimension (component) loop value = 0 / / decode sismu_mv_residual_abs_gt0 sismu_mv_residual_abs_gt0[subMeshId][v][k] = decode(ctxMvCoeffGtN[0][k]) if (sismu_mv_residual_abs_gt0[subMeshId][v][k]) { value++ / / decode sismu_mv_residual_sign sismu_mv_residual_sign[subMeshID][v][k] = decode_bypass() / / decode sismu_mv_residual_abs_gt1 sismu_mv_residual_abs_gt1[subMeshID][v][k] = decode(ctxMvCoeffGtN[1][k]) if (sismu_mv_residual_abs_gt1[subMeshID][v][k]) { / / decode sismu_mv_residual_abs_rem sismu_mv_residual_abs_rem[subMeshID][v][k] = decodeExpGolomb(ctxMvCoeffRemPrefix) value += (1 + sismu_mv_residual_abs_rem[subMeshID][v][k]) } if (sismu_mv_residual_sign[subMeshID][v][k]) { value = -value } } MvPredResidual[subMeshID][v][k] = value } } } vStart += groupSize } Here, bmsps_inter_mesh_motion_group_size_minus1 is the number of vertex groups in motion information (motion vector) coding minus 1, and is notified by a sequence-level control parameter. The method for the sign of the coefficient may be the method of inversion (value = -value) according to the value of sismu_mv_residual_sign[subMeshID][v][k] in the above syntax, or the following arithmetic operation.

[0126] MvPredResidual[subMeshID][v][k] = (1 - 2 * sismu_mv_residual_sign[subMeshID][v][k]) * value Or you can use the following with the positive and negative reversed:

[0127] MvPredResidual[subMeshID][v][k] = (2 * sismu_mv_residual_sign[subMeshID][v][k] - 1) * value The motion information decoding unit 3032 derives the motion vector Mv by the following process. Mv = MvPred + MvPredResidual or Mv[subMeshID][v][k] = MvPred[subMeshID][v][k] + MvPredResidual[subMeshID][v][k]. k=0..2 (Configuration that uses context for some bins in the prefix) Fig. 20 shows the setting of the context used by the motion information decoding unit 3032. The motion information decoding unit 3032 (context selection unit 3056) decodes sismu_mv_pred_mode_group, sismu_mv_residual_abs_gt0, and sismu_mv_residual_abs_gt1 using the context. The motion information decoding unit 3032 (context selection unit 3056) decodes sismu_mv_residual_sign without using the context (bypassing). The motion information decoding unit 3032 (context selection unit 3056) decodes the first part of the prefix of sismu_mv_residual_abs_rem using the context, the rest of the prefix is ​​bypassed, and the suffix is ​​bypassed. In particular, bin=0 of the prefix may be used as the context, and bin>=1 and the following of the prefix may be bypassed (Fig. 20(a)). Alternatively, different contexts may be assigned to bin=0 and bin=1 of the prefix, and bin>=2 and onward of the prefix may be decoded using a bypass (FIG. 20(b)). Also, different contexts may be assigned to bin=0, bin=1, and bin=2 of the prefix, and bin>=3 and onward of the prefix may be decoded using a bypass. According to the above, even when the value to be ExpGolomb encoded becomes large, only a maximum of two (or three) contexts are used, so the complexity can be reduced compared to when contexts are used for all bins of the residual (sismu_mv_residual_abs_rem). Also, encoding can be performed more efficiently than when a bypass is used for all bins of sismu_mv_residual_abs_rem.

[0128] In FIG. 20, the context ctxMvPred with CtxTbl=0 is used to decode sismu_mv_pred_mode_group. The context ctxMvCoeffGtN[CtxInc][k] with CtxTbl=1 is used to decode sismu_mv_residual_abs_gtN (CtxInc is replaced with N). The context ctxMvCoeffRemPrefix[CtxInc] with CtxTbl=2 is used to decode the prefix of sismu_mv_residual_abs_rem (CtxInc is replaced with prefix bin). (Configuration for limiting the number of context coding bins to be decoded) In order to reduce the complexity of the context coding, the number of context-coded bins may be limited. Specifically, the motion information decoding unit 3032 (context selection unit 3056) counts the number of bins decoded by context coding in the syntax element of sismu_mv_residual_abs_rem for each group (groupSize) in a predetermined unit. Then, when the counted value is equal to or greater than a predetermined value maxContextInGroup, each bin of sismu_mv_residual_abs_rem may be switched from decoding using a context to decoding without using a context (bypass, using a static context). Pseudo code for this example is shown below. for (g = 0; g < groupCount; g++) { countCtx = 0 / / decode sismu_mv_pred_mode_group predIndex = decode(ctxMvPred) if (sismu_mv_signalled_flag[subMeshId][v]) { for (v = vStart; v < vStart + groupSize; v++) { / / vertex loop for (k = 0; k < 3; k++) { / / dimension (component) loop value = 0 / / decode sismu_mv_residual_abs_gt0 sismu_mv_residual_abs_gt0[subMeshId][v][k] = decode(ctxMvCoeffGtN[0][k]) if (sismu_mv_residual_abs_gt0[subMeshId][v][k]) { value++ / / decode sismu_mv_residual_sign sismu_mv_residual_sign[subMeshID][v][k] = decode_bypass() / / decode sismu_mv_residual_abs_gt1 sismu_mv_residual_abs_gt1[subMeshID][v][k] = decode(ctxMvCoeffGtN[1][k]) if (sismu_mv_residual_abs_gt1[subMeshID][v][k]) { / / decode sismu_mv_residual_abs_rem if (countCtx < maxContextInGroup) { sismu_mv_residual_abs_rem[subMeshID][v][k] = decodeExpGolomb(ctxMvCoeffRemPrefix) countCtx += 2 } else { sismu_mv_residual_abs_rem[subMeshID][v][k] = decodeExpGolomb(ctxStatic) } value += (1 + sismu_mv_residual_abs_rem[subMeshID][v][k]) } if (sismu_mv_residual_sign[subMeshID][v][k]) { value = -value } } MvPredResidual[subMeshID][v][k] = value } } } vStart += groupSize } According to the above, the maximum value (worst case) of the number of bins to be context-coded can be reduced.

[0129] (Mesh reconstruction) 6 is a functional block diagram showing the configuration of the mesh reconstruction unit 307. The mesh reconstruction unit 307 is made up of a mesh division unit 3071 and a mesh deformation unit 3072.

[0130] The mesh dividing unit 3071 divides the base mesh output from the base mesh decoding unit 303 to generate divided meshes.

[0131] Fig. 9(a) shows a part (triangle) of the base mesh, and the triangle is composed of vertices v1, v2, and v3. v1, v2, and v3 are three-dimensional vectors. The mesh division unit 3071 generates and outputs a divided mesh by adding new vertices v12, v13, and v23 to the middle of each side of the triangle (Fig. 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 division mesh and the mesh displacement, and outputs the mesh displacement d12, A deformed mesh is generated and output by adding d13 and d23 (FIG. 9(c)). The mesh displacement is the output of the mesh displacement decoding unit 305 (coordinate system conversion unit 3055). d12, d13, and d23 are 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 In addition, d12 = disp[0][], d23 = disp[1][], and d23 = disp[3][] may also be used.

[0132] (Configuration of 3D data encoding device according to the first embodiment) 10 is a functional block diagram showing a schematic configuration of a 3D data encoding device 11 according to the first embodiment. The 3D data encoding device 11 includes an atlas information encoding unit 101, a base mesh encoding unit 103, a base mesh decoding unit 104, a mesh displacement updating unit 106, a mesh displacement encoding unit 107, a mesh displacement decoding unit 108, a mesh reconstruction unit 109, an attribute updating 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 receives atlas information, a base mesh, a mesh displacement, a mesh, and an attribute image as 3D data, and outputs encoded data.

[0133] The atlas information encoding unit 101 encodes the atlas information and outputs an atlas information encoded stream.

[0134] The base mesh encoding unit 103 encodes the base mesh and outputs a base mesh encoded stream. Draco or the like is used as the encoding method.

[0135] The base mesh decoding unit 104 is similar to the base mesh decoding unit 303, and therefore a description thereof will be omitted.

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

[0137] The mesh displacement encoding unit 107 encodes the updated mesh displacement and outputs a mesh displacement encoded stream.

[0138] The mesh displacement decoding unit 108 is similar to the mesh displacement decoding unit 305, and therefore a description thereof will be omitted.

[0139] The mesh reconstruction unit 109 is similar to the mesh reconstruction unit 307, and therefore a description thereof will be omitted.

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

[0141] The padding unit 111 receives the attribute image and performs padding processing on areas where pixel values ​​are empty.

[0142] A color space conversion unit 112 performs color space conversion from the RGB format to the YCbCr format.

[0143] The attribute encoding unit 113 encodes the attribute image in the YCbCr format output from the color space conversion unit 112, and outputs an attribute video stream. As an encoding method, VVC, HEVC, or the like is used.

[0144] The multiplexing unit 114 multiplexes the atlas information coded stream, the base mesh coded stream, the mesh displacement coded stream, and the attribute video stream, and outputs the multiplexed data as coded data. As a multiplexing method, a byte stream format, ISOBMFF, or the like is used.

[0145] (Mesh separation unit operation) The mesh separator 115 generates a base mesh and a mesh displacement from the mesh.

[0146] 13 is a functional block diagram showing the configuration of the mesh separation unit 115. The mesh separation unit 115 is made up of a mesh thinning unit 1151, a mesh division unit 1152, and a mesh displacement derivation unit 1153.

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

[0148] FIG. 14(a) shows a part of a mesh, which is made up of vertices v1, v2, v3, v4, v5, 14B, the mesh is composed of vertices v1, v2, v3, v4, v5, and v6. Each of v1, v2, v3, v4, v5, and v6 is a three-dimensional vector. The mesh thinning unit 1151 generates and outputs a base mesh by thinning out the vertices v4, v5, and v6 (FIG. 14B).

[0149] The mesh dividing unit 1152, like the mesh dividing unit 3071, divides the base mesh to generate divided meshes (FIG. 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, d6 of vertices v4, v5, v6 relative to vertices v4', v5', v6' as mesh displacements based on the mesh and the divided meshes (FIG. 14(d)). d4 = v4 - v4' d5 = v5 - v5' d6 = v6 - v6' (Base mesh encoding) FIG. 11 is a functional block diagram showing the configuration of the base mesh encoding unit 103. The mesh encoding unit 103 is composed of a mesh encoding unit 1031, a mesh decoding unit 1032, a motion information encoding 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 encoding unit 103 may be configured to include a base mesh quantization unit (not shown) after the input of the base mesh. When the base mesh is encoded without referring to other base meshes (for example, an already encoded base mesh) (intra-encoding), the switch 1037 and the switch 3038 are connected to the side that does not perform motion compensation. When the base mesh is encoded with reference to other base meshes (inter-encoding), on the other hand, they are connected to the side that performs motion compensation.

[0150] The mesh encoding unit 1031 has an intra-encoding function, intra-encodes the base mesh, and outputs a base mesh encoded stream. Draco or the like is used as the encoding method.

[0151] The mesh decoding unit 1032 is similar to the mesh decoding unit 3031, and therefore a description thereof will be omitted.

[0152] The motion information coding unit 1033 has an inter-coding function, inter-codes the base mesh, and outputs a base mesh coded stream. The coding method used is entropy coding such as arithmetic coding.

[0153] The motion information decoding unit 1034 is similar to the motion information decoding unit 3032, and therefore a description thereof will be omitted.

[0154] The mesh motion compensation unit 1035 is similar to the mesh motion compensation unit 3033, and therefore a description thereof will be omitted.

[0155] The reference mesh memory 1036 is similar to the reference mesh memory 3034, and therefore a description thereof will be omitted.

[0156] (Mesh displacement encoding) 12 is a functional block diagram showing the configuration of the mesh displacement encoding unit 107. The mesh displacement encoding unit 107 is made up of a coordinate system conversion unit 1071, a conversion unit 1072, a quantization unit 1073, a binarization unit 1074, an arithmetic encoding unit 1075, a context selection unit 1076, and a context initialization unit 1077.

[0157] The coordinate system conversion unit 1071 converts the coordinate system of the mesh displacement from a Cartesian coordinate system to a coordinate system that encodes the displacement (for example, a local coordinate system) based on the value of the coordinate system conversion information displacementCoordinateSystem. Here, disp is a three-dimensional vector indicating the mesh displacement before the coordinate system conversion, d is a three-dimensional vector indicating the mesh displacement after the coordinate system conversion, and n_vec, t_vec, and b_vec are three-dimensional vectors (of the Cartesian coordinate system) indicating 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 encoding 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.

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

[0159] To change the displacementCoordinateSystem at the picture / frame level, use the configuration syntax in Figure 8. For ag, set 1 if you want to update the coordinate system, or 0 if you don't want to update the coordinate system. For afps_vdmc_ext_displacement_coordinate_system, set 0 if you want to use the Cartesian coordinate system, or set 1 if you want to use the local coordinate system.

[0160] A transform unit 1072 performs a transform f (eg, wavelet transform) and derives a mesh displacement Tdisp after the transform. Tdisp[0][] = f(d[0][]) Tdisp[1][] = f(d[1][]) Tdisp[2][] = f(d[2][]) The quantization unit 1073 performs quantization based on a quantization scale value "scale" derived from the quantization parameter of each component of the mesh displacement, and derives a mesh displacement Qdisp after quantization. Qdisp[0][] = Tdisp[0][] / scale[0] Qdisp[1][] = Tdisp[1][] / scale[1] Qdisp[2][] = Tdisp[2][] / scale[2] Alternatively, the scale value may be approximated by a power of 2 and Qdisp may 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-value signal, into a binary signal. The binary signal may be a k-th order exponential-Golomb code.

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

[0162] The context selection unit 1076 is similar to the context selection unit 3056, and therefore a description thereof will be omitted.

[0163] Note that a static context with a fixed probability that is not updated is defined as ctxStatic. The syntax element indicated by ctxStatic may be encoded without using a context. Encode(ctxStatic) may use a process dedicated to bypass as encode_bypass().

[0164] The context initialization unit 1077 is similar to the context initialization unit 3057, and therefore a description thereof will be omitted. Although an example using a context will be described here, some syntax elements may be bypass coded without using a context. The bypass coding configuration has the effect of reducing the memory and processing amount 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 coded without using a context. By bypass coding these syntax elements, it is possible to reduce the memory and processing amount of the context while maintaining the coding efficiency.

[0165] The mesh displacement encoding 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 top of the loop (the next iteration). Here, encode() and encodeExpGolomb() are functions that take a value and corresponding context as arguments and arithmetically encode a 1-bit value and a k-th order Golomb code binary string, respectively. dispCount[b] is the number of mesh displacements at detail level b. lastSig is a flag indicating whether the current coefficient is the last nonzero coefficient in the subblock in scan order. lastSig=0 indicates that the current coefficient is not the last nonzero coefficient in the subblock in scan order. lastSig=1 indicates that the current coefficient is the last nonzero coefficient in the subblock in scan order.

[0166] Alternatively, the mesh displacement Qdisp may be encoded using 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) N = 1 maxGtN = 3 while (N <= maxGtN) { d = abs(d) - 1 / / encode diu_coeff_abs_level_gtN (N=1..maxGtN) encode(d != 0, ctxCoeffGtN[ft][b][N][k]) if (!d) break N++ } if (d) { / / encode diu_coeff_abs_level_rem encodeExpGolomb(--d, ctxCoeffRemPrefix[ft][b][k]) } } } dispOffset += dispCount[b] } } Note that maxGtN is not limited to 3, and for example, maxGtN=2 may be used to encode the syntax elements diu_coeff_abs_level_gt0, diu_coeff_abs_level_gt1, and diu_coeff_abs_level_gt2, or maxGtN=4 may be used to encode the syntax elements diu_coeff_abs_level_gt0, diu_coeff_abs_level_gt1, diu_coeff_abs_level_gt2, diu_coeff_abs_level_gt3, and diu_coeff_abs_level_gt4.

[0167] (Motion information encoding) 21 is a functional block diagram showing the configuration of the motion information encoding unit 1033. The motion information encoding unit 1033 includes a motion information prediction unit 10331, a binarization unit 1074, an arithmetic encoding unit 1075, a context selection unit 1076, and a context initialization unit 1077.

[0168] The motion information prediction unit 10331 is similar to the motion information prediction unit 30321, and therefore a description thereof will be omitted.

[0169] The motion information encoding unit 1033 encodes the motion vector prediction residual MvPredResidual (= Mv - MvPred) by the following process. / / encode sismu_mv_pred_mode_group encode(predIndex, ctxMvPred) for (v = 0; v < vertexCount; v++) { for (k = 0; k < 3; k++) { value = MvPredResidual[subMeshID][v][k] / / encode sismu_mv_residual_abs_gt0 encode(value != 0, ctxMvCoeffGtN[0][k]) if (value == 0) continue / / encode sismu_mv_residual_sign encode_bypass(value < 0) value = abs(value) - 1 / / encode sismu_mv_residual_abs_gt1 encode(value != 0, ctxMvCoeffGtN[1][k]) if (value == 0) continue encodeExpGolomb(--value, ctxMvCoeffRemPrefix) }} Although one embodiment of the present invention has been described in detail above with reference to the drawings, the specific configuration is not limited to the above, and various design changes, etc. are possible within the scope that does not deviate from the gist of the present invention.

[0170] [Application example] The above-mentioned 3D data encoding device 11 and 3D data decoding device 31 can be mounted on various devices that transmit, receive, record, and play back 3D data for use. Note that 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.

[0171] The present invention is not limited to the above-described embodiment, and various modifications are possible within the scope of the claims. In other words, the technical scope of the present invention also includes embodiments obtained by combining technical means that are appropriately modified within the scope of the claims. [Industrial Applicability]

[0172] The embodiments of the present invention can be suitably applied to a 3D data decoding device that decodes encoded data in which 3D data is encoded, and a 3D data encoding device that generates encoded data in which 3D data is encoded. Also, the embodiments of the present invention 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]

[0173] 11 3D data encoding device 101 Atlas Information Encoding Unit 103 Base mesh coding unit 1031 Mesh coding unit 1032 Mesh Decoding Unit 1033 Motion information encoding unit 10331 Motion Information Prediction 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 Encoding Unit 1071 Coordinate system conversion section 1072 Converter 1073 Quantization section 1074 Binarization section 1075 Arithmetic encoder 1076 Context Selection 1077 Context Initialization Section 108 Mesh Displacement Decoding Unit 109 Mesh reconstruction unit 110 Attribute Update Section 111 Padding section 112 Color space conversion section 113 Attribute Encoding Unit 114 Multiplexer 115 Mesh separation section 1151 Mesh thinning section 1152 Mesh division section 1153 Mesh displacement derivation part 21 Network 31 3D data decoding device 301 Demultiplexer 302 Atlas Information Decoding Unit 303 Base Mesh Decoding Unit 3031 Mesh Decoding Unit 3032 Motion information decoding unit 30321 Motion Information Prediction Unit 3033 Mesh Motion Compensation Unit 3034 Reference Mesh Memory 3035 Switch 3036 Switch 305 Mesh Displacement Decoding Unit 3051 Arithmetic Decoding Unit 3052 Multi-level conversion section 3053 Inverse quantization section 3054 Reverse conversion unit 3055 Coordinate system conversion section 3056 Context Selection Section 3057 Context Initialization Unit 307 Mesh reconstruction unit 306 Attribute Decoder 3071 Mesh division section 3072 Mesh transformation part 308 Color Space Conversion Unit 41 3D data display device

Claims

1. A 3D data decoding device for decoding encoded data, comprising an arithmetic decoding unit for arithmetically decoding mesh displacement from the encoded data, The 3D data decoding device is characterized in that the arithmetic decoding unit decodes a leading portion of a residual prefix of the absolute value of the coefficient of the mesh displacement using a context.

2. The arithmetic decoding unit counts the number of bins of the prefix decoded using a context for each subblock, and when the number of bins is equal to or greater than a predetermined value, switches from decoding using a context to decoding without using a context for the bins of the prefix. The 3D data decoding device according to claim 1,

3. A 3D data encoding device for encoding 3D data includes an arithmetic encoding unit for arithmetically encoding mesh displacement, The 3D data encoding device is characterized in that the arithmetic coding unit encodes a leading portion of a residual prefix of the absolute value of the coefficient of the mesh displacement using a context.

4. The 3D data encoding device according to claim 3, characterized in that the arithmetic coding unit counts the number of bins of the prefix encoded using a context for each sub-block, and when the number of bins is equal to or greater than a predetermined value, switches the encoding of the bins of the prefix from encoding using a context to encoding without using a context.

5. A 3D data decoding device for decoding encoded data, comprising: an arithmetic decoding unit for arithmetically decoding a mesh motion vector from the encoded data; The 3D data decoding device, wherein the arithmetic decoding unit decodes a leading portion of a residual prefix of an absolute value of a coefficient of the mesh motion vector using a context.

6. The 3D data decoding device according to claim 5, characterized in that the arithmetic decoding unit counts the number of bins of the prefix decoded using a context for each prediction group of the motion vector, and when the number of bins is equal to or greater than a predetermined value, switches the decoding of the bins of the prefix from decoding using a context to decoding without using a context.

7. A 3D data encoding device for encoding 3D data, comprising an arithmetic encoding unit for arithmetically encoding a mesh motion vector, The 3D data encoding device is characterized in that the arithmetic encoding unit encodes a leading portion of a residual prefix of the absolute value of the coefficient of the mesh motion vector using a context.

8. The 3D data encoding device according to claim 7, characterized in that the arithmetic coding unit counts the number of bins of the prefix coded using a context for each prediction group of the motion vector, and when the number of bins is equal to or greater than a predetermined value, switches from coding using a context to coding not using a context for coding the bins of the prefix.

Images