AV2 Syntax Browser

5.1. General

This section presents the syntax structures in a tabular form. The meaning of each of the syntax elements is presented in § 6 Syntax structures semantics.

5.2. OBU syntax

5.2.1. General OBU syntax

where some helper functions used to identify collections of OBU types are specified as:

is_tip_frame() {
    return obu_type == OBU_LEADING_TIP || obu_type == OBU_REGULAR_TIP
}

is_sef() {
    return obu_type == OBU_LEADING_SEF || obu_type == OBU_REGULAR_SEF
}

is_tile_group() {
    return obu_type == OBU_LEADING_TILE_GROUP || 
           obu_type == OBU_REGULAR_TILE_GROUP || 
           obu_type == OBU_CLOSED_LOOP_KEY || 
           obu_type == OBU_OPEN_LOOP_KEY ||
           obu_type == OBU_SWITCH ||
           obu_type == OBU_RAS_FRAME
}

is_extensible_obu() {
    return obu_type == OBU_SEQUENCE_HEADER ||
           obu_type == OBU_MULTI_FRAME_HEADER ||
           obu_type == OBU_LAYER_CONFIGURATION_RECORD ||
           obu_type == OBU_CONTENT_INTERPRETATION ||
           obu_type == OBU_OPERATING_POINT_SET ||
           obu_type == OBU_ATLAS_SEGMENT
}

5.2.2. OBU header syntax

5.2.3. Trailing bits syntax

5.2.4. Byte alignment syntax

5.3. Reserved OBU syntax

Note: Reserved OBUs do not have a defined syntax. The obu_type reserved values are reserved for future use by AOMedia. Decoders should ignore the entire OBU if they do not understand the obu_type. The last byte of the valid content of the payload data for this OBU type is considered to be the last byte that is not equal to zero. This rule is to prevent the dropping of valid bytes by systems that interpret trailing zero bytes as a continuation of the trailing bits in an OBU. This implies that when any payload data is present for this OBU type, at least one byte of the payload data (including the trailing bit) shall not be equal to 0.

5.4. Sequence header OBU syntax

5.4.1. General sequence header OBU syntax

5.4.2. Sequence tile config syntax

5.4.3. Sequence partition config syntax

5.4.4. Sequence segment config syntax

5.4.5. Sequence intra config syntax

5.4.6. Sequence inter config syntax

5.4.7. Sequence screen content config syntax

5.4.8. Sequence transform quant entropy config syntax

5.4.9. Segment information syntax

5.4.10. Sequence filter config syntax

5.4.11. User defined QM syntax

where Fundamental_Tx_Size (which gives the order of quantization matrices) is specified as:

Fundamental_Tx_Size[ 3 ] = { TX_8X8, TX_8X4, TX_4X8 }

5.4.12. Timing info syntax

5.4.13. Sequence decoder model info syntax

5.5. Temporal delimiter OBU syntax

Note: The temporal delimiter has an empty payload.

5.6. Multi Stream Decoder Operation OBU syntax

5.7. Multi frame header OBU syntax

5.8. Layer config record OBU syntax

5.8.1. LCR global info syntax

5.8.2. LCR local info syntax

5.8.3. LCR aggregate info syntax

5.8.4. LCR sequence profile tier level information syntax

5.8.5. LCR global payload syntax

5.8.6. LCR xlayer info syntax

5.8.7. LCR rep info syntax

5.8.8. LCR embedded layer info syntax

5.8.9. LCR xlayer color info syntax

5.9. Atlas segment info OBU syntax

5.9.1. Atlas label segment info syntax

5.9.2. Atlas enhanced atlas info syntax

5.9.2.1. Atlas region info syntax

5.9.2.2. Atlas region to segment mapping syntax

5.9.3. Atlas multistream info syntax

5.9.4. Atlas multistream with alpha info syntax

5.9.5. Atlas basic info syntax

5.10. Operating point set OBU syntax

5.11. Operating point payload syntax

5.11.1. Operating point set aggregate info syntax

5.11.2. Operating point set sequence profile tier level information syntax

5.11.3. Operating point set decoder model info syntax

5.11.4. Operating point set color info syntax

5.11.5. Operating point set mlayer info syntax

5.12. Buffer removal timing OBU syntax

5.13. Quantizer Matrix OBU syntax

5.14. Film grain OBU syntax

5.15. Content interpretation OBU syntax

where the tables Aspect_Ratio_Width and Aspect_Ratio_Height are specified as:

Aspect_Ratio_Width[ 17 ] = {  0,  1, 12, 10, 16,  40, 24, 20, 
                             32, 80, 18, 15, 64, 160,  4,  3, 2 }

Aspect_Ratio_Height[ 17 ] = {  0,  1, 11, 11, 11, 33, 11, 11, 
                              11, 33, 11, 11, 33, 99,  3,  2, 1 }

5.16. Padding OBU syntax

Note: obu_padding_length is not coded in the bitstream but can be computed based on the OBU size minus the number of trailing bytes. In practice, though, since this is padding data meant to be skipped, decoders do not need to determine either that length or the number of trailing bytes. They can ignore the entire OBU. The last byte of the valid content of the payload data for this OBU type is considered to be the last byte that is not equal to zero. This rule is to prevent the dropping of valid bytes by systems that interpret trailing zero bytes as a continuation of the trailing bits in an OBU. This implies that when any payload data is present for this OBU type, at least one byte of the payload data (including the trailing bit) shall not be equal to 0.

Note: A padding OBU with an obuPayloadSize of 0 is legal. This means the OBU has obu_padding_length of 0 and will not contain any trailing bits. A padding OBU with an obuPayloadSize of 1 is legal. This means the OBU has obu_padding_length of 0 and does contain trailing bits. This is allowed so that any OBU can be converted into a padding OBU in-place.

5.17. Metadata OBU syntax

This specification defines two distinct OBU types for carrying metadata:

• OBU_METADATA_SHORT: using metadata short OBU syntax, and

• OBU_METADATA_GROUP: using metadata group OBU syntax.

Both OBU types use the same metadata_unit() syntax element to carry the actual metadata payload. The OBU_METADATA_SHORT type provides a compact header structure, while OBU_METADATA_GROUP provides extended capabilities including the ability to carry multiple metadata units within a single OBU with additional signaling for application-specific handling, layer targeting, and priority.

5.17.1. Metadata unit syntax

Note: The exact syntax of metadata_unit is not defined in this specification when metadata_type is equal to a value reserved for future use or a user private value. Decoders should ignore the metadata_unit() if they do not understand the metadata_type. For OBU_METADATA_SHORT, this means ignoring the entire OBU. For OBU_METADATA_GROUP, decoders should skip only the unrecognized metadata_unit() and continue processing other metadata units within the same OBU.

5.17.2. Metadata short OBU syntax

5.17.3. Metadata group OBU syntax

5.17.4. Metadata ITUT T35 syntax

Note: The exact syntax of itu_t_t35_payload_bytes is not defined in this specification. External specifications can define the syntax. Decoders should ignore the entire OBU if they do not understand it.

5.17.5. Metadata high dynamic range content light level syntax

5.17.6. Metadata high dynamic range mastering display color volume syntax

5.17.7. Metadata timecode syntax

5.17.8. Metadata banding hints syntax

5.17.9. Metadata ICC profile syntax

5.17.10. Metadata scan type syntax

5.17.11. Metadata temporal point info syntax

5.17.12. Metadata decoded frame hash syntax

5.17.13. Metadata user data unregistered syntax

5.18. Frame header syntax

5.18.1. General frame header syntax

where the syntax structure frame_header_copy is defined as:

5.18.2. Frame header info syntax

where the function reset_qm is defined as:

reset_qm() {
    for ( level = 0; level < 15; level++ ) {
        if ( obu_type == OBU_SWITCH || obu_type == OBU_RAS_FRAME ) {
            needsReset = QmMLayerId[ level ] == -1 ||
                         MLayerPresenceMap[QmMLayerId[ level ]][obu_mlayer_id]
        } else {
            needsReset = 1
        }
        if ( !QmProtected[ level ] && needsReset ) {
            QmDataPresent[ level ] = 0 
            QmNumPlanes[ level ]  = NumPlanes
            QmMLayerId[ level ] = -1
            QmTLayerId[ level ] = -1
        }
    }
}

where the function get_disp_order_hint is defined as:

get_disp_order_hint( ) {
    if ( obu_type == OBU_CLOSED_LOOP_KEY ||
         ( !is_sef() && FrameType == SWITCH_FRAME &&
           restricted_prediction_switch ) ) {
        return OrderHintLsbs
    }
    maxDisp = get_max_disp_order_hint( 1 )
    dispOrderHint = OrderHintLsbs
    offset = maxDisp - ((1 << OrderHintBits) >> 1) - OrderHintLsbs
    if ( offset >= 0 ) {
        dispOrderHint += ((offset >> OrderHintBits) + 1) << OrderHintBits
    }
    return dispOrderHint
}

where get_max_disp_order_hint (which returns the maximum order hint from certain frames) is defined as:

get_max_disp_order_hint( onlyShowable ) {
    maxDisp = 0
    for ( i = 0; i < NumRefFrames; i++ ) {
        if ( RefValid[i] && 
                TLayerDependencyMap[obu_mlayer_id][obu_tlayer_id][RefTLayerId[i]] &&
                MLayerDependencyMap[obu_mlayer_id][RefMLayerId[i]] && 
                ( !onlyShowable || RefImplicitOutputFrame[ i ] ||
                  RefImmediateOutputFrame[ i ] ) ) {
            maxDisp = Max( maxDisp, RefOrderHint[i])
        }
    }
    return maxDisp
}

It is a requirement of bitstream conformance that the value returned from get_disp_order_hint is less than (1 << (DISPLAY_ORDER_HINT_BITS - 1)).

The function set_primary_ref_frame_and_ctx is defined as:

set_primary_ref_frame_and_ctx( loadCdfs ) {
    (DerivedPrimaryRefFrame,derivedSecondaryRefFrame) = 
        choose_primary_secondary_ref_frame()
    if ( primary_ref_frame == PRIMARY_REF_CHOOSE ) {
        primary_ref_frame = DerivedPrimaryRefFrame
    }
    if ( DerivedPrimaryRefFrame == PRIMARY_REF_NONE ||
         primary_ref_frame == PRIMARY_REF_NONE ) {
        primary_ref_frame = PRIMARY_REF_NONE
        DerivedPrimaryRefFrame = PRIMARY_REF_NONE
        disable_cross_frame_cdf_init = 1
    }
    if ( !loadCdfs ) {
        return
    }
    if ( primary_ref_frame == PRIMARY_REF_NONE ||
         disable_cross_frame_cdf_init ) {
        init_non_coeff_cdfs( )
    } else {
        load_cdfs( ref_frame_idx[ primary_ref_frame ] )
        if ( TipFrameMode != TIP_FRAME_AS_OUTPUT ) {
            blendFrame = (primary_ref_frame == DerivedPrimaryRefFrame) ? 
                derivedSecondaryRefFrame : DerivedPrimaryRefFrame
            if ( enable_avg_cdf && !avg_cdf_type &&
                 blendFrame != PRIMARY_REF_NONE &&
                 !bru_inactive ) {
                blend_cdfs( ref_frame_idx[ blendFrame ] )
            }
        }
    }
    if ( DerivedPrimaryRefFrame == PRIMARY_REF_NONE ) {
        setup_past_independence( )
    } else {
        load_previous( )
    }
}

The functions choose_primary_secondary_ref_frame and is_ref_better are defined as:

choose_primary_secondary_ref_frame() {
    if ( FrameIsIntra || FrameType == SWITCH_FRAME ) {
        return (PRIMARY_REF_NONE, PRIMARY_REF_NONE)
    }
    primary = PRIMARY_REF_NONE
    primaryQpDiff = 512
    secondary = PRIMARY_REF_NONE
    secondaryQpDiff = 512
    primaryD = 0
    secondaryD = 0
    primaryRatio = 0
    secondaryRatio = 0
    for ( i = 0; i < NumTotalRefs; i++ ) {
        idx = ref_frame_idx[ i ]
        if ( RefFrameType[ idx ] == INTER_FRAME && first_slot_with_ref(idx) &&
             RefOrderHint[idx] != RESTRICTED_OH ) {
            q = RefBaseQIdx[ idx ]
            d = RefOrderHint[ idx ]
            dRatio = FloorLog2( RefFrameWidth[ idx ] * RefFrameHeight[ idx ] )
            qpDiff = Abs(q - base_q_idx)
            if ( (qpDiff < primaryQpDiff) || 
                 (qpDiff == primaryQpDiff &&
                     is_ref_better(d,primaryD,dRatio,primaryRatio)) ) {
                secondary = primary
                secondaryQpDiff = primaryQpDiff
                secondaryD = primaryD
                secondaryRatio = primaryRatio
                primary = i
                primaryQpDiff = qpDiff
                primaryD = d
                primaryRatio = dRatio
            } else if ((qpDiff < secondaryQpDiff) || 
                   (qpDiff == secondaryQpDiff &&
                       is_ref_better(d,secondaryD,dRatio,secondaryRatio))) {
                secondary = i
                secondaryQpDiff = qpDiff
                secondaryD = d
                secondaryRatio = dRatio
            }
        }
    }
    if ( signal_primary_ref_frame ) {
        if ( primary_ref_frame == PRIMARY_REF_NONE ) {
            primary = PRIMARY_REF_NONE
            secondary = PRIMARY_REF_NONE
        } else if ( primary_ref_frame != primary ) {
            if ( secondary == PRIMARY_REF_NONE ||
                 secondary == primary_ref_frame ) {
                secondary = primary
            }
            primary = primary_ref_frame
        }
    }
    return (primary,secondary)
}

is_ref_better(refDisp, bestDisp, refRatio, bestRatio) {
    d0 = Abs(get_relative_dist(OrderHint,refDisp)) - (refRatio << 1)
    d1 = Abs(get_relative_dist(OrderHint,bestDisp)) - (bestRatio << 1)
    if (d0 < d1) {
        return 1
    }
    if (d0 == d1 && get_relative_dist(refDisp,bestDisp) > 0) {
        return 1
    }
    return 0
}

The function long_term_id_in_use (which determines if longTermId is present in the ref_long_term_id array) is defined as:

long_term_id_in_use( longTermId ) {
    for ( j = 0; j < num_key_ref_frames; j++ ) {
        if ( longTermId == ref_long_term_id[ j ] ) {
            return 1
        }
    }
    return 0
}

5.18.3. Frame configuration structures

5.18.3.1. Get relative distance function

This function computes the distance between two order hints by sign extending the result of subtracting the values.

get_relative_dist( a, b ) {
    if ( a == RESTRICTED_OH && b == RESTRICTED_OH ) {
        return 0
    } else if ( a == RESTRICTED_OH ) {
        return 127
    } else if ( b == RESTRICTED_OH ) {
        return -127
    } else {
        return Clip3( -127, 127, a - b )
    }
}

5.18.3.2. Frame optical flow refine type syntax

5.18.3.3. Screen content params syntax

5.18.3.4. Intra block copy params syntax

5.18.4. Frame size structures

5.18.4.1. Frame size syntax

5.18.4.2. Frame size with bridge syntax

5.18.4.3. Frame size with refs syntax

5.18.4.4. Compute image size function

compute_image_size( ) {
    MiCols = 2 * ( ( FrameWidth + 7 ) >> 3 )
    MiRows = 2 * ( ( FrameHeight + 7 ) >> 3 )
    maxFrameWidth = max_frame_width_minus_1 + 1
    maxFrameHeight = max_frame_height_minus_1 + 1
    CropLeft = (seq_cropping_win_left_offset * FrameWidth) / maxFrameWidth
    cropRight = FrameWidth - ((seq_cropping_win_right_offset * FrameWidth) / 
                              maxFrameWidth)
    CropTop = (seq_cropping_win_top_offset * FrameHeight) / maxFrameHeight
    cropBottom = FrameHeight - ((seq_cropping_win_bottom_offset * FrameHeight) / 
                                maxFrameHeight)
    CropWidth = cropRight - CropLeft
    CropHeight = cropBottom - CropTop
}

5.18.5. Filtering structures

5.18.5.1. Interpolation filter syntax

5.18.5.2. Deblocking filter params syntax

5.18.6. Quantization structures

5.18.6.1. Quantization params syntax

5.18.6.2. Setup QM params syntax

5.18.6.3. Delta quantizer syntax

5.18.7. Segmentation and tiling structures

5.18.7.1. Segmentation params syntax

The constant lookup tables used in this syntax are defined as:

Segmentation_Feature_Bits[ SEG_LVL_MAX ]   = { 9, 0, 0 }
Segmentation_Feature_Signed[ SEG_LVL_MAX ] = { 1, 0, 0 }
Segmentation_Feature_Max[ SEG_LVL_MAX ] = { MAXQ_BITS, 0, 0 }

5.18.7.2. Tile info syntax

where uniform_eligible is specified as:

uniform_eligible( tileLog2, sbNum ) {
    tileNum = 1 << tileLog2
    tileWidth = (sbNum + tileNum - 1) >> tileLog2
    lastTileWidth = sbNum - (tileNum - 1) * tileWidth
    return tileWidth >= 1 && lastTileWidth >= 1
}

5.18.7.3. Tile params syntax

5.18.7.4. Reuse tile params function

reuse_tile_params( uniformSpacing, sbRowStarts, tileRows, tileRowsLog2, sbColStarts, tileCols, tileColsLog2, seqSbSize, sbSize ) {
    if ( uniformSpacing ) {
        sbShift = Mi_Width_Log2[ seqSbSize ]      
        (unifSbColStarts, tileCols) = uniform_spacing( tileColsLog2, MiCols,
                                                       seqSbSize )
        (unifSbRowStarts, tileRows) = uniform_spacing( tileRowsLog2, MiRows, 
                                                       seqSbSize )
        tileColsLog2 = tile_log2(1, tileCols)
        tileRowsLog2 = tile_log2(1, tileRows)
        return ( unifSbRowStarts, tileRows, tileRowsLog2, unifSbColStarts,
                 tileCols, tileColsLog2, sbShift)
    } else {
        sbShift = Mi_Width_Log2[ sbSize ]      
        tileColsLog2 = tile_log2(1, tileCols)
        tileRowsLog2 = tile_log2(1, tileRows)
        return ( sbRowStarts, tileRows, tileRowsLog2, sbColStarts, tileCols,
                 tileColsLog2, sbShift)
    }
}

5.18.7.5. Uniform spacing function

uniform_spacing( tileLog2, mis, sbSize ) {
    sb4x4 = Num_4x4_Blocks_Wide[ sbSize ]
    sbShift = Mi_Width_Log2[ sbSize ]
    sbs = ( mis + sb4x4 - 1 ) >> sbShift
    fullSbs = mis >> sbShift
    tileSb = fullSbs >> tileLog2
    if ( tileSb == 0 ) {
        extraSbs = sbs
    } else {
        extraSbs = fullSbs - (tileSb << tileLog2)
    }
    startSb = 0
    for (i = 0; i < (1 << tileLog2) && startSb < sbs; i++) {
        sbStarts[ i ] = startSb
        startSb += tileSb
        if (i < extraSbs) {
            startSb += 1
        }
    }
    return (sbStarts, i)
}

5.18.7.6. Get sequence superblock size function

get_seq_sb_size() {
    if ( use_256x256_superblock ) {
        return BLOCK_256X256
    } else if ( use_128x128_superblock ) {
        return BLOCK_128X128
    } else {
        return BLOCK_64X64
    }
}

5.18.7.7. Tile size calculation function

tile_log2 returns the smallest value for k such that blkSize << k is greater than or equal to target.

tile_log2( blkSize, target ) {
    for ( k = 0; (blkSize << k) < target; k++ ) {
    }
    return k
}

5.18.7.8. Quantizer index delta parameters syntax

5.18.7.9. GDF params syntax

5.18.7.10. CDEF params syntax

5.18.7.11. Loop restoration params syntax

where the function get_filter_set_index is defined as:

get_filter_set_index( base_qindex ) {
    if (base_qindex < 130) {
        return 0
    } else if (base_qindex < 190) {
        return 1
    } else if (base_qindex < 220) {
        return 2
    } else {
        return 3
    }
}

and the constant tables Decode_Num_Filter_Classes and Encode_Num_Filter_Classes are defined as:

Encode_Num_Filter_Classes[ 17 ] = {
    0, 0, 1, 2, 3, 0, 4, 0, 5, 0, 0, 0, 6, 0, 0, 0, 7
}

Decode_Num_Filter_Classes[ 8 ] = {
    1, 2, 3, 4, 6, 8, 12, 16
}

5.18.7.12. CCSO params syntax

where Ccso_Offset is defined as:

Ccso_Offset[ 8 ] = { 
    0, 1, -1, 3, -3, 7, -7, -10
}

5.18.8. Transform and coding mode structures

5.18.8.1. TX mode syntax

5.18.8.2. Skip mode params syntax

5.18.8.3. Frame reference mode syntax

5.18.9. Global motion structures

5.18.9.1. Global motion params syntax

where Param_Shift, Param_Min, Param_Max, and scale_warp_model are defined as:

Param_Shift[ 6 ] = {
    GM_TRANS_PREC_DIFF,    GM_TRANS_PREC_DIFF,   GM_ALPHA_PREC_DIFF,
    GM_ALPHA_PREC_DIFF,    GM_ALPHA_PREC_DIFF,   GM_ALPHA_PREC_DIFF
}

Param_Min[ 6 ] = { 
    GM_TRANS_MIN,    GM_TRANS_MIN,
    GM_ALPHA_MIN,    GM_ALPHA_MIN,
    GM_ALPHA_MIN,    GM_ALPHA_MIN
}

Param_Max[ 6 ] = {
    GM_TRANS_MAX,    GM_TRANS_MAX,
    GM_ALPHA_MAX,    GM_ALPHA_MAX,
    GM_ALPHA_MAX,    GM_ALPHA_MAX
}

scale_warp_model(baseParams, baseDistance, dist) {
    if ( baseDistance == 0 ) {
        return Default_Warp_Params
    }
    if ( baseDistance < 0 ) {
        baseDistance = -baseDistance
        dist = -dist
    }
    for ( i = 0; i < 6; i++ ) {
        center = Default_Warp_Params[ i ]
        limit = (1 << 22) - 1
        input = Clip3( -limit, limit, baseParams[ i ] - center )
        (divShift, divFactor) = resolve_divisor( baseDistance )
        scaled = Round2Signed( input * divFactor, divShift )
        output = Round2Signed( scaled * dist, Param_Shift[ i ] )
        output = Clip3( Param_Min[i], Param_Max[i], output ) << Param_Shift[i]
        params[ i ] = center + output
    }
    return params
}

5.18.9.2. Global param syntax

Note: When force_integer_mv is equal to 1, some fractional bits are still read for the translation components. However, these fractional bits will be discarded during the Setup Global MV process.

5.18.9.3. Decode signed subexp with ref syntax

5.18.9.4. Decode unsigned subexp with ref syntax

5.18.9.5. Decode subexp syntax

5.18.9.6. Inverse recenter function

inverse_recenter( r, v ) {
    if ( v > 2 * r ) {
        return v
    } else if ( v & 1 ) {
        return r - ((v + 1) >> 1)
    } else {
        return r + (v >> 1)
    }
}

5.18.10. Film grain structures

5.18.10.1. Film grain config syntax

5.18.10.2. Film grain model syntax

5.19. Tile group OBU syntax

5.20. Tile group payload syntax

5.20.1. General tile group payload syntax

5.20.2. Tile-level structures

5.20.2.1. Decode tile syntax

where Wiener_Ns_Taps_Min and Wiener_Ns_Taps_K are constant lookup tables specified as:

Wiener_Ns_Taps_Min[ 2 ][ 18 ] = {
    {-24, -24, -14 , -14, -16, -16, -8,   -8,  -8,  -8, -8, -8, -8, -8, -8, -8,
     -8, -8},
    {-24, -24, -14 , -14, -16, -16, -16, -16, -16, -16, -8, -8, -8, -8, -8, -8,
     -8, -8}
}

Wiener_Ns_Taps_K[ 2 ][ 18 ] = {
    {6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4},
    {6, 6, 5, 5, 5, 5, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4}
}

5.20.2.2. Reset reference motion vector bank function

reset_refmv_bank( r, c, sbSize4, topRow ) {
    WarpBankHits = 0
    RefMvBankHits = 0
    RefMvRemainHits = 0
    RefMvUnitHits = 0
    if ( FrameIsIntra || topRow ) {
        return
    }
    rowHits = 0
    candRow = r - 1
    candCol = c
    while ( candCol < MiCols && candCol < c + sbSize4 && rowHits < 4 ) {
        candCol2 = (candCol >> 1) << 1
        if ( IsInters[ candRow ][ candCol2 ] ) {
            rowHits++
            update_ref_mv_bank( RefFrames[ candRow ][ candCol2 ], 
                Mvs[ candRow ][ candCol2 ], CwpIdxs[ candRow ][ candCol2 ],0)
            if ( MotionModes[ candRow ][ candCol2 ] >= LOCALWARP ) {
                update_warp_param_bank( RefFrames[ candRow ][ candCol2 ],
                                        WarpParams[ candRow ][ candCol2 ],1)
            }
        }
        candSize = MiSizes[ 0 ][ candRow ][ candCol2 ]
        candCol += Num_4x4_Blocks_Wide[ candSize ]
    }
}

5.20.2.3. Clear block decoded flags function

clear_block_decoded_flags( r, c, sbSize4 ) {
    for ( plane = 0; plane < NumPlanes; plane++ ) {
        subX = (plane > 0) ? SubsamplingX : 0
        subY = (plane > 0) ? SubsamplingY : 0
        sbWidth4 = ( MiColEnd - c ) >> subX
        sbHeight4 = ( MiRowEnd - r ) >> subY
        for ( y = -1; y <= ( sbSize4 >> subY ); y++ ) {
            for ( x = -1; x <= ( (2 * sbSize4) >> subX ); x++ ) {
                if ( y < 0 && x < sbWidth4 ) {
                    BlockDecoded[ plane ][ y ][ x ] = 1
                } else if ( x < 0 && y < sbHeight4 ) {
                    BlockDecoded[ plane ][ y ][ x ] = 1
                } else {
                    BlockDecoded[ plane ][ y ][ x ] = 0
                }
            }
        }
        BlockDecoded[ plane ][ sbSize4 >> subY ][ -1 ] = 0
    }
}

5.20.3. Partition structures

5.20.3.1. Decode partition syntax

The function is_bsize_allowed_for_extended_sdp is defined as:

is_bsize_allowed_for_extended_sdp(bSize, partition) {
    bw = Block_Width[ bSize ]
    bh = Block_Height[ bSize ]
    return bw <= INTER_SDP_MAX_BLOCK_SIZE && bh <= INTER_SDP_MAX_BLOCK_SIZE &&
           bw >= 8 && bh >= 8 &&
           partition < PARTITION_HORZ_4A && partition != PARTITION_NONE
}

5.20.3.2. Read partition syntax

Rect_Part_Table[ 2 ][ 2 ][ NUM_UNEVEN_4WAY_PARTS ][ NUM_RECT_PARTS ] = {
    {
        {
            { PARTITION_HORZ, PARTITION_VERT },
            { PARTITION_HORZ, PARTITION_VERT },
        },
        {
            { PARTITION_HORZ, PARTITION_VERT },
            { PARTITION_HORZ, PARTITION_VERT },
        },
    },
    {
        {
            { PARTITION_HORZ_3, PARTITION_VERT_3 },
            { PARTITION_HORZ_3, PARTITION_VERT_3 },
        },
        {
            { PARTITION_HORZ_4A, PARTITION_VERT_4A },
            { PARTITION_HORZ_4B, PARTITION_VERT_4B },
        }
    }
}

where init_allowed_partitions, is_partition_allowed, is_chroma_offset_for_partition, is_chroma_offset_for_subsize, check_chroma, block_coded, rect_type_implied_by_bsize, is_ext_partition_allowed, partition_implied_at_bo undary, partition_implied, and is_uneven_4way_partition_allowed are functions defined as:

block_coded(r,c) {
    return r < MiRows && c < MiCols
}

check_chroma(bSize) {
    if ( get_plane_residual_size( bSize, 1 ) == BLOCK_INVALID ) {
        return 0
    }
    return ( TreeType == LUMA_PART &&
            Block_Width[ bSize ] >= 64 &&
            Block_Height[ bSize ] >= 64 )
}

is_chroma_offset_for_subsize( subSize ) {
    if ( SubsamplingY && Mi_Height_Log2[ subSize ] == 0 ) {
        return 1
    }
    if ( SubsamplingX && Mi_Width_Log2[ subSize ] == 0 ) {
        return 1
    }
    return 0
}

is_chroma_offset_for_partition( p, bSize ) {
    if ( is_chroma_offset_for_subsize( Partition_Subsize[ p ][ bSize ] ) ) {
        return 1
    }
    if ( p == PARTITION_HORZ_3 ) {
        middleChroma = bSize == BLOCK_8X32 && SubsamplingX
        if ( !middleChroma ) {
            if ( is_chroma_offset_for_subsize( H_Partition_Midsize[bSize] ) ) {
                return 1
            }
        }
    }
    return 0
}

is_partition_allowed(r,c,p,bSize,chromaOffset,hasChroma,numPlanes) {
    subSize = Partition_Subsize[ p ][ bSize ]
    if ( subSize == BLOCK_INVALID ) {
        return 0
    }
    if ( !FrameIsIntra && RegionType == MIXED_REGION && subSize == BLOCK_4X4 ) {
        return 0
    }
    rectType = rect_type_implied_by_bsize( bSize )
    if ( rectType == RECT_VERT &&
            (p == PARTITION_HORZ ||
            p == PARTITION_HORZ_3 ||
            p == PARTITION_HORZ_4A ||
            p == PARTITION_HORZ_4B) ) {
        return 0
    }
    if ( rectType == RECT_HORZ &&
            (p == PARTITION_VERT ||
            p == PARTITION_VERT_3 ||
            p == PARTITION_VERT_4A ||
            p == PARTITION_VERT_4B) ) {
        return 0
    }
    bw = Block_Width[ subSize ]
    bh = Block_Height[ subSize ]
    if ( bw > bh * MaxPbAspectRatio || bh > bw * MaxPbAspectRatio ) {
        if (p == PARTITION_NONE) {
            return 0
        }
        if ( bw >= bh * 8 || bh >= bw * 8 ) {
            return 0 
        }
    }
    num4x4wide = Num_4x4_Blocks_Wide[ bSize ]
    num4x4high = Num_4x4_Blocks_High[ bSize ]
    halfBlock4x4wide = num4x4wide >> 1
    halfBlock4x4high = num4x4high >> 1      
    if ( hasChroma && TreeType != CHROMA_PART ) {
        if ( !chromaOffset ) {
            chromaOffset = is_chroma_offset_for_partition( p, bSize )
        }
    }
    if ( (hasChroma && !chromaOffset && TreeType != LUMA_PART) || 
         check_chroma(bSize) ) {
        if ( get_plane_residual_size( subSize, 1 ) == BLOCK_INVALID ) {
            return 0
        }
    }
    if ( p == PARTITION_HORZ_3 ) {
        if ( !is_ext_partition_allowed( bSize, RECT_HORZ) ) {
            return 0
        }
    } else if ( p == PARTITION_VERT_3 ) {
        if ( !is_ext_partition_allowed( bSize, RECT_VERT) ) {
            return 0
        }
    } else if ( p == PARTITION_HORZ_4A || p == PARTITION_HORZ_4B ) {
        if ( !is_ext_partition_allowed( bSize, RECT_HORZ) ||
             !is_uneven_4way_partition_allowed( bSize, RECT_HORZ ) ) { 
            return 0
        }
    } else if ( p == PARTITION_VERT_4A || p == PARTITION_VERT_4B ) {
        if ( !is_ext_partition_allowed( bSize, RECT_VERT) ||
             !is_uneven_4way_partition_allowed( bSize, RECT_VERT ) ) {
            return 0
        }
    } else if ( p == PARTITION_NONE ) {
        hasRows = ( r + halfBlock4x4high ) < MiRows
        hasCols = ( c + halfBlock4x4wide ) < MiCols
        if ( (TreeType != CHROMA_PART || bSize != BLOCK_8X8) &&
             (!hasRows || !hasCols) ) {
            return 0
        }
    }
    if ( hasChroma && TreeType != LUMA_PART && numPlanes > 1 ) {
        if ( chromaOffset ) {
            if ( p == PARTITION_HORZ ) {
                return block_coded( r + halfBlock4x4high, c )
            } else if ( p == PARTITION_VERT ) {
                return block_coded( r, c + halfBlock4x4wide )
            } else if ( p == PARTITION_HORZ_3 ) {
                return block_coded( r + 3 * (halfBlock4x4high >> 1), c )
            } else if ( p == PARTITION_VERT_3 ) {
                return block_coded( r, c + 3 * (halfBlock4x4wide >> 1) )
            } else if ( p == PARTITION_HORZ_4A || p == PARTITION_HORZ_4B ) {
                h4 = Num_4x4_Blocks_High[ subSize ]
                return block_coded( r + 7 * h4, c )
            } else if ( p == PARTITION_VERT_4A || p == PARTITION_VERT_4B ) {
                w4 = Num_4x4_Blocks_Wide[ subSize ]
                return block_coded( r, c + 7 * w4 )
            }
        }
    }
    return 1
}

init_allowed_partitions(r,c,bSize,chromaOffset,hasChroma) {
    numAllowed = 0
    for ( p = 0; p < EXT_PARTITION_TYPES; p++ ) {
        good = is_partition_allowed(r,c,p,bSize,chromaOffset,
                                    hasChroma,NumPlanes)
        numAllowed += good
        allowed[ p ] = good
    }
    if ( numAllowed == 0 ) {
        allowed[ PARTITION_NONE ] = 1
        numAllowed = 1
    }
    return (numAllowed,allowed)
}

rect_type_implied_by_bsize(bSize) {
    if ( bSize == BLOCK_4X8 || bSize == BLOCK_64X128 || 
        bSize == BLOCK_128X256 || bSize == BLOCK_4X16 ) {
        return RECT_HORZ
    }
    if ( bSize == BLOCK_8X4 || bSize == BLOCK_128X64 || 
        bSize == BLOCK_256X128 || bSize == BLOCK_16X4 ) {
        return RECT_VERT
    }
    if ( TreeType == CHROMA_PART ) {
        if ( bSize == BLOCK_8X16 || bSize == BLOCK_8X32 ) {
            return RECT_HORZ
        }
        if ( bSize == BLOCK_16X8 || bSize == BLOCK_32X8 ) {
            return RECT_VERT
        }
    }
    return RECT_INVALID
}

is_ext_partition_allowed(bSize, rectType) {
    if ( !enable_ext_partitions ) {
        return 0
    }
    return TreeType != CHROMA_PART ||
        (rectType == RECT_HORZ &&
            Block_Height[ bSize ] > 16 && Block_Width[ bSize ] > 8) ||
        (rectType == RECT_VERT &&
            Block_Width[ bSize ] > 16 && Block_Height[ bSize ] > 8)
}

partition_implied_at_boundary(r, c, bSize) {
    numWide4x4 = Num_4x4_Blocks_Wide[ bSize ]
    numHigh4x4 = Num_4x4_Blocks_High[ bSize ]
    hasRows = ( r + (numHigh4x4 >> 1) ) < MiRows
    hasCols = ( c + (numWide4x4 >> 1) ) < MiCols
    if ( hasRows && hasCols ) {
        return (0, PARTITION_NONE)
    }
    impliedPartition = PARTITION_NONE
    if ( numWide4x4 == numHigh4x4 ) {
        impliedPartition = hasRows ? PARTITION_VERT : PARTITION_HORZ
    } else if ( numHigh4x4 > numWide4x4 ) {
        if ( !hasRows ) {
            impliedPartition = PARTITION_HORZ
        } else {
            subHasCols = ( c + (numWide4x4 >> 2) ) < MiCols
            if ( numWide4x4 >= 4 && !subHasCols ) {
                impliedPartition = PARTITION_HORZ
            }
        }
    } else {
        if ( !hasCols ) {
            impliedPartition = PARTITION_VERT
        } else {
            subHasRows = ( r + (numHigh4x4 >> 2) ) < MiRows
            if ( numHigh4x4 >= 4 && !subHasRows ) {
                impliedPartition =  PARTITION_VERT
            }
        }   
    }
    return (impliedPartition != PARTITION_NONE, impliedPartition)
}

partition_implied(r, c, bSize) {
    if ( bSize == BLOCK_4X4 || bSize >= BLOCK_4X32 ) {
        return (1, PARTITION_NONE)
    }
    if ( TreeType == CHROMA_PART && bSize == BLOCK_8X8 ) {
        return (1, PARTITION_NONE)
    }
    if ( TreeType == CHROMA_PART && bSize == BLOCK_64X64 &&
         ChromaPartitionKnown[ r ][ c ] ) {
        return (1, LumaPartitions[ r ][ c ])
    }
    return partition_implied_at_boundary(r, c, bSize)
}

is_uneven_4way_partition_allowed(bSize, rectType) {
    if ( !enable_uneven_4way_partitions ) {
        return 0
    }
    return TreeType != CHROMA_PART ||
           (rectType == RECT_HORZ && Block_Height[ bSize ] == 64) ||
           (rectType == RECT_VERT && Block_Width[ bSize ] == 64)
}

5.20.4. Block decoding structures

5.20.4.1. Decode block syntax

where reset_block_context( ) is specified as:

reset_block_context( bw4, bh4 ) {
    for ( plane = 0; plane < 1 + 2 * HasChroma; plane++ ) {
        c = plane > 0 ? ChromaMiCol : MiCol
        r = plane > 0 ? ChromaMiRow : MiRow
        w4 = plane > 0 ? Num_4x4_Blocks_Wide[ ChromaMiSize ] : bw4
        h4 = plane > 0 ? Num_4x4_Blocks_High[ ChromaMiSize ] : bh4
        subX = plane > 0 ? SubsamplingX : 0
        subY = plane > 0 ? SubsamplingY : 0
        for ( i = c >> subX; i < ( ( c + w4 ) >> subX ); i++) {
            AboveLevelContext[ plane ][ i ] = 0
            AboveDcContext[ plane ][ i ] = 0
        }
        for ( i = r >> subY; i < ( ( r + h4 ) >> subY ); i++) {
            LeftLevelContext[ plane ][ i ] = 0
            LeftDcContext[ plane ][ i ] = 0
        }
    }
}

update_warp_param_bank is specified as:

update_warp_param_bank( refFrames , params, candFromSbAbove ) {
    isCompound = is_inter_ref_frame( refFrames[ 1 ] ) && !candFromSbAbove
    for ( refList = 0;refList < 1 + isCompound; refList++ ) {
        if ( WarpBankHits >= MAX_WARP_SB_HITS ) {
            return
        }
        WarpBankHits++
        ref = refFrames[ refList ]
        found = -1
        count = WarpBankSize[ ref ]
        start = WarpBankStart[ ref ]
        for ( i = 0; i < count; i++ ) {
            idx = (start + i) % WARP_PARAM_BANK_SIZE
            if ( params_equal( WarpBankParams[ ref ][ idx ],
                                params[ refList ] ) ) {
                found = i
                break
            }
        }
        if ( found >= 0 ) {
            for ( j = 0; j < 6; j++ ) {
                tmpParams[ j ] = WarpBankParams[ ref ][ idx ][ j ]
            }
            for ( i = found; i < count - 1; i++ ) {
                idx0 = (start + i) % WARP_PARAM_BANK_SIZE
                idx1 = (start + i + 1) % WARP_PARAM_BANK_SIZE
                for ( j = 0; j < 6; j++ ) {
                    WarpBankParams[ ref ][ idx0 ][ j ] =
                        WarpBankParams[ ref ][ idx1 ][ j ]
                }
            }
            tail = (start + count - 1) % WARP_PARAM_BANK_SIZE
            for ( j = 0; j < 6; j++ ) {
                WarpBankParams[ ref ][ tail ][ j ] = tmpParams[ j ]
            }
        } else {
            idx = (start + count) % WARP_PARAM_BANK_SIZE
            for ( j = 0; j < 6; j++ ) {
                WarpBankParams[ ref ][ idx ][ j ] = params[ refList ][ j ]
            }
            if ( count < WARP_PARAM_BANK_SIZE ) {
                WarpBankSize[ ref ] = count + 1
            } else {
                WarpBankStart[ ref ] = (start + 1) % WARP_PARAM_BANK_SIZE
            }
        }
    }
}

The function params_equal (which checks if the non-translational parts of two warps are equal) is defined as:

params_equal( paramsA , paramsB ) {
    for ( i = 2; i < 6; i++ ) {
        if ( paramsA[ i ] != paramsB[ i ]) {
            return 0
        }
    }
    return 1
}

update_ref_mv_bank (which ensures the current parameters are at the tail of the appropriate bank of motion vectors) is specified as:

update_ref_mv_bank( refFrames, mvs, cwpIdx, fromWithinSb ) {
    if ( fromWithinSb ) {
        update_ref_mv_count( )
        if ( RefMvRemainHits == 0 || RefMvUnitHits >= 16 ) {
            return
        }
        RefMvRemainHits--
        RefMvUnitHits++
    }
    RefMvBankHits++
    r0 = refFrames[ 0 ]
    r1 = refFrames[ 1 ]
    isCompound = is_inter_ref_frame(r1)
    ref = get_rmb_list_index( refFrames )
    for ( i = 0; i < 6; i++ ) {
        p[ i ] = 0
    }
    p[ 0 ] = cwpIdx
    p[ 1 ] = isCompound ? r0 + (r1 + 1) * BANK_REFS_PER_FRAME : r0
    p[ 2 ] = mvs[ 0 ][ 0 ]
    p[ 3 ] = mvs[ 0 ][ 1 ]
    if ( isCompound ) {
        p[ 4 ] = mvs[ 1 ][ 0 ]
        p[ 5 ] = mvs[ 1 ][ 1 ]
    }
    found = -1
    count = RefMvBankSize[ ref ]
    start = RefMvBankStart[ ref ]
    for ( i = 0; i < count; i++ ) {
        idx = (start + i) % REF_MV_BANK_SIZE
        if ( rmb_params_equal(RefMvBankParams[ ref ][ idx ],p) ) {
            found = i
            break
        }
    }
    if ( found >= 0 ) {
        for ( i = 0; i < 6; i++ ) {
            tmpParams[ i ] = RefMvBankParams[ ref ][ idx ][ i ]
        }
        for ( i = found; i < count - 1; i++ ) {
            idx0 = (start + i) % REF_MV_BANK_SIZE
            idx1 = (start + i + 1) % REF_MV_BANK_SIZE
            for ( j = 0; j < 6; j++ ) {
                RefMvBankParams[ ref ][ idx0 ][ j ] =
                    RefMvBankParams[ ref ][ idx1 ][ j ]
            }
        }
        tail = (start + count - 1) % REF_MV_BANK_SIZE
        for ( j = 0; j < 6; j++ ) {
            RefMvBankParams[ ref ][ tail ][ j ] = tmpParams[ j ]
        }
        return
    }
    idx = (start + count) % REF_MV_BANK_SIZE
    for ( j = 0; j < 6; j++ ) {
        RefMvBankParams[ ref ][ idx ][ j ] = p[ j ]
    }
    if ( count < REF_MV_BANK_SIZE ) {
        RefMvBankSize[ ref ] = count + 1
    } else {
        RefMvBankStart[ ref ] = (start + 1) % REF_MV_BANK_SIZE
    }
}

add_neighbor is specified as:

add_neighbor(nRow, nCol) {
    aboveSbBoundary = (MiRow >> Mi_Width_Log2[ SbSize ]) !=
                      (nRow >> Mi_Width_Log2[ SbSize ])
    if ( NNum < 2 && is_inside(nRow,nCol) && !aboveSbBoundary ) {
        NPos[ NNum ][ 0 ] = nRow
        NPos[ NNum ][ 1 ] = nCol
        NNum += 1
    }
    if ( NNumBuf < 2 && is_inside(nRow,nCol) ) {
        NPosBuf[ NNumBuf ][ 0 ] = nRow
        NPosBuf[ NNumBuf ][ 1 ] = nCol
        NNumBuf += 1
    }
}

Note: NPos will only contain locations that are in the same superblock row as the current block. NPosBuf contains locations that may require buffered access to a different superblock row.

update_ref_mv_count is specified as:

update_ref_mv_count() {
    if ( TreeType != CHROMA_PART ) {
        sbSize4 = Num_4x4_Blocks_Wide[ SbSize ]
        unitSize4 = sbSize4 >> 3
        unitCount = Max( Num_4x4_Blocks_Wide[ MiSize ] / unitSize4 , 1) * 
                    Max( Num_4x4_Blocks_High[ MiSize ] / unitSize4 , 1)
        if ( MiRow % sbSize4 == 0 && MiCol % sbSize4 == 0 ) {
            RefMvRemainHits = Max( unitCount , 4 )
            RefMvUnitHits = 0
        } else if ( MiRow % unitSize4 == 0 && MiCol % unitSize4 == 0 ) {
            RefMvRemainHits += unitCount
            RefMvUnitHits = 0
        }
    }
}

rmb_params_equal is specified as:

rmb_params_equal( paramsA, paramsB ) {
    for ( i = 1; i < 6; i++ ) {
        if ( paramsA[ i ] != paramsB[ i ] ) {
            return 0
        }
    }
    return 1
}

update_ibc_buffers is specified as:

update_ibc_buffers(miRow, miCol) {
    bufRow = miRow >> (IBC_BUFFER_SIZE_LOG2 - MI_SIZE_LOG2)
    bufCol = miCol >> (IBC_BUFFER_SIZE_LOG2 - MI_SIZE_LOG2)
    if ( bufRow != IBCBufferCurRow || bufCol != IBCBufferCurCol ) {
        blkIdx = ibc_buffer_index(IBCBufferCurRow, IBCBufferCurCol)
        IBCBufferRow[ blkIdx ] = IBCBufferCurRow
        IBCBufferCol[ blkIdx ] = IBCBufferCurCol
        IBCBufferValid[ blkIdx ] = 1
        if ( SbSize == BLOCK_64X64 ) {
            bruRow = IBCBufferCurRow << (IBC_BUFFER_SIZE_LOG2 - MI_SIZE_LOG2)
            bruCol = IBCBufferCurCol << (IBC_BUFFER_SIZE_LOG2 - MI_SIZE_LOG2)
            if ( BruModes[ bruRow ][ bruCol ] == BRU_INACTIVE ) {
                for ( i = 0; i < IBC_NUM_BUFFERS; i++ ) {
                    IBCBufferValid[ i ] = 0
                }
            }
        }
        IBCBufferCurRow = bufRow
        IBCBufferCurCol = bufCol
    }
}

Note: Calls to update_ibc_buffers are only needed for bitstream conformance checks. However, a decoder implementation may wish to use the same logic for updating a local cache of information available for intra block copy.

ibc_buffer_index is specified as:

ibc_buffer_index(row, col) {
    if ( SbSize == BLOCK_64X64 ) {
        return col & 3
    } else {
        return (col & 1) | ((row & 1) << 1)
    }
}

store_refined_mvs is specified as:

store_refined_mvs() {
    return Tip_Weighting_Factor[ tip_global_wtd_index ] == CWP_EQUAL && 
           enable_tip_refinemv && NumFutureRefs > 0 && NumPastRefs > 0
}

5.20.5. Mode information structures

5.20.5.1. Mode info syntax

5.20.5.2. BRU mode info syntax

5.20.5.3. Intra frame mode info syntax

5.20.5.4. Read intra block copy syntax

5.20.5.5. Read intra Y mode syntax

where Reordered_Y_Mode, Default_Mode_List_Y, get_intra_y_mode_set, get_joint_mode, and allow_fsc_intra are defined as:

Reordered_Y_Mode[ INTRA_MODES ] = {
    DC_PRED,   SMOOTH_PRED, SMOOTH_V_PRED, SMOOTH_H_PRED, PAETH_PRED,
    D45_PRED,  D67_PRED,    V_PRED,        D113_PRED,     D135_PRED,
    D157_PRED, H_PRED,      D203_PRED
}

Default_Mode_List_Y[ DIRECTIONAL_MODES_COUNT ] = {
    17, 45, 3, 10, 24, 31, 38, 52,
    15, 19, 43, 47, 1, 5, 8, 12, 22, 26, 29, 33, 36, 40, 50, 54,
    16, 18, 44, 46, 2, 4, 9, 11, 23, 25, 30, 32, 37, 39, 51, 53,
    14, 20, 42, 48, 0, 6, 7, 13, 21, 27, 28, 34, 35, 41, 49, 55
}

get_joint_mode( dir ) {
    if ( dir ) {
        mvRow = MiRow - 1
        mvCol = MiCol + Num_4x4_Blocks_Wide[ MiSize ] - 1
    } else {
        mvCol = MiCol - 1
        mvRow = MiRow + Num_4x4_Blocks_High[ MiSize ] - 1
    }
    if ( is_inside( mvRow, mvCol ) ) {
        return IntraJointModes[ mvRow ][ mvCol ]
    }
    return DC_PRED
}

