ISO/IEC 14496-16:2009/FDAmd 1

Information technology - Coding of audio-visual objects - Part 16: Animation Framework eXtension (AFX) - Amendment 1: Scalable complexity 3D mesh coding

Technologies de l'information — Codage des objets audiovisuels — Partie 16: Extension du cadre d'animation (AFX) — Amendement 1: Codage de maillage 3D de complexité échelonnable

General Information

• Status: Withdrawn
• ICS: 35.040 - Information coding
• ICS: 35.040.40 - Coding of audio, video, multimedia and hypermedia information
• Technical Committee: ISO/IEC JTC 1/SC 29 - Coding of audio, picture, multimedia and hypermedia information
• Drafting Committee: ISO/IEC JTC 1/SC 29 - Coding of audio, picture, multimedia and hypermedia information
• Current Stage: 5098 - Project deleted
• Start Date: 10-Sep-2010
• Completion Date: 30-Oct-2025

Relations

• Amends: ISO/IEC 14496-16:2009 - Information technology - Coding of audio-visual objects - Part 16: Animation Framework eXtension (AFX)
• Effective Date: 09-May-2020
• Revised: ISO/IEC 14496-16:2011 - Information technology - Coding of audio-visual objects - Part 16: Animation Framework eXtension (AFX)
• Effective Date: 18-Sep-2010

Standards Content (Sample)

FINAL ISO/IEC
AMENDMENT
DRAFT 14496-16:2009
FDAM 1
ISO/IEC JTC 1
Information technology — Coding of
Secretariat: ANSI
audio-visual objects —
Voting begins on:
2010-05-18
Part 16:
Animation Framework eXtension (AFX)
Voting terminates on:
2010-07-18
AMENDMENT 1: Scalable complexity 3D
mesh coding
Technologies de l'information — Codage des objets audiovisuels —
Partie 16: Extension du cadre d'animation (AFX)
AMENDEMENT 1: Codage de maillage 3D de complexité échelonnable

RECIPIENTS OF THIS DRAFT ARE INVITED TO
SUBMIT, WITH THEIR COMMENTS, NOTIFICATION
OF ANY RELEVANT PATENT RIGHTS OF WHICH
THEY ARE AWARE AND TO PROVIDE SUPPORT-
ING DOCUMENTATION.
IN ADDITION TO THEIR EVALUATION AS
Reference number
BEING ACCEPTABLE FOR INDUSTRIAL, TECHNO-
ISO/IEC 14496-16:2009/FDAM 1:2010(E)
LOGICAL, COMMERCIAL AND USER PURPOSES,
DRAFT INTERNATIONAL STANDARDS MAY ON
OCCASION HAVE TO BE CONSIDERED IN THE
LIGHT OF THEIR POTENTIAL TO BECOME STAN-
DARDS TO WHICH REFERENCE MAY BE MADE IN
©
ISO/IEC 2010
NATIONAL REGULATIONS.
ISO/IEC 14496-16:2009/FDAM 1:2010(E)
PDF disclaimer
This PDF file may contain embedded typefaces. In accordance with Adobe's licensing policy, this file may be printed or viewed but
shall not be edited unless the typefaces which are embedded are licensed to and installed on the computer performing the editing. In
downloading this file, parties accept therein the responsibility of not infringing Adobe's licensing policy. The ISO Central Secretariat
accepts no liability in this area.
Adobe is a trademark of Adobe Systems Incorporated.
Details of the software products used to create this PDF file can be found in the General Info relative to the file; the PDF-creation
parameters were optimized for printing. Every care has been taken to ensure that the file is suitable for use by ISO member bodies. In
the unlikely event that a problem relating to it is found, please inform the Central Secretariat at the address given below.

Copyright notice
This ISO document is a Draft International Standard and is copyright-protected by ISO. Except as permitted
under the applicable laws of the user's country, neither this ISO draft nor any extract from it may be
reproduced, stored in a retrieval system or transmitted in any form or by any means, electronic,
photocopying, recording or otherwise, without prior written permission being secured.
Requests for permission to reproduce should be addressed to either ISO at the address below or ISO's
member body in the country of the requester.
ISO copyright office
Case postale 56 • CH-1211 Geneva 20
Tel. + 41 22 749 01 11
Fax + 41 22 749 09 47
E-mail [e-mail]
Web www.iso.org
Reproduction may be subject to royalty payments or a licensing agreement.
Violators may be prosecuted.
ii © ISO/IEC 2010 – All rights reserved

ISO/IEC 14496-16:2009/FDAM 1:2010(E)
Foreword
ISO (the International Organization for Standardization) and IEC (the International Electrotechnical
Commission) form the specialized system for worldwide standardization. National bodies that are members of
ISO or IEC participate in the development of International Standards through technical committees
established by the respective organization to deal with particular fields of technical activity. ISO and IEC
technical committees collaborate in fields of mutual interest. Other international organizations, governmental
and non-governmental, in liaison with ISO and IEC, also take part in the work. In the field of information
technology, ISO and IEC have established a joint technical committee, ISO/IEC JTC 1.
International Standards are drafted in accordance with the rules given in the ISO/IEC Directives, Part 2.
The main task of the joint technical committee is to prepare International Standards. Draft International
Standards adopted by the joint technical committee are circulated to national bodies for voting. Publication as
an International Standard requires approval by at least 75 % of the national bodies casting a vote.
Attention is drawn to the possibility that some of the elements of this document may be the subject of patent
rights. ISO and IEC shall not be held responsible for identifying any or all such patent rights.
Amendment 1 to ISO/IEC 14496-16:2009 was prepared by Joint Technical Committee ISO/IEC JTC 1,
Information technology, Subcommittee SC 29, Coding of audio, picture, multimedia and hypermedia
information.
© ISO/IEC 2010 – All rights reserved iii

ISO/IEC 14496-16:2009/FDAM 1:2010(E)

Information technology — Coding of audio-visual objects —
Part 16:
Animation Framework eXtension (AFX)
AMENDMENT 1: Scalable complexity 3D mesh coding
Page 2, immediately before 3.1
Add the following:
4C 4-bits-based coding
AC Arithmetic Coding
BPC Bit Precision Coding
SVA Shared Vertex Analysis
TFAN Triangle FAN
QBCR Quantization Based Compact Representation

