.HEVC File Format – CABAC tables

Initialising a context

Each context has its own table (ctxTable, one per syntax element) and index (ctxIdx). Contexts are initialised at the start of each slice segment and each tile (or copied from saved states with wavefronts and dependent slice segments). Each starts from an 8-bit initValue (clause 9.3.2.2):

slopeIdx  = initValue >> 4
offsetIdx = initValue & 15
m = slopeIdx × 5 − 45
n = (offsetIdx << 3) − 16
preCtxState = Clip3(1, 126, ((m × Clip3(0, 51, SliceQpY)) >> 4) + n)
valMps    = preCtxState <= 63 ? 0 : 1
pStateIdx = valMps ? preCtxState − 64 : 63 − preCtxState

The set of values used depends on initType: 0 for I slices; for P slices 1, or 2 when cabac_init_flag is 1; for B slices 2, or 1 when cabac_init_flag is 1 (Equation 9-7). end_of_slice_segment_flag, end_of_subset_one_bit and pcm_flag use no table: they are decoded with DecodeTerminate (ctxTable 0, ctxIdx 0, which a decoder may instead treat as a fixed state with pStateIdx 63 and valMps 0). The engine itself starts with ivlCurrRange = 510 and ivlOffset = the next 9 bits; offsets 510 and 511 may not occur.

Initial values by syntax element

Tables 9-4 to 9-42. For each element, the ctxIdx used by each initType and their initValues in order. Elements that occur only in P and B slices have nothing for initType 0.

The coefficient elements have longer lists. last_sig_coeff_x_prefix and last_sig_coeff_y_prefix (Tables 9-26 and 9-27, identical) use ctxIdx 0 to 17 for initType 0, 18 to 35 for 1 and 36 to 53 for 2:

sig_coeff_flag (Table 9-29) uses 44 contexts per initType: ctxInc 0 to 41 are ctxIdx 0 to 41, 42 to 83 or 84 to 125, and ctxInc 42 and 43 (the transform-skip contexts) are ctxIdx 126 and 127, 128 and 129, or 130 and 131. The values by ctxIdx:

coeff_abs_level_greater1_flag (Table 9-30) uses ctxIdx 0 to 23 for initType 0, 24 to 47 for 1 and 48 to 71 for 2:

Binarisations

Table 9-43. FL is fixed length (the value in ⌈log2(cMax + 1)⌉ bits), TR truncated Rice (a unary prefix of 1s ended by a 0, which is left out at the maximum, then a suffix of cRiceParam bits; with cRiceParam 0 it is truncated unary), EGk k-th order Exp-Golomb, TB truncated binary.

intra_chroma_pred_mode (Table 9-46): 4 is 0; 0 to 3 are 100, 101, 110, 111. inter_pred_idc (Table 9-47): PRED_L0 (0) 00, PRED_L1 (1) 01, PRED_BI (2) 1; for 8 × 4 and 4 × 8 blocks (nPbW + nPbH = 12) only 0 for L0 and 1 for L1.

Choosing the context of each bin

Table 9-48. The context of bin binIdx is ctxIdx = the first ctxIdx of the element for the current initType + ctxInc. “bypass” bins use no context; “terminate” uses DecodeTerminate; “–” means the bin never occurs.

Neighbour-based contexts (clause 9.3.4.2.2)

For split_cu_flag, ctxInc counts the available neighbours to the left and above whose coding tree depth CtDepth is greater than the current depth; for cu_skip_flag, the available neighbours that are skipped (Table 9-49).

last_sig_coeff_x_prefix and _y_prefix (clause 9.3.4.2.3)

ctxInc = (binIdx >> ctxShift) + ctxOffset. For luma ctxOffset = 3 × (log2TrafoSize − 2) + ((log2TrafoSize − 1) >> 2) and ctxShift = (log2TrafoSize + 1) >> 2; for chroma ctxOffset = 15 and ctxShift = log2TrafoSize − 2.

