Advance Professional Video

3.2.1. Arithmetic operators

• // : an integer division with rounding of the result toward zero. For example, 7/4 and -7/-4 are rounded to 1 and -7/4 and 7/-4 are rounded to -1¶

• % : a modulus. x % y is a remainder of x divided by y¶

• min(x,y): the minimum value of the values x and y¶

• max(x,y): the maximum value of the values x and y¶

• ceil(x): the smallest integer value that is larger than or equal to x¶

• clip(x,y,z): clip(x,y,z)=max(x,min(z,y))¶

• sum (i=x, y, f(i)) : a summation of f(i) with i taking all integer values from x up to and including y¶

3.2.2. Bitwise operators

• & (bit-wise "and"): When operating on integer arguments, operates on a two's complement representation of the integer value. When operating on arguments with unequal bitdepts, the bitdepts are equliazed by adding zeros in significant positions to the argument with lower bitdepth.¶

• | (bit-wise "or"): When operating on integer arguments, operates on a two's complement representation of the integer value. When operating on arguments with unequal bitdepts, the bitdepts are equliazed by adding zeros in significant positions to the argument with lower bitdepth.¶

• x >> y: arithmetic right shift of a two's complement integer representation of x by y binary digits. This function is defined only for non-negative integer values of y. Bits shifted into the most significant bits (MSBs) as a result of the right shift have a value equal to the MSB of x prior to the shift operation.¶

• x << y: arithmetic left shift of a two's complement integer representation of x by y binary digits. This function is defined only for non-negative integer values of y. Bits shifted into the least significant bits (LSBs) as a result of the left shift have a value equal to 0.¶

3.3.1. Order of operations precedence

When order of precedence is not indicated explicitly by use of parentheses, operations are evaluated in the following order¶

• Operations of a higher precedence are evaluated before any operation of a lower precedence. Table 1 specifies the precedence of operations from highest to lowest; operations closer to the top of the table indicates a higher precedence.¶

• Operations of the same precedence are evaluated sequentially from left to right.¶

4.3.1. Partitioning of a frame into tiles

This section specifies how a frame is partitioned into tiles.¶

A frame is divided into tiles. A tile is a group of MBs that cover a rectangular region of a frame and is processed independently of other tiles. Every tile has the same width and height, except possibly tiles at the right or bottom frame boundary when the frame width or height is not a multiple of the tile width or height, respectively. The tiles in a frame are scanned in raster order. Within a tile, the MBs are scanned in raster order. Each MB is comprised of one (MbWidth) x (MbHeight) luma array and two corresponding chroma sample arrays.¶

For example, a frame may be divided into 6 tiles (3 tile columns and 2 tile rows) as shown in Figure 3: Frame with 10 by 8 MBs that is partitioned into 6 tiles. In this example, the tile size is defined as 4 column MBs and 4 row MBs. In case of the third and sixth tiles (in raster order), the tile size is 2 column MBs and 4 row MBs since the frame width is not multiple of the tile width.¶

     +===================+===================+=========+
     #    |    |    |    # MB | MB | MB | MB # MB | MB #
     +-------------------+-------------------+---------+
     #    |    |    |    # MB | MB | MB | MB # MB | MB #
     +-----   tile  -----+-------------------+---------+
     #    |    |    |    # MB | MB | MB | MB # MB | MB #
     +-------------------+-------------------+---------+
     #    |    |    |    # MB | MB | MB | MB # MB | MB #
     +===================+===================+=========+
     # MB | MB | MB | MB # MB | MB | MB | MB # MB | MB #
     +-------------------+-------------------+---------+
     # MB | MB | MB | MB # MB | MB | MB | MB # MB | MB #
     +-------------------+-------------------+---------+
     # MB | MB | MB | MB # MB | MB | MB | MB # MB | MB #
     +-------------------+-------------------+---------+
     # MB | MB | MB | MB # MB | MB | MB | MB # MB | MB #
     +===================+===================+=========+

                 #,=  tile boundary

                 |,-  MB boundary

4.3.2. Spatial or component-wise partitioning

The following divisions of processing elements form spatial or component-wise partitioning:¶

• the division of each frame into components;¶

• the division of each frame into tile columns;¶

• the division of each frame into tile rows;¶

• the division of each tile column into tiles;¶

• the division of each tile row into tiles;¶

• the division of each tile into color components;¶

• the division of each tile into MBs;¶

• the division of each MB into blocks.¶

4.4.1. Zig-zag scan

Inputs to this process are:¶

• a variable blkWidth specifying the width of a block, and¶

• a variable blkHeight specifying the height of a block.¶

Output of this process is the array zigZagScan[sPos].¶

The array index sPos specifies the scan position ranging from 0 to (blkWidth * blkHeight)-1. Depending on the value of blkWidth and blkHeight, the array zigZagScan is derived as follows:¶

pos=0
zigZagScan[pos]=0
pos++
for(line=1;line<(blkWidth+blkHeight-1);line++){
  if(line%2){
    x=min(line,blkWidth-1)
    y=max(0,line-(blkWidth-1))
    while(x>=0&&y<blkHeight){
      zigZagScan[pos]=y*blkWidth+x
      pos++
      x--
      y++
    }
  }
  else{
    y=min(line,blkHeight-1)
    x=max(0,line-(blkHeight-1))
    while(y>=0&&x<blkWidth){
      zigZagScan[pos]=y*blkWidth+x
      pos++
      x++
      y--
    }
  }
}

4.4.2. Inverse scan

Inputs to this process are:¶

• a variable blkWidth specifying the width of a block, and¶

• a variable blkHeight specifying the height of a block.¶

Output of this process is the array inverseScan[rPos].¶

The array index rPos specifies the raster scan position ranging from 0 to (blkWidth * blkHeight)-1. Depending on the value of blkWidth and blkHeight, the array inverseScan is derived as follows:¶

• The variable forwardScan is derived by invoking zig-zag scan order 1D array initialization process as specified in Section 4.4.1 with input parameters blkWidth and blkHeight.¶

• The output variable inverseScan is derived as follows:¶

for(pos=0;pos<blkWidth*blkHeight;pos++){
  inverseScan[forwardScan[pos]]=pos
}

5.2.1. byte_aligned()

• If the current position in the bitstream is on a byte boundary, i.e., the next bit in the bitstream is the first bit in a byte, the return value of byte_aligned() is equal to TRUE.¶

• Otherwise, the return value of byte_aligned() is equal to FALSE.¶

5.2.2. more_data_in_tile()

• If the current position in the tileIdx-th tile() syntax structure is less than TileSize[ tileIdx ] in bytes from the beginning of the tile_header() syntax structure of the tileIdx-th tile, the return value of more_data_in_tile() is equal to TURE.¶

• Otherwise, the return value of more_data_in_tile() is equal to FALSE.¶

5.2.3. next_bits(n)

This function provides the next bits in the bitstream for comparison purposes, without advancing the bitstream pointer. Provides a lookat the next n bits in the bitstream with n being its argument.¶

5.2.4. read_bits(n)

This function indicate to read the next n bits from the bitstreamand advances the bitstream pointer by n bit positions. When n isequal to 0, read_bits(n) is specified to return a value equal to 0and to not advance the bitstream pointer.¶

5.2.5. Syntax element processing functions

• b(8): byte having any pattern of bit string (8 bits). The parsing process for this descriptor is specified by the return value of the function read_bits(8).¶

• f(n): fixed-pattern bit string using n bits written (from left to right) with the left bit first. The parsing process for this descriptor is specified by the return value of the function read_bits(n).¶

• u(n): unsigned integer using n bits. The parsing process for this descriptor is specified by the return value of the function read_bits(n) interpreted as a binary representation of an unsigned integer with most significant bit written first.¶

• h(v): variable-length entropy coded syntax element with the left bit first. The parsing process for this descriptor is specified in Section 7.1.¶

5.3.1. Frame Data

syntax code                                             | type
--------------------------------------------------------|--------
frame_data(){                                           |
    frame_header()                                      |
    for(tileIdx=0;tileIdx<NumTiles;tileIdx++){          |
        tile_size_minus1[tileIdx]                       | u(32)
        tile(tileIdx)                                   |
    }                                                   |
    metadata()                                          |
    filler_data()                                       |
}                                                       |

• tile_size_minus1[tileIdx]¶

• plus 1 indicates the size in bytes of tileIdx-th tile data (i.e., tile(tileIdx)) in raster order in a frame.¶

• The variable TileSize[ tileIdx ] is set equal to tile_size_minus1[ tildIdx ] + 1¶

5.3.2. Frame header syntax

syntax code                                        | type
---------------------------------------------------|-------
frame_header(){                                    |
  frame_header_size                                | u(16)
  profile_idc                                      | u(8)
  level_idc                                        | u(8)
  reserved_zero_8bits                              | u(8)
  frame_width_minus1                               | u(32)
  frame_height_minus1                              | u(32)
  chroma_format_idc                                | u(4)
  bit_depth_minus8                                 | u(4)
  capture_time_distance                            | u(8)
  reserved_zero_16bits                             | u(16)
  color_description_present_flag                   | u(1)
  if(color_description_present_flag){              |
    color_primaries                                | u(8)
    transfer_characteristics                       | u(8)
    matrix_coefficients                            | u(8)
  }                                                |
  use_q_matrix                                     | u(1)
  if(use_q_matrix){                                |
    quantization_matrix()                          |
  }                                                |
  tile_info()                                      |
  reserved_zero_8bits                              | u(8)
  byte_alignment()                                 |
}                                                  |

• frame_header_size¶

• indicates the size of the frame header in bytes.¶

• profile_idc¶

• indicates a profile to which the Frame Data stream conforms to as specified in Section 10.1. Bitstreams shall not contain values of profiles_idc other than those specified in Appendix A. Other values of profile_idc are reserved for future use.¶

• level_idc¶

• indicates a level to which the Frame Data stream conforms to as specified in Appendix A. Bitstreams shall not contain values of level_idc other than those specified in Section 10.1. Other values of level_idc are reserved for future use.¶

• reserved_zero_8bits¶

• shall be equal to 0 in bitstreams conforming to this version of document. Values of reserved_zero_8bits greater than 0 are reserved for future use. Decoders conforming to a profile specified in Section 10.1. MUST ignore Frame Data with values of reserved_zero_8bits greater than 0.¶

• frame_width_minus1¶

• plus 1 specifies the width of frame in units of luma samples. frame_width_minus1 plus 1 MUST be as multiple of 2 when chroma_format_idc has a value of 2.¶

• frame_height_minus1¶

• plus 1 specifies the height of frame in units of luma samples.¶

• The variables FrameWidthInMbsY, FrameHeightInMbsY, FrameWidthInSamplesY, FrameHeightInSamplesY, FrameWidthInSamplesC, FrameHeightInSamplesC, FrameSizeInMbsY, and FrameSizeInSamplesY are derived as follows:¶

• • FrameWidthInSamplesY = frame_width_minus1 + 1¶

  • FrameHeightInSamplesY = frame_height_minus1 + 1¶

  • FrameWidthInMbsY = ceil(FrameWidthInSamplesY / MbWidth)¶

  • FrameHeightInMbsY = ceil(FrameHeightInSamplesY / MbHeight)¶

  • FrameWidthInSamplesC = FrameWidthInSamplesY // SubWidthC¶

  • FrameHeightInSamplesC = FrameHeightInSamplesY // SubHeightC¶

  • FrameSizeInMbsY = FrameWidthInMbsY * FrameHeightInMbsY¶

  • FrameSizeInSamplesY = FrameWidthInSamplesY * FrameHeightInSamplesY¶

• chroma_format_idc¶

• specifies the chroma sampling relative to the luma sampling as specified in Table 2 The value of chroma_format_idc MUST be in the range of 2 to 3, inclusive. Other values of chroma_format_idc are reserved for future use.¶

• bit_depth_minus8¶

• specifies the bit depth of the samples. The variables BitDepth and QpBdOffset are derived as follows:¶

• • • BitDepth = bit_depth_minus8 + 8¶

• • • QpBdOffset = bit_depth_minus8 * 6¶

• bit_depth_minus8¶

• MUST be in the range of 2 to 8, inclusive. Other values of bit_depth_minus8 are reserved for future use.¶

• capture_time_distance¶

• indicates time difference between the capture time of the previous frame and the current frame if there has been any frame preceding this frame.¶

• reserved_zero_16bits¶

• MUST be equal to 0 in bitstreams conforming to this version of document. Values of reserved_zero_16bits greater than 0 are reserved for future use. Decoders conforming to a profile specified in Section 10.1 MUST ignore Frame Data with values of reserved_zero_16bits greater than 0.¶

• color_description_present_flag equal to 1¶

• specifies that color_primaries, transfer_characteristics and matrix_coefficients are present. color_description_present_flag equal to 0 specifies that color_primaries, transfer_characteristics and matrix_coefficients are not present.¶

• color_primaries¶

• MUST have the semantics of ColourPrimaries as specified in [ISO23091-2]. When the color_primaries syntax element is not present, the value of color_primaries is inferred to be equal to 2.¶

• transfer_characteristics¶

• MUST have the semantics of TransferCharacteristics as specified in [ISO23091-2]. When the transfer_characteristics syntax element is not present, the value of transfer_characteristics is inferred to be equal to 2.¶

• matrix_coefficients¶

• MUST have the semnatics of MatrixCoefficients as specified in [ISO23091-2]. When the matrix_coefficients syntax element is not present, the value of matrix_coefficients is inferred to be equal to 2.¶

• use_q_matrix¶

• equal to 1 specifies that the quantization matrices are present. use_q_matrix equal to 0 specifies that the quantization matrices are not present.¶

• reserved_zero_8bits¶

• MUST be equal to 0 in bitstreams conforming to this version of document. Values of reserved_zero_8bits greater than 0 are reserved for future use. Decoders conforming to a profile specified in Section 10.1 MUST ignore Frame Data with values of reserved_zero_8bits greater than 0.¶

5.3.3. Quantization matrix syntax

syntax code                                        | type
---------------------------------------------------|--------
quantization_matrix(){                             |
  for(cIdx=0;cIdx<NumComp;cIdx++){                 |
    for(y=0;y<8;y++){                              |
      for(x=0;x<8;x++){                            |
        q_matrix_minus1[cIdx][x][y]                | u(8)
      }                                            |
    }                                              |
  }                                                |
}                                                  |

• q_matrix_minus1[cIdx][x0][y0]¶

• plus 1 specifies a scaling value in the quantization matrices. When q_matrix_minus1[cIdx][x0][y0] is not present, it is inferred to be equal to 15. The array index cIdx specifies an indicator for the color component; when chroma_format_idc is equal to 2 or 3, 0 for Y, 1 for Cb and 2 for Cr.¶

• The quantization matrix, QMatrix[cIdx][x0][y0], is derived as follows:¶

• QMatrix[cIdx][x0][y0] = q_matrix_minus1[cIdx][x0][y0] + 1¶

5.3.4. Tile info syntax

syntax code                                        | type
---------------------------------------------------|-------
tile_info(){                                       |
  tile_width_in_mbs_minus1                         | u(28)
  tile_height_in_mbs_minus1                        | u(28)
  startMb=0                                        |
  for(i=0;startMb<FrameWidthInMbsY;i++){           |
    ColStarts[i]=startMb*MbWidth                   |
    startMb+=tile_width_in_mbs_minus1+1            |
  }                                                |
  ColStarts[i]=FrameWidthInMbsY*MbWidth            |
  TileCols=i                                       |
  startMb=0                                        |
  for(i=0;startMb<FrameHeightMbsY;i++){            |
    RowStarts[i]=startMb*MbHeight                  |
    startMb+=tile_height_in_mbs_minus1+1           |
  }                                                |
  RowStarts[i]=FrameHeightMbsY*MbHeight            |
  TileRows=i                                       |
  NumTiles=TileCols*TileRows                       |
  tile_size_present_in_fh_flag                     | u(1)
  if(tile_size_present_in_fh_flag){                |
    for(tileIdx=0;tileIdx<NumTiles;tileIdx++){     |
      tile_size_in_fh_minus1[tileIdx]              | u(32)
    }                                              |
  }                                                |
}                                                  |

• tile_width_in_mbs_minus1¶

• plus 1 specifies the width of a tile in units of MBs.¶

• tile_height_in_mbs_minus1¶

• plus 1 specifies the height of a tile in units of MBs.¶

• tile_size_present_in_fh_flag¶

• equal to 1 specifies that tile_size_in_fh_minus1[tileIdx] is present in Frame header. tile_size_present_in_fh_flag equal to 0 specifies that tile_size_in_fh_minus1[tileIdx] is not present in Frame header.¶

• tile_size_in_fh_minus1[tileIdx]¶