The mathematical operators used to describe this part of ISO/IEC 14496 are similar to those used in the C
programming language. However, integer divisions with truncation and rounding are specifically defined.
Numbering and counting loops generally begin from zero.
Arithmetic operators
+ Addition.
- Subtraction (as a binary operator) or negation (as a unary operator).
++ Increment. i.e. x++ is equivalent to x = x + 1
- - Decrement. i.e. x-- is equivalent to x = x - 1
×
Multiplication.
∗
^ Power.
/ Integer division with truncation of the result toward zero. For example, 7/4 and -7/-4 are truncated
to 1 and -7/4 and 7/-4 are truncated to -1.
÷ Used to denote division in mathematical equations where no truncation or rounding is intended.
© ISO/IEC 2010 – All rights reserved 1

ISO/IEC 14496-16:2009/FDAM 1:2010(E)
% Modulus operator. Defined only for positive numbers.
xx >= 0
Abs( )
Abs (x) =
−xx < 0
Logical operators
|| Logical OR.
&& Logical AND.
! Logical NOT.
Relational operators
> Greater than.
>= Greater than or equal to.
≥ Greater than or equal to.
< Less than.
<= Less than or equal to.
≤ Less than or equal to.
== Equal to.
!= Not equal to.
max [, … ,] the maximum value in the argument list.
min [, … ,] the minimum value in the argument list.
Bitwise operators
& AND
| OR
>> Shift right with sign extension.
<< Shift left with zero fill.
Assignment
= Assignment operator.
2 © ISO/IEC 2010 – All rights reserved

ISO/IEC 14496-16:2009/FDAM 1:2010(E)
Page 182, immediately before 4.3
Add the following new subclause.

4.2.5 Scalable Complexity 3D Mesh Coding
4.2.5.1 SC3DMC Bitstream structure
The Scalable Compression 3D Mesh Coding (SC3DMC) stream describes any triangular mesh represented
as an IndexedFaceSet, with single or multiple attributes defined per vertex of per triangle. The bitstream is
composed of two main components (cf. Figure AMD1.1):
- The header: describing general information about the coded mesh.
- The data stream: describing the connectivity and the geometry information of the mesh.

Figure AMD1.1 — SC3DMC stream structure.

The SC3DMCStream is encapsulated in an AFX stream and has the following AFX object code:
Table AMD1.1 — AFX object code
AFX object code Object Associated node Type value
of
bitwrapper
0x0C Scalable complexity Based IndexedFaceSet 2
Representation
When used in a BIFS scene, the value of the field "type" is 2.
4.2.5.2 SC3DMC Bitstream syntax and semantics
4.2.5.2.1 SC3DMCStream class
4.2.5.2.1.1 Syntax
class SC3DMCStream{
SC3DMCStreamHeader header;
SC3DMCStreamData data;
}
4.2.5.2.1.2 Semantics
SC3DMCStreamHeader: This is the header buffer of SC3DMC.
SC3DMCSteamData: This is the data buffer of SC3DMC.
© ISO/IEC 2010 – All rights reserved 3