get_intra_y_mode_set( modeIdx ) {
    if ( modeIdx < NON_DIRECTIONAL_MODES_COUNT ) {
        return modeIdx
    }
    modeIdx -= NON_DIRECTIONAL_MODES_COUNT
    for ( i = 0; i < DIRECTIONAL_MODES_COUNT; i++ ) {
        isDirSelected[ i ] = 0
    }
    if ( MiSize >= BLOCK_8X8 ) {
        count = 0
        for ( dir = 0; dir < 2; dir++ ) {
            mode = get_joint_mode( dir )
            if ( mode >= NON_DIRECTIONAL_MODES_COUNT ) {
                mode -= NON_DIRECTIONAL_MODES_COUNT
                if ( count == 0 || mode != dirModes[ 0 ] ) {
                    if ( modeIdx == 0 ) {
                        return mode + NON_DIRECTIONAL_MODES_COUNT
                    }
                    modeIdx -= 1
                    isDirSelected[ mode ] = 1
                    dirModes[ count ] = mode
                    count += 1
                }
            }
        }
        if ( Block_Width[ MiSize ] * Block_Height[ MiSize ] > 64 ) {
            for ( i = 1; i <= 4; i++ ) {
                for ( j = 0; j < count; j++ ) {
                    for ( sgn = -1 ; sgn <= 1 ; sgn += 2 ) {
                        mode = dirModes[ j ] + i * sgn
                        if (mode < 0) {
                            mode += DIRECTIONAL_MODES_COUNT
                        }
                        else if (mode >= DIRECTIONAL_MODES_COUNT) 
                            mode -= DIRECTIONAL_MODES_COUNT
                        if ( !isDirSelected[ mode ] ) {
                            if ( modeIdx == 0 ) {
                                return mode + NON_DIRECTIONAL_MODES_COUNT
                            }
                            modeIdx -= 1
                            isDirSelected[ mode ] = 1
                        }
                    }
                }
            }
        }
    }

    for ( i = 0; i < DIRECTIONAL_MODES_COUNT; i++ ) {
        mode = Default_Mode_List_Y[ i ]
        if ( !isDirSelected[ mode ] ) {
            if ( modeIdx == 0 ) {
                return mode + NON_DIRECTIONAL_MODES_COUNT
            }
            modeIdx -= 1
        }
    }
}

allow_fsc_intra( ) {
    w = Block_Width[ MiSize ]
    h = Block_Height[ MiSize ]
    return enable_idtx_intra && w <= FSC_MAX && h <= FSC_MAX
}

5.20.5.6. Read intra UV mode syntax

where Default_Mode_List_Uv, get_intra_uv_mode_set, and is_mhccp_allowed are defined as:

Default_Mode_List_Uv[ UV_INTRA_MODES_CFL_NOT_ALLOWED ] = {
    DC_PRED, SMOOTH_PRED, SMOOTH_V_PRED, SMOOTH_H_PRED, PAETH_PRED,
    V_PRED,   H_PRED,    D45_PRED,  D135_PRED,
    D67_PRED, D113_PRED, D157_PRED, D203_PRED
}

get_intra_uv_mode_set( modeIdx ) {
    if ( is_directional_mode( YMode ) ) {
        if ( modeIdx == 0 ) {
            return YMode
        }
        modeIdx -= 1
    }
    for ( i = 0; i < UV_INTRA_MODES_CFL_NOT_ALLOWED; i++ ) {
        mode = Default_Mode_List_Uv[ i ]
        if ( mode != YMode || !is_directional_mode( YMode ) ) {
            if ( modeIdx == 0 ) {
                return mode
            }
            modeIdx -= 1
        }
    }
}

is_mhccp_allowed( ) {
    planeSz = get_plane_residual_size( ChromaMiSize, 1 )
    if ( !enable_mhccp ) {
        return 0
    } else if ( TreeType == CHROMA_PART && FrameIsIntra && !CflAllowedInSdp ) {
        return 0
    } else if ( Lossless ) {
        return planeSz == BLOCK_4X4
    } else {
        w = Block_Width[ planeSz ]
        h = Block_Height[ planeSz ]
        return ( w > 4 || h > 4 ) && w <= 32 && h <= 32
    }
}

5.20.5.7. Intra segment ID syntax

5.20.5.8. Read segment ID syntax

where neg_deinterleave is a function defined as:

neg_deinterleave(diff, ref, max) {
    if ( !ref ) {
        return diff
    }
    if ( ref >= (max - 1) ) {
        return max - diff - 1
    }
    if ( 2 * ref < max ) {
        if ( diff <= 2 * ref ) {
            if ( diff & 1 ) {
                return ref + ((diff + 1) >> 1)
            } else {
                return ref - (diff >> 1)
            }
        }
        return diff
    } else {
        if ( diff <= 2 * (max - ref - 1) ) {
            if ( diff & 1 ) {
                return ref + ((diff + 1) >> 1)
            } else {
                return ref - (diff >> 1)
            }
        }
        return max - (diff + 1)
    }
}

5.20.5.9. Skip mode syntax

where is_comp_ref_allowed is a function that checks the block size as follows:

is_comp_ref_allowed( ) {
    w = Block_Width[ MiSize ]
    h = Block_Height[ MiSize ]
    return ( Min( w, h ) >= 8 ) || is_thin_4xn_nx4_block()
}

5.20.5.10. Skip syntax

5.20.5.11. Quantizer index delta syntax

5.20.5.12. Segmentation feature active function

seg_feature_active_idx( idx, feature ) {
    return segmentation_enabled && FeatureEnabled[ idx ][ feature ]
}

seg_feature_active( feature ) {
    return seg_feature_active_idx( segment_id, feature )
}

5.20.6. Transform and quantization structures

5.20.6.1. TX size syntax

Note: The same transform partition is used for all chunks when read_tx_size is called.

5.20.6.2. Block TX size syntax

5.20.6.3. Read TX partition syntax

where the function find_tx_size finds the transform block size for the given dimensions and is defined as:

find_tx_size( w, h ) {
    for ( txSz = 0; txSz < TX_SIZES_ALL; txSz++ ) {
        if ( Tx_Width[ txSz ] == w && Tx_Height[ txSz ] == h ) {
            return txSz
        }
    }
    return TX_INVALID
}

and the function set_tx_size saves the transform size as follows:

set_tx_size(row, col, h4, w4, mid, scanOrder) {
    subTxSz = find_tx_size( w4 << 2, h4 << 2 )
    for ( i = 0; i < h4; i++ ) {
        for ( j = 0; j < w4; j++ ) {
            LumaTxSizes[ row + i ][ col + j ] = subTxSz
            LumaTxMiddle[ row + i ][ col + j ] = mid
            LumaTxScanOrder[ row + i ][ col + j ] = scanOrder
        }
    }
    return subTxSz
}

5.20.7. Motion vector and prediction structures

5.20.7.1. Inter frame mode info syntax

5.20.7.2. Inter segment ID syntax

This is called before (preSkip equal to 1) and after (preSkip equal to 0) the skip_flag syntax element has been read.

5.20.7.3. Is inter syntax

5.20.7.4. Get segment ID function

The predicted segment id is the smallest value found in the on-screen region of the segmentation map covered by the current block.

get_segment_id( ) {
    bw4 = Num_4x4_Blocks_Wide[ MiSize ]
    bh4 = Num_4x4_Blocks_High[ MiSize ]
    xMis = Min( MiCols - MiCol, bw4 )
    yMis = Min( MiRows - MiRow, bh4 )
    seg = MAX_SEGMENTS - 1
    for ( y = 0; y < yMis; y++ ) {
        for ( x = 0; x < xMis; x++ ) {
            seg = Min( seg, PrevSegmentIds[ MiRow + y ][ MiCol + x ] )
        }
    }
    return seg
}

5.20.7.5. Intra block mode info syntax

5.20.7.6. Inter block mode info syntax

The function has_nearmv is defined as:

has_nearmv( mode ) {
    return (mode == NEARMV || mode == NEAR_NEARMV
            || mode == NEAR_NEWMV || mode == NEW_NEARMV)
}

The function has_newmv is defined as:

has_newmv( mode ) {
    return (mode == NEWMV ||
            mode == NEW_NEWMV ||
            mode == NEAR_NEWMV ||
            mode == NEW_NEARMV ||
            mode == WARP_NEWMV ||
            mode == JOINT_NEWMV
            )
}

The function needs_interp_filter is defined as:

needs_interp_filter( ) {
    large = (Min(Block_Width[ MiSize ], Block_Height[ MiSize ]) >= 8)
    if ( motion_mode >= LOCALWARP ) {
        return 0
    } else if ( large && YMode == GLOBALMV ) {
        return 0
    } else if ( large && YMode == GLOBAL_GLOBALMV ) {
        return 0
    } else {
        return 1
    }
}

The function is_inter_ref_frame is defined as:

is_inter_ref_frame(ref) {
    return ref != INTRA_FRAME && ref != NONE
}

The function is_joint_mvd_coding_mode is defined as:

is_joint_mvd_coding_mode(mode) {
    return mode == JOINT_NEWMV
}

The function has_second_drl is defined as:

has_second_drl(mode) {
    return (mode == NEAR_NEARMV || mode == NEAR_NEWMV) && !skip_mode &&
           !use_optflow
}

Note: Two reference lists can be used for NEAR_NEWMV, but only one for NEW_NEARMV.

The constant table Cwp_Weighting_Factor is defined as:

Cwp_Weighting_Factor[ 2 ][ MAX_CWP_NUM ] = {
    { 8, 12, 4, 10, 6 },
    { 8, 12, 4, 20, -4 }
}

The function opfl_allowed_for_refs is defined as:

opfl_allowed_for_refs( refFrames ) {
    if ( FrameType == SWITCH_FRAME ||
         is_scaled( refFrames[ 0 ], 1 ) || 
         is_scaled( refFrames[ 1 ], 1 ) ) {
        return 0
    }
    d0 = get_relative_dist( OrderHint, OrderHints[ refFrames[ 0 ] ] )
    d1 = get_relative_dist( OrderHint, OrderHints[ refFrames[ 1 ] ] )
    return (d0 <= 0) ^ (d1 <= 0)
}

The constant table Tip_Pred_Index_To_Mode is defined as:

Tip_Pred_Index_To_Mode[ 2 ] = {
    NEARMV,
    NEWMV
}

The function allow_amvd_mode is defined as:

allow_amvd_mode( mode ) {
    return enable_adaptive_mvd &&
        (mode == NEWMV ||
         mode == NEW_NEWMV ||
         mode == NEAR_NEWMV ||
         mode == NEW_NEARMV ||
         mode == JOINT_NEWMV)
}

5.20.7.7. Read warp delta syntax

where the function read_warp_delta_param is specified as:

read_warp_delta_param( idx, highPrec ) {
    S() warp_delta_param_low;
    v = warp_delta_param_low
    if ( highPrec && v == WARP_DELTA_NUM_SYMBOLS_LOW - 1 ) {
        S() warp_delta_param_high;
        v += warp_delta_param_high
    }
    if ( v != 0 ) {
        S() warp_delta_param_sign;
        if ( warp_delta_param_sign ) {
            v = -v
        }
    }
    return v << ( WARP_DELTA_STEP_BITS + 1 - highPrec )
}

5.20.7.8. Read drl idx syntax

5.20.7.9. DIP mode info syntax

5.20.7.10. Ref frames syntax

where skip_mode_frames is specified as:

skip_mode_frames() {
    for ( n = 0; n < NNumBuf; n++ ) {
        if ( NRefFrame[ n ][ 0 ] == TIP_FRAME ) {
            return ( Min(ClosestPast, ClosestFuture),
                     Max(ClosestPast, ClosestFuture) )
        }
        if ( is_inter_ref_frame( NRefFrame[ n ][ 0 ] ) &&
             is_inter_ref_frame( NRefFrame[ n ][ 1 ] ) ) {
            return (NRefFrame[ n ][ 0 ], NRefFrame[ n ][ 1 ])
        }
        if ( is_inter_ref_frame( NRefFrame[ n ][ 0 ] ) ) {
            break
        }
    }
    return (SkipModeFrame[ 0 ], SkipModeFrame[ 1 ])
}

5.20.7.11. Read compound ref syntax

5.20.7.12. Read single ref syntax

5.20.7.13. Assign MV syntax

where the function is_same_side is defined as:

is_same_side() {
    return ( FrameDistance[ RefFrame[ 0 ] ] < 0 &&
             FrameDistance[ RefFrame[ 1 ] ] < 0) ||
           ( FrameDistance[ RefFrame[ 0 ] ] > 0 &&
             FrameDistance[ RefFrame[ 1 ] ] > 0)
}

and the function is_mvd_sign_derive_allowed is defined as:

is_mvd_sign_derive_allowed(isCompound) {
    if ( use_intrabc ||
         !enable_mvd_sign_derive ||
         motion_mode != SIMPLE ||
         IsAdaptiveMvd || skip_mode ||
         allow_screen_content_tools ||
         FrameMvPrecision > MV_PRECISION_QUARTER_PEL ||
         MvPrecision >= MV_PRECISION_QUARTER_PEL ||
         has_nearmv(YMode) ) {
        return 0
    }
    if ( isCompound ) {
        return RefMvIdx == 0
    } else {
        return 1
    }
}