• plus 1 indicates the size in bytes of tileIdx-th tile data in raster order in a frame. The value of tile_size_in_fh_minus1[tileIdx] MUST have the same value with tile_size_minus[tileIdx]. When it is not present, the value of tile_size_in_fh_minus1[tileIdx] is inferred to be equal to tile_size_minus1[tileIdx].¶

5.3.5. Metadata syntax

syntax code                                        | type
---------------------------------------------------|-------
metadata(){                                        |
  metadata_size                                    | u(32)
  metadata_payload(metadata_size)                  |
}                                                  |

• metadata_size¶

• specifies the size of metadata in current Frame Data. Syntax and semantics of metadata_payload() is not defined in this document.¶

5.3.6. Filler data syntax

syntax code                                        | type
---------------------------------------------------|-------
filler_data(){                                     |
  while(next_bits(8)==0xFF)                        |
    ff_byte                                        | f(8)
}                                                  |

• ff_byte¶

• is a byte equal to 0xFF.¶

5.3.7. Tile syntax

syntax code                                        | type
---------------------------------------------------|-------
tile(tileIdx){                                     |
  tile_header()                                    |
  for(i=0;i<NumComp;i++){                          |
    tile_data(tileIdx,i)                           |
  }                                                |
  while(more_data_in_tile()){                      |
    tile_dummy_byte                                | b(8)
  }                                                |
}                                                  |

• tile_dummy_byte¶

• has any pattern of 8-bit string.¶

5.3.8. Tile header syntax

syntax code                                        | type
---------------------------------------------------|-------
tile_header(){                                     |
  tile_header_size                                 | u(16)
  tile_index                                       | u(16)
  for(i=0;i<NumComp;i++){                          |
    tile_data_size_minus1[i]                       | u(32)
  }                                                |
  for(i=0;i<NumComp;i++){                          |
    tile_qp[i]                                     | u(8)
  }                                                |
  reserved_zero_8bits                              | u(8)
  byte_alignment()                                 |
}                                                  |

• tile_header_size¶

• indicates the size of the tile header in bytes.¶

• tile_index¶

• specifies the tile index in raster order in a frame. tile_index MUST have the same value with tileIdx.¶

• tile_data_size_minus1[i] plus 1¶

• indicates the size of i-th color component data in a tile in bytes. The array index i specifies an indicator for the color component; when chroma_format_idc is equal to 2 or 3, 0 for Y, 1 for Cb and 2 for Cr¶

• tile_qp[i]¶

• specify the quantization parameter value for i-th color component. The array index i specifies an indicator for the color component; when chroma_format_idc is equal to 2 or 3, 0 for Y, 1 for Cb and 2 for Cr. Qp[i] to be used for the MBs in the tile are derived as follows¶

• • • Qp[i] = tile_qp[i] - QpBdOffset¶

• • • Qp[i] MUST be in the range of -QpBdOffset to 51, inclusive.¶

• reserved_zero_8bits¶

• MUST be equal to 0 in bitstreams conforming to this version of document. Values of reserved_zero_8bits greater than 0 are reserved for future use. Decoders conforming to a profile specified in Section 10.1 MUST ignore Frame Data with values of reserved_zero_8bits greater than 0.¶

5.3.9. Tile data syntax

syntax code                                         | type
----------------------------------------------------|-------
tile_data(tileIdx,cIdx){                            |
  x0=ColStarts[tileIdx%TileCols]                    |
  y0=RowStarts[tileIdx//TileCols]                   |
  numMbColsInTile=(ColStarts[tileIdx%TileCols+1]-   |
            ColStarts[tileIdx%TileCols])//MbWidth   |
  numMbRowsInTile=(RowStarts[tileIdx//TileCols+1]-  |
            RowStarts[tileIdx//TileCols])//MbHeight |
  numMbsInTile=numMbColsInTile*numMbRowsInTile      |
  PrevDC=0                                          |
  PrevDcDiff=20                                     |
  Prev1stAcLevel=0                                  |
  for(i=0;i<numMbsInTile;i++){                      |
    xMb=x0+((i%numMbColsInTile)*MbWidth)            |
    yMb=y0+((i//numMbColsInTile)*MbHeight)          |
    macroblock_layer(xMb,yMb,cIdx)                  |
  }                                                 |
  byte_alignment()                                  |
}                                                   |

5.3.10. Macroblock layer syntax

syntax code                                         | type
----------------------------------------------------|-------
macroblock_layer(xMb,yMb,cIdx){                     |
  subW=(cIdx==0)?1:SubWidthC                        |
  subH=(cIdx==0)?1:SubHeightC                       |
  blkWidth=(cIdx==0)?MbWidth:MbWidthC               |
  blkHeight=(cIdx==0)?MbHeight:MbHeightC            |
  TrSize=8                                          |
  for(y=0;y<blkHeight;y+=TrSize){                   |
    for(x=0;x<blkWidth;x+=TrSize){                  |
      abs_dc_coeff_diff                             | h(v)
      if(abs_dc_coeff_diff)                         |
        sign_dc_coeff_diff                          | u(1)
      TransCoeff[cIdx][xMb//subW+x][yMb//subH+y]=   |
              PrevDC+abs_dc_coeff_diff              |
              *(1-2*sign_dc_coeff_diff)             |
      PrevDC=                                       |
      TransCoeff[cIdx][xMb//subW+x][yMb//subH+y]    |
      PrevDcDiff=abs_dc_coeff_diff                  |
      ac_coeff_coding(xMb//subW+x,yMb//subH+y,      |
            Log2(TrSize),Log2(TrSize),cIdx)         |
    }                                               |
  }                                                 |
 }                                                  |

• abs_dc_coeff_diff¶

• specifies the absolute value of the difference between the current DC transform coefficient level and PrevDC.¶

• sign_dc_coeff_diff¶

• specifies the sign of the difference between the current DC transform coefficient level and PrevDC. sign_dc_coeff_diff equal to 0 specifies that the difference has a positive value. sign_dc_coeff_diff equal to 1 specifies that the difference has a negative value.¶

5.3.11. AC coefficient coding syntax

syntax code                                         | type
----------------------------------------------------|-------
ac_coeff_coding(x0,y0,log2BlkWidth,                 |
log2BlkHeight,cIdx){                                |
  scanPos=1                                         |
  firstAC=1                                         |
  PrevLevel=Prev1stAcLevel                          |
  PrevRun=0                                         |
  do{                                               |
    coeff_zero_run                                  | h(v)
    for(i=0;i<coeff_zero_run;i++){                  |
      blkPos=ScanOrder[scanPos]                     |
      xC=blkPos&((1<<log2BlkWidth)-1)               |
      yC=blkPos>>log2BlkWidth                       |
      TransCoeff[cIdx][x0+xC][y0+yC]=0              |
      scanPos++                                     |
    }                                               |
    PrevRun=coeff_zero_run                          |
    if(scanPos<(1<<(log2BlkWidth+log2BlkHeight))){  |
      abs_ac_coeff_minus1                           | h(v)
      sign_ac_coeff                                 | u(1)
      level=(abs_ac_coeff_minus1+1)                 |
        *(1-2*sign_ac_coeff)                        |
      blkPos=ScanOrder[scanPos]                     |
      xC=blkPos&((1<<log2BlkWidth)-1)               |
      yC=blkPos>>log2BlkWidth                       |
      TransCoeff[cIdx][x0+xC][y0+yC]=level          |
      scanPos++                                     |
      PrevLevel=abs_ac_coeff_minus1+1               |
      if(firstAC==1){                               |
        firstAC=0                                   |
        Prev1stAcLevel=PrevLevel                    |
      }                                             |
    }                                               |
  }while(scanPos<(1<<(log2BlkWidth+log2BlkHeight))) |
}                                                   |

• coeff_zero_run¶

• specifies the number of zero-valued transform coefficient levels that are located before the position of the next non-zero transform coefficient level in a scan of transform coefficient levels.¶

• abs_ac_coeff_minus1¶

• plus 1 specifies the absolute value of an AC transform coefficient level at the given scanning position.¶

• sign_ac_coeff¶

• specifies the sign of an AC transform coefficient level for the given scanning position. sign_ac_coeff equal to 0 specifies that the corresponding AC transform coefficient level has a positive value. sign_ac_coeff equal to 1 specifies that the corresponding AC transform coefficient level has a negative value.¶

5.3.12. Byte alignment syntax

syntax code                                        | type
---------------------------------------------------|-------
byte_alignment(){                                  |
  while(!byte_aligned())                           |
    alignment_bit_equal_to_zero                    | f(1)
}                                                  |

• alignment_bit_equal_to_zero¶

• MUST be equal to 0.¶

6.3.1. Scaling process for transform coefficients

Inputs to this process are:¶

• a location (xBlkY, yBlkY) of the current color component specifying the top-left sample of the current block relative to the top-left sample of the current frame,¶

• a variable nBlkW specifying the width of the current block,¶

• a variable nBlkH specifying the height of the current block,¶

• a variable cIdx specifying the color component of the current block, and¶

• a variable qP specifying the quantization parameter.¶

Output of this process is the (nBlkW)x(nBlkH) array d of scaled transform coefficients with elements d[x][y].¶

The variable bdShift is derived as follows:¶

• • bdShift = BitDepth + ((Log2(nBlkW) + Log2(nBlkH)) // 2) - 5¶

The list levelScale[] is specified as follows:¶

• • levelScale[k] = {40, 45, 51, 57, 64, 71} with k = 0..5.¶

For the derivation of the scaled transform coefficients d[x][y] with x = 0..nBlkW - 1, y = 0..nBlkH - 1, the following applies:¶

• The scaled transform coefficient d[x][y] is derived as follows:¶

• • d[x][y] = clip(-32768, 32767, ( ( TransCoeff[cIdx][xBlkY][yBlkY] * QMatrix[cIdx][x][y] * levelScale[qP%6] << (qP//6) ) + ( 1 << (bdShift-1) ) >> bdShift ))¶

6.3.2. Process for scaled transform coefficients

7.1.1. Process for abs_dc_coeff_diff

Inputs to this process are bits for the abs_dc_coeff_diff syntax element. Output of this process is a value of the abs_dc_coeff_diff syntax element. The variable kParam is derived as follows:¶

• • kParam = clip( 0, 5, PrevDcDiff >> 1 )¶

The value of syntax element abs_dc_coeff_diff is obtained by invoking the parsing process for variable length codes as specified in Section 7.1.4 with kParam.¶

7.1.2. Process for coeff_zero_run

Inputs to this process are bits for the coeff_zero_run syntax element.¶

Output of this process is a value of the coeff_zero_run syntax element.¶

The variable kParam is derived as follows:¶

• • kParam = clip( 0, 2, PrevRun >> 2 )¶

The value of syntax element coeff_zero_run is obtained by invoking the parsing process for variable length codes as specified in Section 7.1.4 with kParam.¶

7.1.3. Process for abs_ac_coeff_minus1

Inputs to this process are bits for the abs_ac_coeff_minus1 syntax element.¶

Output of this process is a value of the abs_ac_coeff_minus1 syntax element.¶

The variable kParam is derived as follows:¶

• • kParam = clip( 0, 4, PrevLevel >> 2 )¶

The value of syntax element abs_ac_coeff_minus1 is obtained by invoking the parsing process for variable length codes as specified in Section 7.1.4 with kParam.¶

7.1.4. Process for variable length codes

Input to this process is kParam.¶

Output of this process is a value, symbolValue, of a syntax element.¶

The symbolValue is derived as follows:¶

symbolValue = 0
parseExpGolomb = 1
k = kParam
stopLoop = 0

if(read_bits(1) = = 1) {
  parseExpGolomb = 0
}
else {          (9 4)
  if(read_bits (1) = = 0) {
    symbolValue += (1 << k)
    parseExpGolomb = 0
  }
  else {
    symbolValue += (2 << k)
    parseExpGolomb = 1
  }
}

if(parseExpGolomb) {
  do {
    if(read_bits(1) = = 1) {
      stopLoop = 1
    }
    else {
      symbolValue += (1 << k)
      k++
    }
  } while(!stopLoop)
}

if(k > 0)
  symbolValue += read_bits(k)

where the value returned from read_bits(n) is interpreted as a binary representation of a n-bit unsigned integer with most significant bit written first.¶

7.2.1. Process for abs_dc_coeff_diff

Input to this process is a symbol value of the abs_dc_coeff_diff syntax element.¶

Output of this process is a codeword of the abs_dc_coeff_diff syntax element.¶

The variable kParam is derived as follows:¶

• • kParam = clip( 0, 5, PrevDcDiff >> 1 )¶

The codeword of syntax element abs_dc_coeff_diff is obtained by invoking the generation process for variable length codes as specified in Section 7.2.4 with the symbol value symbolValue and kParam.¶

7.2.2. Process for coeff_zero_run

Input to this process is a symbol value of the coeff_zero_run syntax element.¶

Output of this process is a codeword of the coeff_zero_run syntax element.¶

The variable kParam is derived as follows:¶

• • kParam = clip( 0, 2, PrevRun >> 2 )¶

The codeword of syntax element coeff_zero_run is obtained by invoking the generation process for variable length codes as specified in Section 7.2.4 with the symbol value symbolValue and kParam.¶

7.2.3. Process for abs_ac_coeff_minus1

Input to this process is a symbol value of the abs_ac_coeff_minus1 syntax element.¶

Output of this process is a codeword of the abs_ac_coeff_minus1 syntax element.¶

The variable kParam is derived as follows:¶

• • kParam = clip( 0, 4, PrevLevel >> 2 )¶

The codeword of syntax element abs_ac_coeff_minus1 is obtained by invoking the generation for variable length codes as specified in Section 7.2.4 with the symbol value symbolValue and kParam.¶

7.2.4. Process for variable length codes

Inputs to this process are¶

• symbolVal and¶

• kParam.¶

Output of this process is a codeword of a syntax element.¶

The codeword is derived as follows:¶

SimpleVLCTable[3][2] = {  {1, 0}, {0, 0}, {0, 1} }
symbolValue = symbolVal
valSimpleVLC = clip(0, 2, symbolVal >> kParam)
bitCount = 0
k = kParam

while(symbolValue >= (1 << k)) {
  symbolValue -= (1 << k)
  if(bitCount < 2)
    put_bits(SimpleVLCTable[valSimpleVLC][ bitCount ], 1)
  else
    put_bits(0, 1)
  if(bitCount >= 2)
    k++
  bitCount++
}

if(bitCount < 2)
  put_bits(SimpleVLCTable[valSimpleVLC][ bitCount ], 1)
else
  put_bits(1, 1)

if(k > 0)
  put_bits(symbolValue, k)

where a codeword generated from put_bits( v, n ) is interpreted as a binary representation of an n-bit unsigned integer value v with most significant bit written first.¶

10.1.1. Overview of profiles, levels and toolsets

Profiles and levels specify restrictions on the bitstreams and hence limits on the capabilities needed to decode the bitstreams. Profiles and levels may also be used to indicate interoperability points between individual decoder implementations. NOTE This document does not include individually selectable "options" at the decoder, as this would increase interoperability difficulties. Each profile specifies a subset of algorithmic features and limits that MUST be supported by all decoders conforming to that profile. NOTE Encoders are not required to make use of any particular subset of features supported in a profile. Each level specifies a set of limits on the values that may be taken by the syntax elements of this document. The same set of level definitions is used with all profiles, but individual implementations may support a different level for each supported profile. For any given profile, a level generally corresponds to a particular decoder processing load and memory capability. The profiles that are specified in Section 10.1.3 are also referred to as the profiles specified in Section 10.1¶

10.1.2. Requirements on video decoder capability

Capabilities of video decoders conforming to this document are specified in terms of the ability to decode video streams conforming to the constraints of profiles and levels specified in this section. When expressing the capabilities of a decoder for a specified profile, the level supported for that profile should also be expressed. Specific values are specified in this section for the syntax elements profile__idc and level__idc. All other values of profile_idc and level_idc are reserved for future use. NOTE Decoders must not infer that a reserved value of profile__idc between the values specified in this document indicates intermediate capabilities between the specified profiles, as there are no restrictions on the method to be chosen for the use of such future reserved values. However, decoders must infer that a reserved value of level__idc between the values specified in this document indicates intermediate capabilities between the specified levels.¶

10.1.3. Profiles

10.1.4. Levels

10.2.1. Raw bitstream Frame Data syntax and semantics

syntax code                                                   | type
--------------------------------------------------------------|-----
raw_bitstream_frame_data( ) {                                 |
    frame_data_size                                           | u(32)
    frame_data( )                                             |
}                                                             |

• frame_data_size¶

• indicates the length of the Frame Data, in bytes, within the frame_data( ) syntax structure.¶