ISO/IEC 14496-16:2009/FDAM 1:2010(E)
4.2.5.2.2 SC3DMCStreamHeader class
4.2.5.2.2.1 Syntax
class SC3DMCStreamHeader{
unsigned int (32) streamSize;
bit (8) encodingMode;
float (32) creaseAngle;
bit (1) ccw;
bit (1) solid;
bit (1) convex;
bit (1) colorPerVertex;
bit (1) normalPerVertex;
bit (1) otherAttributesPerVertex;
bit (1) isTriangularMesh;
bit (1) markerBit // always set as 1

unsigned int (32) numberOfCoord;
unsigned int (32) numberOfNormal
unsigned int (32) numberOfTexCoord;
unsigned int (32) numberOfColor;
unsigned int (32) numberOfOtherAttributes;

if (numberOfOtherAttributes >0)
unsigned int (8) dimensionOfOtherAttributes;
if (numberOfCoord>0) {
unsigned int (32) numberOfCoordIndex;
bit(8) QPforGeometry;
}
if (numberOfNormal>0) {
unsigned int (32) numberOfNormalIndex;
bit(8) QPforNormal;
}
if (numberOfColor>0) {
unsigned int (32) numberOfColorIndex;
bit(8) QPforColor;
}
if (numberOfTexCoord>0) {
unsigned int (32) numberOfTexCoordIndex;
bit(8) QPforTexCoord;
unsigned int (32) TexCoordWidth;
unsigned int (32) TexCoordHeight;

}
if (numberOfOtherAttributes >0) {
unsigned int (32) numberOfOtherAttributesIndex;
bit(8) QPforOtherAttributes
}
if (numberOfCoord>0) {
for(i=0;i<3;i++) {
float(32) quantMinGeometry[i];
float(32) quantRangeGeometry[i];
}
}
4 © ISO/IEC 2010 – All rights reserved

ISO/IEC 14496-16:2009/FDAM 1:2010(E)
If(numberOfNormal>0){
for(i=0;i<3;i++) {
float(32) quantMinNormal[i];
float(32) quantRangeNormal[i];
}
}
If(numberOfColor>0){
for(i=0;i<3;i++) {
float(32) quantMinColor[i];
float(32) quantRangeColor[i];
}
}
If(numberOfTexCoord>0){
{
for(i=0;i<2;i++) {
float(32) quantMinTexCoord[i];
float(32) quantRangeTexCoord[i];
}
}
If(numberOfOtherAttributes>0)
{
for(i=0;i< dimensionOfOtherAttributes;i++) {
float(32) quantMinOtherAttributes[i];
float(32) quantRangeOtherAttributes[i];
}
}
};
4.2.5.2.2.2 Semantics
streamSize: A 32-bit unsigned integer describing the size in bytes of the current SC3DMC stream.
encodingMode: A 8-bit unsigned integer indicating the encoding method for the connectivity
Table AMD1.2 — SC3DMC encoding modes
encodingMode Method
0 QBCR
1 SVA
2 TFAN
3-255 ISO reserved
creaseAngle: A 32-bit float indicating the IFS creaseAngle parameter which controls the default normal
generation process.
ccw: 1-bit flag describing the IFS ccw parameter, which indicates whether the vertices are ordered in a
counter-clockwise direction when the mesh is viewed from the outside.
solid: 1-bit flag describing the IFS solid parameter which indicates whether the shape encloses a volume.
convex: 1-bit flag describing the IFS solid parameter which indicates whether all faces in the shape are
convex (should be always 1 for triangular meshes).
© ISO/IEC 2010 – All rights reserved 5

ISO/IEC 14496-16:2009/FDAM 1:2010(E)
colorPerVertex: 1-bit flag describing the IFS colorPerVertex parameter which indicates whether the colors
are defined per vertex.
normalPerVertex: 1-bit flag describing the IFS normalPerVertex parameter which indicates whether the
normals are defined per vertex.
otherAttributesPerVertex: 1-bit flag describing whether the other attributes are defined per vertex.
isTriangularMesh: 1-bit flag describing whether the mesh is triangular (should be always 1).
markerBit: Always set as 1
numberOfCoord: A 32-bit unsigned integer indicating the number of position coordinates.
numberOfNormal: A 32-bit unsigned integer indicating the number of normal coordinates.
numberOfTexCoord: A 32-bit unsigned integer indicating the number of texture coordinates.
numberOfColor: A 32-bit unsigned integer indicating the number of color coordinates.
numberOfOtherAttributes: A 32-bit unsigned integer indicating the number of the other attributes.
dimensionOfOtherAttributes: A 32-bit unsigned integer indicating the dimension (i.e., number of attributes)
of the other attributes.
numberOfCoordIndex: A 32-bit unsigned integer indicating the number of faces associated to the position
coordinates.
numberOfNormalIndex: A 32-bit unsigned integer indicating the number of indices associated to the
normals.
numberOfColorIndex: A 32-bit unsigned integer indicating the number of indices associated to the colors.
numberOfTexCoordIndex: A 32-bit unsigned integer indicating the number of indices associated to the
texture coordinates.
numberOfOtherAttributesIndex: A 32-bit unsigned integer indicating the number of indices associated to the
other attributes.
QPforGeometry: A 8-bit data indicating quantization parameter for geometry.
QPforNormal: A 8-bit data indicating quantization parameter for normals.
QPforColor: A 8-bit data indicating quantization parameter for colour.
QPforTexCoord: A 8-bit data indicating quantization parameter for texture coordinate.
TexCoordWidth: A 32-bit unsigned integer indicating the width size of texture image.
TexCoordHeight: A 32-bit unsigned integer indicating the height size of texture image.
QPforOtherAttributes: A 8-bit data indicating quantization parameter for other attributes
quantMinGeometry[]:1 by 3 array containing 32 bit floating data indicating minimum value used for geometry
quantization
quantRangeGeometry: A 32-bit floating point data indicating range value used for geometry quantization
6 © ISO/IEC 2010 – All rights reserved

ISO/IEC 14496-16:2009/FDAM 1:2010(E)
quantRangeGeometryArr[]: 1 by 3 array containing 32 bit floating data indicating range value for each axes
used for geometry quantization
quantMinNormal[]: 1 by 3 array containing 32 bit floating data indicating minimum value used for normal
quantization
quantRangeNormal: A 32-bit floating point data indicating range value used for normal quantization
quantMinColor[]: 1 by 3 array containing 32 bit floating data indicating minimum value used for color
quantization
quantRangeColor: A 32-bit floating point data indicating range value used for color quantization
quantMinTexCoord[]: 1 by 2 array containing 32 bit floating data indicating minimum value used for texcoord
quantization
quantRangeTexCoord: A 32-bit floating point data indicating range value used for texcoord quantization
quantRangeOtherAttributes: A 32-bit floating point indicating range value used for normal quantization
4.2.5.2.3 SC3DMCStreamData class
4.2.5.2.3.1 Syntax
class SC3DMCStreamData{
if(encodingMode = 0)
{
DecodeIntArray (numberOfGeometry, numberOfCoordIndex*3, 1) decodedCoordIndex;

if(numberOfNormalIndex != 0)
{
if (normalPerVertex == 1)
DecodeIntArray (numberOfNormal, numberOfNormalIndex*3, 1) decodedNormalIndex;
else
DecodeIntArray (numberOfNormal, numberOfNormalIndex, 1) decodedNormalIndex;
}
if(numberOfColorIndex != 0)
{
if (colorPerVertex == 1)
DecodeIntArray (numberOfColor, numberOfColorIndex*3, 1) decodedColorIndex;
else
DecodeIntArray (numberOfColor, numberOfColorIndex, 1) decodedColorIndex;
}
If(numberOfTexCoord != 0)
{
DecodeIntArray (numberOfTexCoord, numberOfOTexCoordIndex*3, 1)
decodedTexCoordIndex;
}
If(numberOfOtherAttributeIndex != 0)
{
if (otherAttributesPerVertex == 1)
DecodeIntArray (numberOfotherAttributes, numberOfOtherAttributesIndex*
dimensionOfOtherAttributes , 1) decodedOtherAttributesIndex;
else
DecodeIntArray (numberOfOtherAttributesIndex, 1) decodedOtherAttributesIndex;
}
© ISO/IEC 2010 – All rights reserved 7

ISO/IEC 14496-16:2009/FDAM 1:2010(E)
If(numberOfCoord!= 0)
DecodefloatArray (numberOfCoord, 3, quantMinGeometry, quantRangeGeometry, tQP)
decodedCoord;
If (numberOfNormal != 0)
DecodefloatArray(numberOfNormal, 3, quantMinNormal, quantRangeNormal, tQP)
decodedNormal;
If (numberOfColor !=0)
DecodefloatArray (numberOfColor, 3, quantMinColor, quantRangeColor, tQP) decodedColor;
If (numberOfTexCoord !=0)
DecodefloatArray (numberOfTexCoord, 3, quantMinTexCoord, quantRangeTexCoord, tQP)
decodedColor;
If (numberOfOtherAttributes != 0)
DecodefloatArray (numberOfOtherAttributes, dimensionOfOtherAttributes,
quantMinOtherAttributes, quantRangeOtherAttributs, tQP)decodedOtherAttributes
}
else if (encodingMode = 1)
{
SVAIndexDecoder (numberOfGeometry, numberOfCoordIndex) decodedCoordIndex;

if(numberOfNormalIndex != 0)
{
SVAIndexDecoder (numberOfNormal, numberOfNormalIndex) decodedNormalIndex;
}
if(numberOfColorIndex != 0)
{
SVAIndexDecoder (numberOfColor, numberOfColorIndex) decodedColorIndex;
}
If(numberOfTexCoord != 0)
{
SVAIndexDecoder (numberOfTexCoord, numberOfOTexCoordIndex)
decodedTexCoordIndex;
}
If(numberOfOtherAttributeIndex != 0)
{
SVAIndexDecoder (numberOfotherAttributes, numberOfOtherAttributesIndex* dimensionOfOtherAttributes
, 1) decodedOtherAttributesIndex;
}
If(numberOfCoord!= 0)
DecodefloatArray (numberOfCoord, 3, quantMinGeometry, quantRangeGeometry, tQP)
decodedCoord;
If (numberOfNormal != 0)
DecodefloatArray(numberOfNormal, 3, quantMinNormal, quantRangeNormal, tQP)
decodedNormal;
If (numberOfColor !=0)
DecodefloatArray (numberOfColor, 3, quantMinColor, quantRangeColor, tQP) decodedColor;
If (numberOfTexCoord !=0)
DecodefloatArray (numberOfTexCoord, 3, quantMinTexCoord, quantRangeTexCoord, tQP)
decodedColor;
If (numberOfOtherAttributes != 0)
DecodefloatArray (numberOfOtherAttributes, dimensionOfOtherAttributes,
quantMinOtherAttributes, quantRangeOtherAttributs, tQP)decodedOtherAttributes
}
else if (encodingMode = 2)
{
8 © ISO/IEC 2010 – All rights reserved

ISO/IEC 14496-16:2009/FDAM 1:2010(E)
TFANIndexDecoder(3, numberOfCoord, numberOfCoordIndex, triangleOrderPres, 0)
decodedCoordIndex;
if(numberOfNormalIndex != 0)
{
if (normalPerVertex == 1)
TFANIndexDecoder(3, numberOfNormal, numberOfNormalIndex, 1, 1)
decodedNormalIndex;
else
SC3DMCDataDecoder(numberOfNormalIndex, 1) decodedNormalIndex;
}
if(numberOfColorIndex != 0)
{
if (colorPerVertex == 1)
TFANIndexDecoder(3, numberOfColor, numberOfColorIndex, 1, 1) decodedColorIndex;
else
SC3DMCDataDecoder(numberOfColorIndex, 1) decodedColorIndex;
}
If(numberOfTexCoord != 0)
{
TFANIndexDecoder(3, numberOfTexCoord, numberOfOtherAttributesIndex, 1, 1)
decodedTexCoordIndex;
}
If(numberOfOtherAttributeIndex != 0)
{
if (otherAttributesPerVertex == 1)
TFANIndexDecoder(3, numberOfOtherAttributes, numberOfOtherAttributesIndex, 1, 1)
decodedOtherAttributesIndex;
else
SC3DMCDataDecoder(numberOfOtherAttributesIndex, 1) decodedOtherAttributesIndex;
}
If(numberOfCoord!= 0)
DecodefloatArray (numberOfCoord, 3, quantMinGeometry, quantRangeGeometry, tQP)
decodedCoord;
If (numberOfNormal != 0)
DecodefloatArray(numberOfNormal, 3, quantMinNormal, quantRangeNormal, tQP)
decodedNormal;
If (numberOfColor !=0)
DecodefloatArray (numberOfColor, 3, quantMinColor, quantRangeColor, tQP) decodedColor;
If (numberOfTexCoord !=0)
DecodefloatArray (numberOfTexCoord, 3, quantMinTexCoord, quantRangeTexCoord, tQP)
decodedColor;
If (numberOfOtherAttributes != 0)
DecodefloatArray (numberOfOtherAttributes, dimensionOfOtherAttributes,
quantMinOtherAttributes, quantRangeOtherAttributs, tQP)decodedOtherAttributes

}
}
4.2.5.2.3.2 Semantics
decodedCoord: A reconstructed coordinate whose size is 1 by numberOfCoord*3.
decodedCoordIndex: A reconstructed coordIndex whose size is 1 by numberOfCoordIndex*3.
decodedNormal: A reconstructed normal whose size is 1 by numberOfNormal*3.
© ISO/IEC 2010 – All rights reserved 9

ISO/IEC 14496-16:2009/FDAM 1:2010(E)
decodedNomalindex: A reconstructed noramlIndex whose size is 1 by numberOfNormalIndex*3.
decodedTexCoord: A reconstructed texcoord whose size is 1 by numberOfTexCoord*2.
decodedTexCoordIndex: A reconstructed texcoordIndex whose size is 1 by numberOfTexCoordIndex*3.
decodedColor: A reconstructed color whose size is 1 by numberOfColor*3.
decodedColorIndex: A reconstructed colorIndex whose size is 1 by numberOfColorIndex*3.
decodedOtherAttributes: A reconstructed otherAttributes whose size is 1 by
dimensionOfOtherAttributes*OfOtherAttributes.
decodedOtherAttributesIndex: A reconstructed otherAttributesIndex whose size is 1 by
numberOfColorIndex*3.
tQP: 3 integer array containing data for quantization containing QP, width, and height values
DecodefloatArray: A decoding function for geometry, color, normal, and texture coordinate.
DecodeIntArray: A decoding function of Index depending on SC3DMC prediction mode for geometry, color,
normal, and texture coordinate.
SVAIndexDecoder: A decoding function of index data using SVA algorithm.
TFANIndexDecoder: A decoding function of index data using TFAN algorithm.
4.2.5.2.4 DecodeFloatArray Class
4.2.5.2.4.1 Syntax
DecodefloatArray(numberOfDatal, dim, quantMin, quantRange, quantizationMode, tQP)
{
DecodeIntArray ((1< InverseQauntization(quatizationMode, tQP, quantMin, quantRange)
}
4.2.5.2.4.2 Semantics
InverQuantization: A decoding process of inverse quantization depending on the quantization mode as
follows:
Table AMD1.3 — Quantization modes
Quantization Mode Quantization method
0 result = quantMin + (1< nbins = 1 << ((normal_quant - 3) / 2);
y0 = nbins - ceil(sqrt(nbins*nbins - i));
x0 = i + y0*y0;
skew = (x0 & 1)*2.0/3.0;
x0 = (x0 >> 1) & (nbins - 1);
1 x = (float)x0 + skew;
y = (float)y0 + skew;
z = (float)nbins - x - y;
n = 1.0/sqrt(x*x + y*y + z*z);
x = (sx) ? -x*n : x*n;
y = (sy) ? -y*n : y*n;
z = (sz) ? -z*n : z*n;
x = texture_image_width *input
y = texture_image_height *input
10 © ISO/IEC 2010 – All rights reserved

ISO/IEC 14496-16:2009/FDAM 1:2010(E)
4.2.5.2.5 DecodeFloatArray Class
4.2.5.2.5.1 Syntax
DecodefloatArray(numberOfData, dim, quantMin, quantRange, quantizationMode, tQP)
{
InverseBinarizeIntArray(numberOfdata, dim, binarizationMode);
InversePredictIntArray(numberOfdata, dim, predictionMode, sizeOfData);
}
4.2.5.2.5.2 Sementics
InverseBinarizeIntArray: decoding process of inverse binarization depending on binarization mode
InversePredictIntArray: decoding process of inverse prediction depending on prediction mode
4.2.5.2.6 SC3DMCDataDecoder class
4.2.5.2.6.1 Syntax
InverseBinarizeIntArray (numberOfdata, dim)
{
Bit(4) predictionMode;
Bit(4) BinarizationMode;  -
If ((binarizationMode == 0) && (predictionMode == 0)) // FL
{
Bit(8) QP;
for(i=0;i< numberOfdata *dim;i++)
{
bit (QP) nData; // simple QBCR
}
}
else if (binarizationMode == 1) // BPC
{
If(prediction = 1)
If (predictionMode==3)    bit(1-7) predictor
bit (5) prefixSize
for(i=0;i< numberOfdata *dim;i++)
{
BPDecoder(prefix_size) nDifData
If (predictionMode==1 || predictionMode==4)    bit(1) nSign
}
}
else if (binarizationMode == 2) // 4C
{
for(i=0;i< numberOfdata *dim;i++)
{
If (predictionMode==3)
{
bit(3) predictor;
bit (1) terminationBit
while (terminationBit)
{
bit(3) threeBitsFL;
bit(1) terminationBit;
}
}
else
{
© ISO/IEC 2010 – All rights reserved 11

ISO/IEC 14496-16:2009/FDAM 1:2010(E)
do
{
bit(3) threeBitsFL;
bit(1) terminationBit;
}
while (terminationBit)
}
}
}
else if (binarizationMode == 3) // AC
{
unsinged int (32) streamSizeAC;
for(i=0;i< numberOfdata *dim;i++)
{
If (predictionMode==3)    ACDecoder(8) predictor

ACDecoder(1< ACDecoder(2) hasnext
If (predictionMode==1 || predictionMode==4)    ACDecoder(1) nSign

}
}
else if (binarizationMode == 4) // AC/EGk
{
unsinged int (32) streamSizeAC;
unsinged int (8) K
unsinged int (8) M
for(i=0;i< numberOfdata *dim;i++)
{
If (predictionMode==3)    ACDecoder(8) predictor

ACDecoder(M+1) nDifData
if (nDifData == M+1) ACExpGolombDecode(K) nDifDataEGk;
}
}
}
4.2.5.2.6.2 Semantics
A detailed description of the QBCR decoding process is presented in 4.2.5.2.18.1. The QBCR encoding
process is described in Annex N.
QP: A 8-bit unsigned integer indicating the number of bits used for the FL(fixed length) binarization.
coordPredictionMode: A 4-bit unsigned integer indicating the prediction strategy to be applied to the
decoded residual values associated to the coordinates.
12 © ISO/IEC 2010 – All rights reserved

ISO/IEC 14496-16:2009/FDAM 1:2010(E)
Table AMD1.4 — SC3DMC prediction modes.
PredictionMode Prediction mode
0 Default(No prediction)
Differential prediction: predicted value is
just before the current value
2 XOR prediction
3 Adaptive linear prediction: a different
predictor is defined for each
encoded value.
4 Circular Differential prediction :
Differential prediction using circular
method
5 TFAN-based Parallelogram prediction:
the predicted value associated to the
current vertex is obtained by applying the
parallelogram prediction rule while
considering only the neighbors in a
triangle fan.
6-15 Reserved for ISO purposes

binarizationMode: 4-bit integer indicating the binarization mode as illustrated in Table AMD1.5
Table AMD1.5 — Binarization mode
binarizationMode Function
0 Default(Fixed Length Binarization)
1 Bit Precision Coding (BPC)
2 4-bits-based Coding (4C)
3 Arithmetic Coding (AC)
Mixed Arithmetic Coding and Exponential
Golomb Code
5~15 ISO reserved
nData: An unsigned integer value which corresponds to an index or a quantized value.
predictor: A 3-bit value indicating the predictor to be applied. It is defined only for prediction modes 3 and 4
(cf. Table AMD1.4). The predictors defined for the prediction mode 3 are detailed in Table AMD1.6.

© ISO/IEC 2010 – All rights reserved 13

ISO/IEC 14496-16:2009/FDAM 1:2010(E)
Table AMD1.6— Adaptive predictors: all possible configurations
(P[i] represents the predictor associated with the i-th value T[i] to be decoded).
predictor Value Applied rule
0 No prediction
d=1…7 Delta prediction: P[i] = T[i-d*dim]

The value of dim depends on the type of data as illustrated in Table AMD1.7
Table AMD1.7 — Value of variable dim with respect to type of the data
Data Type Value of dim
coord 3
normal 3
texCoord 2
color 3
otherAttributes dimOfOtherAttributes
coordIndex 1
normalIndex 1
texCoordIndex 1
colorIndex 1
otherAttributesIndex 1
prefixSize: 5-bit data indicating the bit size read for the BPC Decoder
nDifData: An unsigned integer obtained by BCP or 4C or AC decoding.
streamSizeAC: A 32-bit unsigned integer indicating how many byte is used for AC.
M: A 8-bit unsigned integer describing the interval of values described by the arithmetic encoded
representation. More specifically, if a decoded value ranges in the interval [0, M] it is decoded only with the
arithmetic decoder. Otherwise, an additional part is decoded with an Exponential Golomb code representation.
K: A 8-bit unsigned integer describing the order of the Exponential Golomb code representation.
nDifDataEGk: Unsigned integer describing the EGk part of the AC/EGk code.
NOTE For the AC/EGk binarization mode (binarizationMode = 4), the residual error value is obtained by
adding the quantities nDifData and nDifDataEGk.
14 © ISO/IEC 2010 – All rights reserved

ISO/IEC 14496-16:2009/FDAM 1:2010(E)
The TFAN-based Parallelogram prediction mode: (i.e. PredictionMode equals 5) is defined only for the
TFAN mode (i.e. encodingMode equals 2). It can be applied only to the geometry/attributes information. Here,
the inverse prediction stage exploits the already decoded connectivity information (cf. Annex Q). Several
situations are distinguished in the following.
For vertices coordinates, the coordIndex connectivity is used.
a. For texture coordinates, if the texCoordIndex connectivity is not empty then it is used, otherwise the
coordIndex connectivity is considered.
b. For colors or normals or other attributes, distinguished two cases are as follows:
- Colors/normals/other attributes are defined per vertex: if the
colorIndex/normalIndex/otherAttributesIndex connectivity is not empty then it is used,
otherwise the coordIndex connectivity is considered.
- Colors/normals/other attributes are defined per triangle: only the prediction mode 1 is
possible. There is no need to connectivity information to decode the geometry.
4.2.5.2.7 ExpGolombDecode class
4.2.5.2.7.1 Syntax
Class ExpGolombDecode (K)
{
do
{
Bit(1) b=AC.decode(bModel);
if (b==1)
{
K++;
}
}
while (b!=0);
while (K--)
{
Bit(1) b=AC.decode(bModel);
}
}
4.2.5.2.7.2 Semantics
b: A 1-bit decoded using the AC with the static binary probability model bModel. Here, the probabilities are set
to 0.5 to both symbols 0 and 1.
NOTE Refer to Annex T for more details on the EGk decoding process.
4.2.5.2.8 BPDecoding(prefix_size) class
4.2.5.2.8.1 Syntax
Class BPDecoder(prefixSize)
{
bit(prefix_size) prefixVal;
if (prefix_val>2){
bit(prefix_val-1) nPayload;
}
}
© ISO/IEC 2010 – All rights reserved 15

ISO/IEC 14496-16:2009/FDAM 1:2010(E)
4.2.5.2.8.2 Semantics
prefixVal: A prefix value indicating the bit length used for BP decoding.
nPayload: The value of using for BP decoding and the result is computed as follows:
decoded value = BPLTable[prefixVal]+nPayload , where BPLTable is initialized in the creation phase
4.2.5.2.9 SVAIndexDecoder class
4.2.5.2.9.1 Syntax
SVAIndexDecoder (numberOfIndex, numberOfData)
{
if(entropytype == 1) // BPC case
{
bit (1) FDMode;
if(FDMode == 0)
bit (1) FDValue;
bit(5) prefixSize;
for (i=0;i<3;i++){ // first face.
BPDecoder(prefix_size) nData;
}
If (FDMode == 0){
for (i=1;i bit(1-5) nType
switch(nType){
case 0:  // mode 0
bit(1-2) nPosition;
bit(1) nSign;
BPDecoder(prefix_size) nDifIndex;
bit(1) nSign;
bit(1-2) nRotation;
break;
case 1:  //mode 1
for (j=0;j<3;j++){
BPDecoder(prefix_size) nDifIndex;
bit(1) nSign;
}
break;
case 2:  //mode 2
bit(1-5) nPosition;
for(j = 0; j< 2; j++){
BPDecoder(prefix_size) nDifIndex;
bit(1) nSign;
}
bit(1-2) nRotation;
break;
case 3:  //mode 3
for (j=0;j<3;j++){
BPDecoder(prefix_size) nDifIndex;
bit(1) nSign;
}
break;
case 4:  //mode 4
bit(1) nSign;
bit(1-2) nRotation;
break;
}
16 © ISO/IEC 2010 – All rights reserved

ISO/IEC 14496-16:2009/FDAM 1:2010(E)
}
} else{ // FDMode == 1
for (i=1;i bit(1-5) nType
switch(nType){
case 0:  // mode 0
bit(1-2) nPosition;
BPDecoder(prefix_size) nDifIndex;
bit(1) nSign;
bit(1-2) nRotation;
break;
case 1:  //mode 1
for (j=0;j<3;j++){
BPDecoder(prefix_size) nDifIndex;
bit(1) nSign;
}
break;
case 2:  //mode 2
bit(1-5) nPosition;
for(j = 0; j< 2; j++){
BPDecoder(prefix_size) nDifIndex;
bit(1) nSign;
}
bit(1-2) nRotation;
break;
case 3:  //mode 3
for (j=0;j<3;j++){
BPDecoder(prefix_size) nDifIndex;
bit(1) nSign;
}
break;
case 4:  //mode 4
bit(1-2) nRotation;
break;
}
}
}
}
else if (entropytype == 2) // AC case.
{
unsinged int code (32)_bytes;
Adaptive_Data_Model mModel(1024);
Adaptive_Data_Model mhasnext (2);
Adaptive_Data_Model mSign (2);
Adaptive_Data_Model mType (5);
Adaptive_Data_Model mFD (2);
Adaptive_Data_Model mPos (3);
Adaptive_Data_Model mRotate (3);
Arithmetic_Codec acd(code_bytes, code_buffer);
acd.start_decoder();
for (i=1;i ACDecoder(mType) nType
switch(nType){
case 0:  // mode 0
ACDecoder(mPos) nPosition;
ACDecoder(mFD) faceDirection;
ACDecoder(mModel, mhasnext) nDifIndex;
ACDecoder(mSign) nSign;
ACDecoder(mRotaion) nRotation;
break;
© ISO/IEC 2010 – All rights reserved 17

ISO/IEC 14496-16:2009/FDAM 1:2010(E)
case 1:  //mode 1
for (j=0;j<3;j++){
ACDecoder(mModel, mhasnext) nDifIndex;
ACDecoder(mSign) nSign;
}
break;
case 2:  //mode 2
ACDecoder(mPos) nPosition;
for(j = 0; j< 2; j++){
ACDecoder(mModel, mhasnext) nDifIndex;
ACDecoder(mSign) nSign;
}
ACDecoder(mRotaion) nRotation;
break;
case 3:  //mode 3
for (j=0;j<3;j++){
ACDecoder(mModel, mhasnext) nDifIndex;
ACDecoder(mSign) nSign;
}
break;
case 4:  //mode 4
ACDecoder(mFD) faceDirection;
ACDecoder(mRotaion) nRotation;
break;
}
}
}
}
4.2.5.2.9.2 Semantics
nType: Current face type for vertex index analysis as illustrated in Table AMD1.8.
Table AMD1.8 — Type and representation
Type Representation
0 1
1 01
2 001
3 0001
4 00001
nPosition: Position information for vertex index analysis as illustrated in Table AMD1.9
Table AMD1.9— Position and representation
nPosition Representation
0 0
1 10
2 11
18 © ISO/IEC 2010 – All rights reserved

ISO/IEC 14496-16:2009/FDAM 1:2010(E)
nDifCoordIndex: CoordIndex difference between current and previous face
nRotation: Rotation information saying that how many rotation needed
Table AMD1.10 — Rotation and representation
nRotation Representation
0 0
1 10
2 11
FaceDirection: Face direction information. If this is 1, invert the decoded current face
4.2.5.2.10 SVANormalDecoder class
4.2.5.2.10.1 Syntax
SVANormalDecoder()
{
if(entropytype == 1) // BPC
{
unsigned int (5) prefix
if(codingtype == 1) // Differential coding
{
for(i = 0; i < numberOfNormal; i++)
{
unsigned int (1-7) codeForNormalO;
bit (1) nSign;
BPDecoder (prefix) codeForNormalS;
bit (1) nSign
}
}
else if (codingtype == 2) //XOR
{
for(i = 0; i < numberOfNormal; i++)
{
unsigned int (1-7) codeForNormalO;
BpDecoder (prefix) codeForNormalS;
}
}
}
else if(entropy == 1)//AC
{
if(codingtype == 1) // Differential coding
{
for(i = 0; i < numberOfNormal; i++)
{
unsigned int (1-7) codeForNormalO;
bit (1) nSign;
ACDecoder (prefix) codeForNormalS;
bit (1) nSign
}
}
else if (codingtype == 2) //XOR
© ISO/IEC 2010 – All rights reserved 19

ISO/IEC 14496-16:2009/FDAM 1:2010(E)
{
for(i = 0; i < numberOfNormal; i++)
{
unsigned int (1-7) codeForNormalO;
ACDecoder (prefix) codeForNormalS;
}
}
}
}
4.2.5.2.10.2 Semantics
codeForNormalO: A quantized data to indicate a subdivision part of quantized data
Table AMD1.11 — CodeForNomal and representation
CodeForNormal representation CodeForNormal representation
0 1 4 00001
1 01 5 000001
2 001 6 0000001
3 0001 7 00000001
codeForNormalS: 2*subdivision-data bits integer data to indicate a subdivision part of quantized data
subdivision = (QPforNormal << 3) /2;
4.2.5.2.11 TFANIndexDecoder class
4.2.5.2.11.1 Syntax
class TFANIndexDecoder(dim, nV, nT, preserveTrianglesOrder, preservePermutations) {
TFANIndexDecoderNTFans(nV) nTFans;
TFANIndexDecoderDegrees degrees;
TFANIndexDecoderCases cases;
TFANIndexDecoderVerticesIndices verticesIndices;
TFANIndexDecoderOps ops;
if (vertexOrderPres == 1) SC3DMCDataDecoder(nV, 1) vo;
if (preserveTrianglesOrder == 1) SC3DMCDataDecoder(nT, 1) fo;
if (preservePermutations == 1) SC3DMCDataDecoder(nT, 1)  permutations;
}
4.2.5.2.11.2 Semantics
dim: Parameter indicating the dimension of the connectivity array to be decoded (should be either 1 or 3).
nV: Parameter indicating the number of vertices for the connectivity array to be decoded.
nT: Parameter indicating the number of triangles for the connectivity array to be decoded.
20 © ISO/IEC 2010 – All rights reserved

ISO/IEC 14496-16:2009/FDAM 1:2010(E)
nTFans: Bitstream of type TFANIndexDecoderNTFans describing for each vertex the number of triangle fans
incident to it.
degrees: Bitstream of type TFANIndexDecoderDegrees describing for each triangle fan the number of its
triangles.
cases: Bitstream of type TFANIndexDecoderCases describing for each triangle fan its topological
configuration. Refer to Annex P for a description of the TFAN encoding process and a detailed specification of
the 10 topological configurations (or cases) considered by the TFAN codec.
verticesIndices: Bitstream of type TFANIndexDecoderVerticesIndices describing for each triangle fan the
indices of the vertices composing it. Refer to Annex P for a description of the TFAN encoding process.
ops: Bitstream of type TFANIndexDecoderOps describing, for each vertex of a triangle fan, if it is a new one
(i.e., it should be created by the decoder) or an old one (i.e., it has already been created). Refer to Annex P
for a description of the TFAN encoding process.
vo: Bitstream of type TFANIntArrayDecoder describing for each vertex its original order (i.e., position in the
original IFS).
fo: Bitstream of type TFANIntArrayDecoder describing for each triangle its original order (i.e., position in the
original IFS calling face order).
permutations: Bitstream of type TFANPermutationDecoder describing for each triangle the permutation to be
applied to its vertices to obtain the original order. For instance, if the original triangle was (8, 19, 12) and the
decoded one is (12, 8, 19) the value decoded should be 1. In the general case, if the decoded triangle is (a(0),
a(1), a(2)) and the decoded permutation is p (0 ≤ p ≤ 2), then the original triangle was (a((0 - p + 3) % 3),
((1 - p + 3) % 3), ((2 - p + 3) % 3)).
4.2.5.2.12 TFANIndexDecoderNTFans class
4.2.5.2.12.1 Syntax
class TFANIndexDecoderNTFans(nV) {
unsigned char(8) maxNTFans;
unsigned int(32) streamSize;
for (int v = 0; v < nV; v++) {
nbrTFans[v] = aithmetic_decoder.decode();
}
}
4.2.5.2.12.2 Semantics
nV: Parameter indicating the number of vertices for the connectivity array to be decoded.
maxNTFans: A 8-bit unsigned integer indicating the maximal number of triangle fans per vertex. This value is
exploited to initialize the statistics model of the arithmetic encoding.
streamSize: A 32-bit unsigned integer describing the size in bytes of the arithmetic encoded stream for the
numbers of triangles fans.
nbrTFans: An array of integers of dimension nV indicating for each vertex the number of triangle fans incident
to it.
© ISO/IEC 2010 – All rights reserved 21

ISO/IEC 14496-16:2009/FDAM 1:2010(E)
4.2.5.2.13 TFANIndexDecoderDegrees class
4.2.5.2.13.1 Syntax
class TFANIndexDecoderDegrees{
unsigned int (32) nDegrees;
unsigned int (32) maxDegree;
unsigned int (32) streamSize;
for (int v = 0; v < nDegrees; v++) {
degrees[v] = arithmetic_encoder.decode();
}
}
4.2.5.2.13.2 Semantics
nDegrees: A 32-bit unsigned integer describing the number of degrees to be decoded.
maxNTFans: A 8-bit unsigned integer indicating the maximal number of triangle fans per vertex. This value is
exploited to initialize the statistics model of the arithmetic decoder.
streamSize: A 32-bit unsigned integer describing the size in bytes of the arithmetic encoded stream for the
degrees.
degrees: An array of integers of dimension nDegrees indicating the dimension of each triangle fan.
4.2.5.2.14 TFANIndexDecoderCases class
4.2.5.2.14.1 Syntax
class TFANIndexDecoderCases {
unsigned int (32) streamSize;
for (int v = 0; v < nDegrees; v++) {
cases[v] = arithmetic_decoder.Decode();
}
}
4.2.5.2.14.2 Semantics
streamSize: A 32-bit unsigned integer describing the size in bytes of the arithmetic encoder stream for the
TFAN topological configurations.
cases: An array of integers of dimension nDegrees indicating for each triangle fan its topological
configuration.
NOTE nDegrees is recovered when decoding the TFANIndexDecoderDegrees.
4.2.5.2.15 TFANIndexDecoderVerticesIndices class
4.2.5.2.15.1 Syntax
class TFANIndexDecoderVerticesIndices {
unsigned int (32) nVerticesIndices;
SC3DMCDataDecoder(nVerticesIndices, 1) decodedVerticesIndices;
}
22 © ISO/IEC 2010 – All rights reserved

ISO/IEC 14496-16:2009/FDAM 1:2010(E)
4.2.5.2.15.2 Semantics
nVerticesIndices: A 32-bit unsigned integer describing the number of vertices indices to be decoded.
decodedVerticesIndices: Array of integer of dimension nVerticesIndices describing the vertices indices.
4.2.5.2.16 TFANIndexDecoderOps class
4.2.5.2.16.1 Syntax
class TFANIndexDecoderOps {
unsigned int (32) nOps;
if (nOps > 0) {
unsigned int (32) streamSize;
for (int v = 0; v < nOps; v++) {
ops[v] = arithmetic_decoder.Decode();
}
}
}
4.2.5.2.16.2 Semantics
nOps: A 32-bit unsigned integer describing the number of operation values to be decoded.
streamSize: A 32-bit unsigned integer describing the size in bytes of the arithmetic encoded stream for the
operation stream.
ops: An array of bits of dimension nOps indicating for each vertex of a triangle fan if it should be created by
the decoder or not.
4.2.5.2.17 TFANPermutationDecoder class
4.2.5.2.17.1 Syntax
class TFANPermutationDecoder(nT) {
unsigned int (32) streamSize;
for (int t = 0; t < nT; v++) {
perm[t] = arithmetic_encoder.decode();
}
}
4.2.5.2.17.2 Semantics
streamSize: A 32-bit unsigned integer describing the size in bytes of the arithmetic encoded stream for the
permutations.
perm: An array of integer of dimension nT indicating for each triangle the permutation to applied to its vertices
to obtain the original order.
4.2.5.2.18 Decoding process
This clause specifies the decoding process that the decoder shall perform to recover 3D mesh data from the
encoded bitstream. As shown in Figure AMD1.2, the decoding process includes a switch which indicates the
algorithm used in the encoding process. After bitstream decoding, it is sent to the compositor to reconstruct
3D mesh data. In this document, only triangular meshes are considered.
© ISO/IEC 2010 – All rights reserved 23

ISO/IEC 14496-16:2009/FDAM 1:2010(E)

Figure AMD1.2 — SC3DMC Decoder structure
4.2.5.2.18.1 QBCR Decoding
The QBCR decoder handles the geometry and properties (i.e. coordinate, color, normals, texture coordinate,
and otherAttributes) and their associated indices (i.e. coordIndex, colorIndex , normalIndex, texture
coordIndex, and otherAttributesIndex) in a unified manner. The only difference consists in applying to the
geometry and attributes an additional inverse quantization procedure.
Let T be either the index array or the quantized geometry and properties array to be decoded. Let N be the
number of elements of T and dim their dimension. Figure AMD1.3 illustrates an example of an array of
quantized position coordinates. Let us note that all the elements of T are non-negative integers.

Figure AMD1.3 — Example of a flat representation of an array of quantized position coordinates.
If no prediction was applied (i.e. prediction mode 0) the decoder retrieves the array T by directly interpreting
the FL representation of each element.
For the prediction modes 1, 2 and 4, the decoder retrieves first the prediction residual errors E[i] by
interpreting associated binary representation. The decoded residuals E[i] are non-negative integers. They are
remapped to signed integers e[i] by applying the f
...