and the function lower_mv_precision (which modifies the contents of the input motion vector to the target precision) is defined as:

lower_mv_precision( precision, candMv ) {
    bits = MV_PRECISION_EIGHTH_PEL - precision
    radix = 1 << bits
    for ( i = 0; i < 2; i++ ) {
        a = Abs( candMv[ i ] )
        aInt = Round2( a - 1, bits )
        if ( candMv[ i ] >= 0 ) {
            candMv[ i ] = aInt << bits
        } else {
            candMv[ i ] = (-aInt) << bits
        }
        if ((aInt << bits) != a) {
            candMv[ i ] = Clip3( MV_LOW + radix, MV_UPP - radix, candMv[ i ] )
        }
    }
}

and the function mv_clamp_to_integer (which adjusts a motion vector component to an integer location if it would have overflowed the allowed range) is defined as:

mv_clamp_to_integer( v ) {
    if ( v < MV_LOW + 1 ) {
        return MV_LOW + 8
    } else if ( v > MV_UPP - 1 ) {
        return MV_UPP - 8
    } else {
        return v
    }
}

5.20.7.14. Read motion mode syntax

The function motion_mode_allowed works out the allowed motion modes as follows:

motion_mode_allowed(isCompound) {
    for ( i = 0; i < MOTION_MODES; i++ ) {
        AllowedMotionModes[ i ] = 0
    }
    if ( YMode == WARPMV ) {
        AllowedMotionModes[ DELTAWARP ] = 1
        return
    }
    if ( YMode == WARP_NEWMV ) {
        AllowedMotionModes[ LOCALWARP ] =  WarpSampleFound[ 0 ]
        AllowedMotionModes[ EXTENDWARP ] = WarpSampleFound[ 0 ]
        AllowedMotionModes[ DELTAWARP ] = 1
        return
    }
    if ( skip_mode || RefFrame[ 0 ] == INTRA_FRAME || use_bawp ||
         RefFrame[ 0 ] == TIP_FRAME ||
         seg_feature_active(SEG_LVL_SKIP) || 
         seg_feature_active(SEG_LVL_GLOBALMV) ||
         ( isCompound && is_thin_4xn_nx4_block() ) ) {
        return
    }
    AllowedMotionModes[ INTERINTRA ] = (!isCompound && 
                                        MiSize >= BLOCK_8X8 && 
                                        Block_Width[ MiSize ] <= 64 &&
                                        Block_Height[ MiSize ] <= 64)
    if ( RefFrame[ 0 ] == RefFrame[ 1 ] ) {
        return
    }
    if ( !force_integer_mv &&
         ( YMode == GLOBALMV || YMode == GLOBAL_GLOBALMV ) &&
         GmType[ RefFrame[ 0 ] ] > IDENTITY ) {
        return
    }
    if ( Min( Block_Width[ MiSize ], Block_Height[ MiSize ] ) < 8 ) {
        return
    }
    AllowedMotionModes[ LOCALWARP ] = !force_integer_mv && YMode == NEW_NEWMV &&
                                    !use_optflow &&
                                    opfl_refine_type != REFINE_ALL &&
                                    WarpSampleFound[ 0 ] &&
                                    WarpSampleFound[ 1 ]
}

where is_scaled is a function that determines whether a reference frame uses scaling and is specified as:

is_scaled( refFrame, checkRestricted ) {
    if ( checkRestricted && OrderHints[ refFrame ] == RESTRICTED_OH ) {
        return 1
    }
    refIdx = ref_frame_idx[ refFrame ]
    xScale = ( ( RefFrameWidth[ refIdx ] << REF_SCALE_SHIFT ) +
                 ( FrameWidth / 2 ) ) / FrameWidth
    yScale = ( ( RefFrameHeight[ refIdx ] << REF_SCALE_SHIFT ) +
                 ( FrameHeight / 2 ) ) / FrameHeight
    noScale = 1 << REF_SCALE_SHIFT
    return xScale != noScale || yScale != noScale
}

and is_thin_4xn_nx4_block is a function that tests the block size as follows:

is_thin_4xn_nx4_block( ) {
    w = Block_Width[ MiSize ]
    h = Block_Height[ MiSize ]
    return (w == 4 && h >= 16) || (h == 4 && w >= 16)
}

5.20.7.15. Read inter intra syntax

5.20.7.16. Read compound type syntax

5.20.7.17. Read refine mv syntax

where the functions is_refinemv_allowed_mode, is_switchable_refinemv, is_refinemv_allowed_reference are specified as:

is_refinemv_allowed_mode() {
    if ( skip_mode || YMode == GLOBAL_GLOBALMV || motion_mode != SIMPLE ) {
        return 0
    }
    if ( opfl_refine_type == REFINE_SWITCHABLE &&
         has_newmv( YMode ) &&
         !use_optflow ) {
        return 0
    }
    return 1
}

is_switchable_refinemv() {
    if ( YMode == NEAR_NEARMV || 
         (YMode == JOINT_NEWMV && use_optflow &&
             opfl_refine_type == REFINE_SWITCHABLE)) {
        return 0
    }
    return 1
}

is_refinemv_allowed_reference( refFrames ) {
    if ( FrameType == SWITCH_FRAME ||
         is_scaled( refFrames[ 0 ], 1 ) || 
         is_scaled( refFrames[ 1 ], 1 ) ) {
        return 0
    }
    d0 = get_relative_dist( OrderHint, OrderHints[ refFrames[ 0 ] ] )
    d1 = get_relative_dist( OrderHint, OrderHints[ refFrames[ 1 ] ] )
    return d0 != 0 && d0 == -d1
}

5.20.7.18. Read wedge mode syntax

where the lookup table Wedge_Angle_Dist_2_Index is specified as:

Wedge_Angle_Dist_2_Index[ WEDGE_ANGLES ][ NUM_WEDGE_DIST ] = {
    { -1, 0, 1, 2 },
    { 3, 4, 5, 6 },
    { 7, 8, 9, 10 },
    { 11, 12, 13, 14 },
    { 15, 16, 17, 18 },
    { -1, 19, 20, 21 },
    { 22, 23, 24, 25 },
    { 26, 27, 28, 29 },
    { 30, 31, 32, 33 },
    { 34, 35, 36, 37 },
    { -1, 38, 39, 40 },
    { -1, 41, 42, 43 },
    { -1, 44, 45, 46 },
    { -1, 47, 48, 49 },
    { -1, 50, 51, 52 },
    { -1, 53, 54, 55 },
    { -1, 56, 57, 58 },
    { -1, 59, 60, 61 },
    { -1, 62, 63, 64 },
    { -1, 65, 66, 67 }
}

5.20.7.19. Get mode function

get_mode( refList, baseList ) {
    if ( YMode == JOINT_NEWMV ) {
        if ( refList == baseList ) {
            compMode = NEWMV
        } else {
            compMode = NEARMV
        }
    } else if ( refList == 0 ) {
        if ( YMode == NEW_NEWMV || YMode == NEW_NEARMV ) {
            compMode = NEWMV
        } else if ( YMode < NEAR_NEARMV ) {
            compMode = YMode
        } else if ( YMode == NEAR_NEARMV || YMode == NEAR_NEWMV ) {
            compMode = NEARMV
        } else {
            compMode = GLOBALMV
        }
    } else {
        if ( YMode == NEW_NEWMV || YMode == NEAR_NEWMV ) {
            compMode = NEWMV
        } else if ( YMode == NEAR_NEARMV || YMode == NEW_NEARMV ) {
            compMode = NEARMV
        } else {
            compMode = GLOBALMV
        }
    }
    return compMode
}

5.20.7.20. MV syntax

5.20.7.21. MV component syntax

where the constant table Amvd_Index_To_Mvd is defined as:

Amvd_Index_To_Mvd[ MAX_AMVD_INDEX ] = { 
    2, 4, 6, 8, 16, 32, 64, 128 
}

5.20.7.22. Compute prediction syntax

5.20.7.23. Residual syntax

5.20.7.24. Transform block syntax

The function store_tx_info is defined as:

store_tx_info(plane, row, col, txSz, eob, doParse, doPred) {
    subX = (plane > 0) ? SubsamplingX : 0
    subY = (plane > 0) ? SubsamplingY : 0
    sbMask = Num_4x4_Blocks_Wide[ SbSize ] - 1
    subBlockMiRow = row & sbMask
    subBlockMiCol = col & sbMask
    stepX = Tx_Width[ txSz ] >> MI_SIZE_LOG2
    stepY = Tx_Height[ txSz ] >> MI_SIZE_LOG2
    for ( i = 0; i < stepY; i++ ) {
        for ( j = 0; j < stepX; j++ ) {
            if ( doParse ) {
                if ( plane == 0 ) {
                    LrTxSkip[ row + i ][ col + j ] = skip_flag || (eob == 0)
                }
                DeblockingTxSizes[ plane ]
                                    [ (row >> subY) + i ]
                                    [ (col >> subX) + j ] = txSz
                TxColBase[ plane ]
                            [ (row >> subY) + i ]
                            [ (col >> subX) + j ] = col
                TxRowBase[ plane ]
                            [ (row >> subY) + i ]
                            [ (col >> subX) + j ] = row
            }
            if ( doPred ) {
                BlockDecoded[ plane ]
                            [ ( subBlockMiRow >> subY ) + i ]
                            [ ( subBlockMiCol >> subX ) + j ] = 1
            }
        }
    }
}

The function make_intra_prediction (which calls intra prediction processes) is defined as:

make_intra_prediction(plane, startX, startY, txSz, x, y, allowCorners) {
    if ( !is_inter ) {
        stepX = Tx_Width[ txSz ] >> MI_SIZE_LOG2
        stepY = Tx_Height[ txSz ] >> MI_SIZE_LOG2
        subX = (plane > 0) ? SubsamplingX : 0
        subY = (plane > 0) ? SubsamplingY : 0
        row = ( startY << subY ) >> MI_SIZE_LOG2
        col = ( startX << subX ) >> MI_SIZE_LOG2
        sbMask = Num_4x4_Blocks_Wide[ SbSize ] - 1
        subBlockMiRow = row & sbMask
        subBlockMiCol = col & sbMask
        if ( plane == 0 && PaletteSizeY ) {
            predict_palette( startX, startY, x, y, txSz )
        } else {
            isCfl = ( plane > 0 && UVMode == UV_CFL_PRED )
            if ( plane == 0 ) {
                mode = YMode
            } else {
                mode = ( isCfl ) ? DC_PRED : UVMode
            }
            log2W = Tx_Width_Log2[ txSz ]
            log2H = Tx_Height_Log2[ txSz ]
            predict_intra( plane, startX, startY,
                            ( plane == 0 ? AvailL : AvailLChroma ) || x > 0,
                            ( plane == 0 ? AvailU : AvailUChroma ) || y > 0,
                            allowCorners ? count_top_right_avail( plane,
                                               ( subBlockMiCol >> subX ), 
                                               ( subBlockMiRow >> subY ),
                                               stepX) : 0,
                            allowCorners ? count_bottom_left_avail( plane,
                                               ( subBlockMiCol >> subX ),
                                               ( subBlockMiRow >> subY ),
                                               stepY) : 0,
                            mode,
                            log2W, log2H )
            if ( isCfl ) {
                predict_chroma_from_luma( plane, startX, startY, txSz )
            }
        }
    }
}

The functions count_top_right_avail and count_bottom_left_avail (which count how many samples have already been decoded in the corners) are defined as:

count_top_right_avail(plane, x4, y4, w4) {
    numTopRight = 0
    for ( i = 0; i < w4; i++ ) {
        if ( BlockDecoded[ plane ][ y4 - 1 ][ x4 + w4 + i ] ) {
            numTopRight = i + 1
        } else {
            break
        }
    }
    return numTopRight
}

count_bottom_left_avail(plane, x4, y4, h4) {
    numBottomLeft = 0
    for ( i = 0; i < h4; i++ ) {
        if ( BlockDecoded[ plane ][ y4 + h4 + i ][ x4 - 1 ] ) {
            numBottomLeft = i + 1
        } else {
            break
        }
    }
    return numBottomLeft
}

5.20.7.25. Get TX size function

get_tx_size( plane, txSz ) {
    if ( plane == 0 ) {
        return txSz
    }
    uvTx = Max_Tx_Size_Rect[ get_plane_residual_size( ChromaMiSize, plane ) ]
    return uvTx
}

5.20.7.26. Get plane residual size function

The get_plane_residual_size function returns the size of a residual block for the specified plane. (The residual block will always have width and height at least equal to 4.)

get_plane_residual_size( subsize, plane ) {
    subx = plane > 0 ? SubsamplingX : 0
    suby = plane > 0 ? SubsamplingY : 0
    return Subsampled_Size[ subsize ][ subx ][ suby ]
}

The Subsampled_Size table is defined as:

Subsampled_Size[ BLOCK_SIZES ][ 2 ][ 2 ] = {
  { { BLOCK_4X4,    BLOCK_4X4},      {BLOCK_4X4,     BLOCK_4X4} },
  { { BLOCK_4X8,    BLOCK_4X4},      {BLOCK_INVALID, BLOCK_4X4} },
  { { BLOCK_8X4,    BLOCK_INVALID},  {BLOCK_4X4,     BLOCK_4X4} },
  { { BLOCK_8X8,    BLOCK_8X4},      {BLOCK_4X8,     BLOCK_4X4} },
  { {BLOCK_8X16,    BLOCK_8X8},      {BLOCK_4X16,    BLOCK_4X8} },
  { {BLOCK_16X8,    BLOCK_16X4},     {BLOCK_8X8,     BLOCK_8X4} },
  { {BLOCK_16X16,   BLOCK_16X8},     {BLOCK_8X16,    BLOCK_8X8} },
  { {BLOCK_16X32,   BLOCK_16X16},    {BLOCK_8X32,    BLOCK_8X16} },
  { {BLOCK_32X16,   BLOCK_32X8},     {BLOCK_16X16,   BLOCK_16X8} },
  { {BLOCK_32X32,   BLOCK_32X16},    {BLOCK_16X32,   BLOCK_16X16} },
  { {BLOCK_32X64,   BLOCK_32X32},    {BLOCK_16X64,   BLOCK_16X32} },
  { {BLOCK_64X32,   BLOCK_64X16},    {BLOCK_32X32,   BLOCK_32X16} },
  { {BLOCK_64X64,   BLOCK_64X32},    {BLOCK_32X64,   BLOCK_32X32} },
  { {BLOCK_64X128,  BLOCK_64X64},    {BLOCK_INVALID, BLOCK_32X64} },
  { {BLOCK_128X64,  BLOCK_INVALID},  {BLOCK_64X64,   BLOCK_64X32} },
  { {BLOCK_128X128, BLOCK_128X64},   {BLOCK_64X128,  BLOCK_64X64} },
  { {BLOCK_128X256, BLOCK_128X128 }, {BLOCK_INVALID, BLOCK_64X128 } },
  { {BLOCK_256X128, BLOCK_INVALID }, {BLOCK_128X128, BLOCK_128X64 } },
  { {BLOCK_256X256, BLOCK_256X128 }, {BLOCK_128X256, BLOCK_128X128 } },
  { {BLOCK_4X16,    BLOCK_4X8},      {BLOCK_INVALID, BLOCK_4X8} },
  { {BLOCK_16X4,    BLOCK_INVALID},  {BLOCK_8X4,     BLOCK_8X4} },
  { {BLOCK_8X32,    BLOCK_8X16 },    { BLOCK_4X32,   BLOCK_4X16 } },
  { {BLOCK_32X8,    BLOCK_32X4 },    { BLOCK_16X8,   BLOCK_16X4 } },
  { {BLOCK_16X64,   BLOCK_16X32 },   { BLOCK_8X64,   BLOCK_8X32 } },
  { {BLOCK_64X16,   BLOCK_64X8 },    { BLOCK_32X16,  BLOCK_32X8 } },
  { {BLOCK_4X32,    BLOCK_4X16},     { BLOCK_INVALID,BLOCK_4X16 } },
  { {BLOCK_32X4,    BLOCK_INVALID }, { BLOCK_16X4,   BLOCK_16X4 } },
  { {BLOCK_8X64,    BLOCK_8X32 },    { BLOCK_INVALID,BLOCK_4X32 } },
  { {BLOCK_64X8,    BLOCK_INVALID }, { BLOCK_32X8,   BLOCK_32X4 } }
}

5.20.7.27. Coefficients syntax

where get_tx_row_col (which extracts the row and column for a position in raster order) is defined as:

get_tx_row_col(pos, txSz) {
    adjTxSz = Adjusted_Tx_Size[ txSz ]
    bwl = Tx_Width_Log2[ adjTxSz ]
    row = pos >> bwl
    col = pos - (row << bwl)
    return (row, col)
}

and get_lf_limits (which determines if this is a low frequency coefficient) is defined as:

get_lf_limits(row, col, txClass, plane) {
    if ( txClass == TX_CLASS_2D ) {
        return plane == 0 ? ((row + col) < 4) : ((row + col) < 1)
    } else if ( txClass == TX_CLASS_HORIZ ) {
        return plane == 0 ? (col < 2) : (col < 1)
    } else {
        return plane == 0 ? (row < 2) : (row < 1)
    }
}

and is_cctx_allowed is defined as:

and Tcq_Next_State (which updates the TCQ state based on the current state and parity) is defined as:

Tcq_Next_State[ 8 ][ 2 ] = {
    {0, 4},
    {4, 0},
    {1, 5},
    {5, 1},
    {6, 2},
    {2, 6},
    {7, 3},
    {3, 7}
}

5.20.7.28. Read quantized coefficient syntax

5.20.7.29. Compute transform type function

compute_tx_type( plane, txSz, blockX, blockY ) {
    if ( Lossless && plane == 0 && fsc_mode ) {
        return IDTX
    }
    if ( Lossless ) {
        if ( !is_inter ) {
            fscMode = PlaneStart == 0 ? fsc_mode :
                                        FscModes[ ChromaMiRow ][ ChromaMiCol ]
            if ( fscMode ) {
                return IDTX
            } else {
                return DCT_DCT
            }
        }
        if ( is_inter && txSz != TX_4X4 ) {
            return IDTX
        }
        if ( plane > 0 ) {
            x4 = Max( MiCol, blockX << SubsamplingX )
            y4 = Max( MiRow, blockY << SubsamplingY )
            if ( is_inter && LumaTxSizes[ y4 ][ x4 ] != TX_4X4 ) {
                return IDTX
            }
            if ( !FrameIsIntra &&
                 MiRow == ChromaMiRow && MiCol == ChromaMiCol ) {
                return TxTypes[ y4 ][ x4 ]
            }
            return TxTypes[ MiRow ][ MiCol ]
        }
    }
    txSet = get_tx_set( txSz, plane )
    if ( plane == 0 ) {
        return TxTypes[ blockY ][ blockX ]
    }
    if ( enable_chroma_dctonly ) {
        return DCT_DCT
    }
    if ( is_inter ) {
        x4 = Max( MiCol, blockX << SubsamplingX )
        y4 = Max( MiRow, blockY << SubsamplingY )
        txType = TxTypes[ y4 ][ x4 ]
        if ( !is_tx_type_in_set( txSet, txType ) ) {
            return DCT_DCT
        }
        return txType
    }
    if ( is_directional_mode( UVMode ) ) {
        pAngle = Mode_To_Angle[ UVMode ] + AngleDeltaUV * ANGLE_STEP
        (mode, unusedAngle) = wide_angle_mapping( UVMode, Tx_Width[ txSz ],
                                                  Tx_Height[ txSz ], pAngle )
        txType = Mode_To_Txfm[ mode ]
    } else {
        txType = Mode_To_Txfm[ UVMode ]
    }
    if ( !is_tx_type_in_set( txSet, txType ) ) {
        return DCT_DCT
    }
    return txType
}

is_tx_type_in_set( txSet, txType ) {
    return is_inter ? Tx_Type_In_Set_Inter[ txSet ][ txType ] :
                      Tx_Type_In_Set_Intra[ txSet ][ txType ]
}

where the tables Tx_Type_In_Set_Inter and Tx_Type_In_Set_Intra are specified as follows:

Tx_Type_In_Set_Intra[ TX_SET_TYPES_INTRA ][ TX_TYPES ] = {
  {
    1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  },
  { 
    1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 
  },
  { 
    1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0
  }, 
  { 
    1, 1, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0
  },
  { 
    1, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1
  },
  {
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  },
  {
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  }
}

Tx_Type_In_Set_Inter[ TX_SET_TYPES_INTER ][ TX_TYPES ] = {
  {
    1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
  },
  { 
    1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0
  },
  { 
    1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0
  },
  {
    1, 1, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0
  },
  {
    1, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1
  },
  {
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
  },
  {
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0
  },
  {
    1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0
  },
  {
    1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0
  }
}

The function wide_angle_mapping is defined as:

wide_angle_mapping(mode, w, h, pAngle) {
    if ((h == 2 * w && pAngle < WAIP_WH_RATIO_2_THRES) ||
        (h == 4 * w && pAngle < WAIP_WH_RATIO_4_THRES) ||
        (h == 8 * w && pAngle < WAIP_WH_RATIO_8_THRES) ||
        (h == 16 * w && pAngle < WAIP_WH_RATIO_16_THRES)) {
        return (D203_PRED,180 + pAngle)
    } else if ((w == 2 * h && pAngle > 270 - WAIP_WH_RATIO_2_THRES) ||
            (w == 4 * h && pAngle > 270 - WAIP_WH_RATIO_4_THRES) ||
            (w == 8 * h && pAngle > 270 - WAIP_WH_RATIO_8_THRES) ||
            (w == 16 * h &&
            pAngle > 270 - WAIP_WH_RATIO_16_THRES)) {
        return (D45_PRED, pAngle - 180)
    }
    return (mode,pAngle)
}

5.20.7.30. Get scan function

get_scan( txSz, txClass ) {
    w = Min( Tx_Width[ txSz ], 32)
    h = Min( Tx_Height[ txSz ], 32)
    if ( txClass == TX_CLASS_VERT ) {
        c = 0
        for ( y = 0; y < h; y++ ) {
            for ( x = 0; x < w; x++ ) {
                out[ c ] = y * w + x
                c += 1
            }
        }
    } else if ( txClass == TX_CLASS_HORIZ ) {
        c = 0
        for ( x = 0; x < w; x++ ) {
            for ( y = 0; y < h; y++ ) {
                out[ c ] = y * w + x
                c += 1
            }
        }
    } else {
        x = 0
        y = 0
        for ( c = 0; c < w*h; c++ ) {
            out[ c ] = y * w + x
            x += 1
            y -= 1
            if ( y < 0 || x >= w ) {
                x += 1
                s = Min(x,h - 1 - y)
                x -= s
                y += s
            }
        }
    }
    return out
}

5.20.7.31. Is directional mode function

is_directional_mode( mode ) {
    if ( ( mode >= V_PRED ) && ( mode <= D67_PRED ) ) {
        return 1
    }
    return 0
}

5.20.7.32. Read CFL alphas syntax

5.20.8. Coding tools structures

5.20.8.1. Palette mode info syntax

The function sort( arr, i1, i2 ) sorts a subarray of the array arr in-place into ascending order. The subarray to be sorted is between indices i1 and i2 inclusive.

The function get_palette_cache, which merges the above and left palettes to form a cache, is specified as follows:

get_palette_cache( ) {
    r = MiRow
    c = MiCol
    aboveN = 0
    if ( ( r * MI_SIZE ) % 64 ) {
        aboveN = PaletteSizes[ r - 1 ][ c ]
    }
    leftN = 0
    if ( AvailL ) {
        leftN = PaletteSizes[ r ][ c - 1 ]
    }
    aboveIdx = 0
    leftIdx = 0
    n = 0
    while ( aboveIdx < aboveN || leftIdx < leftN ) {
        if ( aboveIdx < aboveN ) {
            val = PaletteColors[ r - 1 ][ c ][ aboveIdx ]
            aboveIdx++
            PaletteCache[ n ] = val
            n++
        }
        if ( leftIdx < leftN ) {
            val = PaletteColors[ r ][ c - 1 ][ leftIdx ]
            leftIdx++
            PaletteCache[ n ] = val
            n++
        }
    }
    return n
}

Note: get_palette_cache interleaves the available palette colors from above and left together.

5.20.8.2. Transform type syntax

where the inversion tables used in the function are specified as follows:

Tx_Type_Inter_Inv_Set1[ 16 ] = {
    IDTX, V_DCT, H_DCT, V_ADST, H_ADST, V_FLIPADST, H_FLIPADST,
    DCT_DCT, ADST_DCT, DCT_ADST, FLIPADST_DCT, DCT_FLIPADST, ADST_ADST,
    FLIPADST_FLIPADST, ADST_FLIPADST, FLIPADST_ADST
}

Tx_Type_Inter_Inv_Set2[ 12 ] = {
    IDTX, V_DCT, H_DCT, DCT_DCT, ADST_DCT, DCT_ADST, FLIPADST_DCT,
    DCT_FLIPADST, ADST_ADST, FLIPADST_FLIPADST, ADST_FLIPADST,
    FLIPADST_ADST
}

Tx_Type_Inter_Inv_Set3[ 2 ]  = { IDTX, DCT_DCT }

Tx_Type_Inter_Inv_Set4[ 4 ]  = { DCT_DCT, V_DCT, H_DCT, IDTX }

Tx_Type_Inv_Long[ 2 ][ 2 ][ 4 ] = {
    {
        { V_DCT, V_ADST, V_FLIPADST, IDTX },
        { H_DCT, H_ADST, H_FLIPADST, IDTX },
    },
    {
        { DCT_DCT, ADST_DCT, FLIPADST_DCT, H_DCT },
        { DCT_DCT, DCT_ADST, DCT_FLIPADST, V_DCT },
    }
}

5.20.8.3. Get transform set function

get_tx_set( txSz, plane ) {
    txSzSqr = Tx_Size_Sqr[ txSz ]
    txSzSqrUp = Tx_Size_Sqr_Up[ txSz ]
    if ( txSzSqrUp > TX_32X32 ) {
        if ( txSzSqr >= TX_32X32 ) {
            return TX_SET_DCTONLY
        }
        return (Tx_Width[ txSz ] > Tx_Height[ txSz ]) ? TX_SET_WIDE_64 :
                                                    TX_SET_HIGH_64
    }
    if ( txSzSqrUp == TX_32X32 && txSzSqr != TX_32X32 ) {
        return (Tx_Width[ txSz ] > Tx_Height[ txSz ]) ? TX_SET_WIDE_32 :
                                                    TX_SET_HIGH_32
    }
    if (!is_inter && txSzSqrUp == TX_32X32) {
        return TX_SET_DCTONLY
    }
    reducedTxSet = plane == 0 ? reduced_tx_set : enable_chroma_dctonly
    if ( txSzSqrUp == TX_32X32 || reducedTxSet == 1 ) {
        return is_inter ? TX_SET_DCT_IDTX : TX_SET_INTRA_2
    } else if ( reducedTxSet == 2 ) {
        return TX_SET_DCT_IDTX
    } else if ( reducedTxSet == 3 ) {
        return is_inter ? TX_SET_DCT_IDTX_IDDCT : TX_SET_INTRA_2
    }
    if ( is_inter ) {
        return ( txSzSqr == TX_16X16 ) ? TX_SET_INTER_2 : TX_SET_INTER_1
    }
    return TX_SET_INTRA_1
}

5.20.8.4. Palette tokens syntax

5.20.8.5. Palette color context function

get_palette_color_context( colorMap, r, c, n ) {
    for ( i = 0; i < PALETTE_COLORS; i++ ) {
        scores[ i ] = 0
        ColorOrder[ i ] = i
    }
    if ( c > 0 ) {
        neighbor = colorMap[ r ][ c - 1 ]
        scores[ neighbor ] += 2
    }
    if ( ( r > 0 ) && ( c > 0 ) ) {
        neighbor = colorMap[ r - 1 ][ c - 1 ]
        scores[ neighbor ] += 1
    }
    if ( r > 0 ) {
        neighbor = colorMap[ r - 1 ][ c ]
        scores[ neighbor ] += 2
    }
    for ( i = 0; i < PALETTE_NUM_NEIGHBORS; i++ ) {
        maxScore = scores[ i ]
        maxIdx = i
        for ( j = i + 1; j < n; j++ ) {
            if ( scores[ j ] > maxScore ) {
                maxScore = scores[ j ]
                maxIdx = j
            } else if ( scores[ j ] > 0 && scores[ j ] == maxScore &&
                        c > 0 && j == colorMap[ r ][ c - 1 ] ) {
                maxScore = scores[ j ]
                maxIdx = j
            }
        }
        if ( maxIdx != i ) {
            maxScore = scores[ maxIdx ]
            maxColorOrder = ColorOrder[ maxIdx ]
            for ( k = maxIdx; k > i; k-- ) {
                scores[ k ] = scores[ k - 1 ]
                ColorOrder[ k ] = ColorOrder[ k - 1 ]
            }
            scores[ i ] = maxScore
            ColorOrder[ i ] = maxColorOrder
        }
    }
    ColorContextHash = 0
    for ( i = 0; i < PALETTE_NUM_NEIGHBORS; i++ ) {
        ColorContextHash += scores[ i ] * Palette_Color_Hash_Multipliers[ i ]
    }
}

Note: The reference software has an alternative implementation that may be better suited for hardware implementations.

5.20.9. Helper functions

5.20.9.1. Is inside function

is_inside determines whether a candidate position is inside the current tile.

is_inside( candidateR, candidateC ) {
    return ( candidateC >= MiColStart &&
             candidateC < MiColEnd &&
             candidateR >= MiRowStart &&
             candidateR < MiRowEnd )
}

5.20.9.2. Is inside frame function

is_inside_frame determines whether a candidate position is inside the current frame.

is_inside_frame( candidateR, candidateC ) {
    return ( candidateC >= 0 &&
            candidateC < MiCols &&
            candidateR >= 0 &&
            candidateR < MiRows )
}

5.20.9.3. Is inside filter region function

is_inside_filter_region determines whether a candidate position is inside the region that is being used for CDEF and restoration filtering.

is_inside_filter_region( candidateR, candidateC ) {
    if ( disable_loopfilters_across_tiles ) {
        return is_inside( candidateR, candidateC )
    } else {
        return is_inside_frame( candidateR, candidateC )
    }
}

5.20.9.4. Clamp MV row function

clamp_mv_row( mvec ) {
    bh4 = Num_4x4_Blocks_High[ MiSize ]
    low = -(MiRow + bh4) * MI_SIZE * 8 - MV_BORDER
    high = (MiRows - MiRow) * MI_SIZE * 8 + MV_BORDER
    return Clip3( low, high, mvec )
}

5.20.9.5. Clamp MV col function

clamp_mv_col( mvec ) {
    bw4 = Num_4x4_Blocks_Wide[ MiSize ]
    low = -(MiCol + bw4) * MI_SIZE * 8 - MV_BORDER
    high = (MiCols - MiCol) * MI_SIZE * 8 + MV_BORDER
    return Clip3( low, high, mvec )
}

5.20.9.6. Clear CDEF function

clear_cdef( r, c ) {
    cdef_idx[ r ][ c ] = -1
    num4x4 = Num_4x4_Blocks_Wide[ SbSize ]
    cdefSize4 = Num_4x4_Blocks_Wide[ BLOCK_64X64 ]
    num64x64 = num4x4 / cdefSize4
    for ( i = 0; i < num64x64; i++ ) {
        for ( j = 0; j < num64x64; j++ ) {
            cdef_idx[ r + i * cdefSize4 ][ c + j * cdefSize4 ] = -1
        }
    }
}

5.20.10. Filtering structures

5.20.10.1. Read CDEF syntax

5.20.10.2. Read CCSO syntax

5.20.10.3. Read GDF syntax

5.20.10.4. Read loop restoration syntax

where count_units_in_frame is a function specified as:

count_units_in_frame(unitSize, frameSize) {
    return Max((frameSize + (unitSize >> 1)) / unitSize, 1)
}

5.20.10.5. Read loop restoration unit syntax

5.20.10.6. Read Wiener NS syntax

where decode_signed_4part is a function defined as follows:

decode_signed_4part(low, k, r) {
    rOffset = r - low
    xOffset = decode_unsigned_4part(k, rOffset)
    x = xOffset + low
    return x
}

decode_unsigned_4part(k, r) {
    mx = 1 << k
    v = decode_4part( 6 - k )
    if ((r << 1) <= mx) {
        offset = inverse_recenter(r, v)
    } else {
        offset = mx - 1 - inverse_recenter(mx - 1 - r, v)
    }
    return offset
}

decode_4part(num) {
    S() wiener_ns_base;
    bits = 2 - num + Max(1, wiener_ns_base)
    offset = wiener_ns_base == 0 ? 0 : (1 << bits)
    L(bits) wiener_ns_rem;
    return offset + wiener_ns_rem
}

The function fill_first_slot_of_bank_with_filter_match is specified as:

fill_first_slot_of_bank_with_filter_match( c, plane, m ) {
    WienerNsPtr[ plane ][ c ] = 0
    WienerNsBankSize[ plane ][ c ] = 1
    (numClasses, numRefFilters, matchIdx, matchCls, matchPlane) =
        search_frame_filters( plane, m )
    for( j = 0; j < ( (plane > 0) ? WIENER_NS_CHROMA_COEFFS :
                                    WIENER_NS_LUMA_COEFFS ); j++ ) {
        if ( m == 0 ) {
            v = 0
        } else if ( m < numClasses ) {
            oldCls = m - 1
            v = FrameLrWienerNs[ plane ][ oldCls ][ j ]
        } else if ( m < numClasses + numRefFilters ) {
            v = RefFrameLrWienerNs[ matchIdx ][ matchPlane ][ matchCls ][ j ]
        } else {
            v = get_translated_pc_wiener(m - NumFilterClasses - numRefFilters,j)
        }
        RefLrWienerNs[ plane ][ c ][ 0 ][ j ] = v
    }
}

The function search_frame_filters is specified as:

search_frame_filters( plane, target ) {
    nopcw = lr_tools_disable[ 0 ][ RESTORE_PC_WIENER ]
    minPcWiener = (plane > 0 || nopcw) ? 0 : 16
    numClasses = (plane == 0) ? NumFilterClasses : 1 
    maxRefFilters = (nopcw ? 16 : 64) - numClasses - minPcWiener
    numRefFilters = 0
    numCheckPlanes = plane > 0 ? 2 : 1
    matchIdx = 0
    matchCls = 0
    matchPlane = plane
    for ( ref = 0; ref < NumTotalRefs; ref++ ) {
        if ( FrameType != SWITCH_FRAME && OrderHints[ref] != RESTRICTED_OH ) {
            idx = ref_frame_idx[ ref ]
            for ( check = 0; check < numCheckPlanes; check++ ) {
                if ( check == 0 ) {
                    checkPlane = plane
                } else {
                    checkPlane = plane == 1 ? 2 : 1
                }
                if ( RefFrameFiltersOn[ idx ][ checkPlane ] ) {
                    numRefClasses = (plane == 0) ?
                                        RefNumFilterClasses[ idx ] : 1
                    for ( i = 0; i < numRefClasses; i++ ) {
                        if ( numRefFilters < maxRefFilters ) {
                            if ( numRefFilters + numClasses == target ) {
                                matchIdx = idx
                                matchCls = i
                                matchPlane = checkPlane
                            }
                            numRefFilters += 1
                        }
                    }
                }
            }
        }
    }
    return (numClasses, numRefFilters, matchIdx, matchCls, matchPlane)
}

The function get_translated_pc_wiener (which converts a pixel classified filter into a Wiener filter) is specified as:

get_translated_pc_wiener( m, j ) {
    if ( j >= 12 ) {
            return 0
    }
    filt = Shuffled_Index[ m ]
    coeff = Round2Signed( Pc_Wiener_Filters[ 0 ][ filt ][ j ],
                          PC_WIENER_PREC_BITS - WIENER_NS_PREC_BITS )
    min = Wiener_Ns_Taps_Min[ 0 ][ j ]
    max = min + ( 1 <<  Wiener_Ns_Taps_K[ 0 ][ j ] ) - 1
    return Clip3(min, max, coeff)                       
}

where Shuffled_Index is defined as:

Shuffled_Index[ 64 ] = {
    16, 7,  58, 21, 12, 61, 26, 38, 18, 30, 50,
    45, 23, 49, 43, 62, 42, 54, 27, 36, 17, 44,
    32, 34, 4,  24, 52, 31, 37, 11, 33, 19, 35,
    6,  22, 53, 63, 25, 41, 47, 1,  59, 0,  28,
    40, 55, 48, 8,  5,  51, 9,  46, 56, 60, 15,
    2,  13, 14, 57, 29, 3,  20, 39, 10
}

The function predict_group (which finds which group has the highest count) is specified as:

predict_group( counts ) {
    pred = 0
    for ( i = 1; i <= 2; i++ ) {
        if ( counts[ i ] > counts[ pred ] ) {
            pred = i
        }
    }
    return pred
}

The table Wiener_Ns_Taps_Present (which specifies which filter taps are present) is specified as:

Wiener_Ns_Taps_Present[ 2 ][ 4 ][ WIENER_NS_CHROMA_COEFFS ] = {
    {
        { 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
        { 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0},
        { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0},
        { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0}
    },
    {
        { 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
        { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0},
        { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
        { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} 
    }
}

↑ Back to Table of Contents