coded_sub_block_flag (clause 9.3.4.2.4)

csbfCtx is the sum of the flags of the sub-blocks to the right and below (where they exist); ctxInc = Min(csbfCtx, 1) for luma and 2 + Min(csbfCtx, 1) for chroma.

sig_coeff_flag (clause 9.3.4.2.5)

• With transform_skip_context_enabled_flag and either transform skip or transquant bypass: sigCtx = 42 for luma, 16 for chroma.
• Else in a 4 × 4 block: sigCtx = ctxIdxMap[(yC << 2) + xC], with ctxIdxMap (Table 9-50) = 0, 1, 4, 5, 2, 3, 4, 5, 6, 6, 8, 8, 7, 7, 8 for positions 0 to 14.
• Else the DC position (xC + yC = 0): sigCtx = 0.
• Else, from prevCsbf (bit 0 the sub-block to the right, bit 1 the one below) and the position (xP, yP) inside the 4 × 4 sub-block: prevCsbf 0 gives 2 when xP + yP = 0, 1 when xP + yP < 3, else 0; prevCsbf 1 gives 2, 1, 0 for yP = 0, 1, more; prevCsbf 2 gives 2, 1, 0 for xP = 0, 1, more; prevCsbf 3 gives 2. Then for luma add 3 when the sub-block is not the first, and add 9 (8 × 8, diagonal scan) or 15 (8 × 8, other scans) or 21 (larger blocks); for chroma add 9 (8 × 8) or 12 (larger).

ctxInc = sigCtx for luma and 27 + sigCtx for chroma.

coeff_abs_level_greater1_flag and _greater2_flag (clauses 9.3.4.2.6, 9.3.4.2.7)

At the first coefficient of each sub-block, ctxSet is 0 for the first sub-block or for chroma and 2 otherwise, plus 1 if the previous sub-block’s last greater1Ctx had reached 0 (that is, a greater-than-1 level was seen there). greater1Ctx starts at 1, becomes 0 after a flag of 1 and grows by 1 after each flag of 0. greater1 ctxInc = ctxSet × 4 + Min(3, greater1Ctx), plus 16 for chroma. greater2 ctxInc = ctxSet, plus 4 for chroma.

palette_run_prefix (clause 9.3.4.2.8)

For bin 0 after an index (not copy-above), ctxInc is 0 if palette_idx_idc < 1, 1 if < 3, else 2. Otherwise Table 9-51: copy above, bins 0 to 4 use 5, 6, 6, 7, 7; index mode, bins 1 to 4 use 3, 3, 4, 4; later bins are bypassed.

The arithmetic decoder

Decoding a context-coded bin (clause 9.3.4.3.2): qRangeIdx = (ivlCurrRange >> 6) & 3 and ivlLpsRange = rangeTabLps[pStateIdx][qRangeIdx]; ivlCurrRange −= ivlLpsRange. If ivlOffset ≥ ivlCurrRange the bin is the LPS (1 − valMps), ivlOffset −= ivlCurrRange and ivlCurrRange = ivlLpsRange; otherwise it is valMps. The state then moves: after an MPS to transIdxMps(pStateIdx); after an LPS, valMps flips if pStateIdx was 0, then pStateIdx = transIdxLps(pStateIdx). Renormalisation doubles ivlCurrRange and shifts one bit into ivlOffset while ivlCurrRange < 256.

A bypass bin doubles ivlOffset, shifts in one bit and gives 1 (subtracting ivlCurrRange) if ivlOffset ≥ ivlCurrRange. A terminate bin subtracts 2 from ivlCurrRange and gives 1, ending CABAC, if ivlOffset ≥ ivlCurrRange; the last bit read is then the stop bit or the alignment bit. Before aligned bypass decoding of coeff_abs_level_remaining and coeff_sign_flag, ivlCurrRange is set to 256 (clause 9.3.4.3.6).

Table 9-52 above gives rangeTabLps (q is qRangeIdx). Table 9-53, the state transitions: