Make clear that this isn't the official version

[dirac-spec-errata.git] / motion-dec.tex

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% - This chapter defines how motion data - %
% - is decoded                           - % 
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\label{motiondec}

This section defines the operation of the $block\_motion\_data()$ process for extracting
block motion data from the Dirac stream. 

Block motion data is aggregated into {\em superblocks}, consisting of a 4x4 array of 
blocks. The number of superblocks horizontally and vertically shall be determined so 
that there are sufficient superblocks to cover the picture area. Superblocks 
may overlap the right and bottom edge of the picture.

\begin{informative}
\\
\begin{enumerate}
\item Since superblocks may overlap the right and bottom edge of the picture, blocks in 
such superblocks may also overlap the edges or even fall outside the picture area
 altogether. Motion data for blocks which fall outside the picture area is still decoded, but
 will not be used for motion compensation (Section \ref{motioncompensate}). 

\item Unlike macroblocks in MPEG standards, a superblock does not encapsulate all 
data within a given area of the picture. It is merely an aggregation device for motion data,
and for this reason a different nomenclature has been adopted.
\end{enumerate}
\end{informative}

\subsection{Prediction modes and splitting modes}

\subsubsection{Prediction modes}

Two types of prediction mode shall be defined: a reference prediction mode, indicating
which references are to be used for motion compensation,  and a global motion
 mode flag, indicating how prediction is to be performed (using global motion or block
 motion for a given block).

Four reference prediction modes shall be defined and shall be denoted by integer
constant values: 
\begin{enumerate}
\item \Intra~shall denote value 0, and shall indicate that DC values for a block
shall be decoded and that no motion vectors shall be decoded.
\item  \RefOneOnly~shall denote value 1 and shall indicate that a motion vector
for the first reference picture shall be decoded, but no motion vector for the second
reference picture shall be decoded.
\item  \RefTwoOnly~shall denote value 2 and shall indicate that a motion vector
for the second reference picture shall be decoded, but no motion vector for the first
reference picture shall be decoded.
\item  \RefOneAndTwo~shall denote value 3 and shall indicate that motion vectors
for both the first and second reference picture shall be decoded.
\end{enumerate}

In addition, where global motion is used for a picture (i.e.\ $\PictureUsingGlobal$ is set),
a global motion mode flag shall be encoded for each block. If $\true$, global motion
compensation shall be used for this block, and no block motion vectors or DC values
shall be encoded. If $\false$, block motion compensation shall be employed and
one or more motion vectors shall be encoded.

\subsubsection{Splitting modes}

Block motion data shall be aggregated into superblocks, consisting of a 4x4 array
of blocks, for each block motion data element. 

Three superblock splitting levels shall be defined, numbered 0, 1, and 2. 

When level 0 splitting is used, if a block motion data element is
present for that superblock, only one value shall be coded. This value shall be 
applied to all blocks within the superblock.

When level 1 splitting is used, at most 4 values shall be coded for each
block motion data element. Where present, each of these values
shall be applied to the blocks in within the corresponding 2x2 sub-array of blocks
within the superblock.

When level 2 splitting is used, if a block motion data element is
present for that superblock, only four values shall be coded. Each of these values
shall be applied to all the four blocks in one of the four 2x2 sub-arrays of blocks
within the superblock.

\subsection{Structure of block motion data arrays}

\label{motionconventions}

For the purposes of this specification, block motion data shall be stored in the 
two dimensional array $\BlockData$. Superblock
splitting modes shall be stored in the two dimensional array $\SBSplit$.

For each block with coordinates $(i,j)$, a block motion data element 
$\BlockData[j][i]$ shall be defined. It is a map (Section \ref{datatypes}) and shall
consist of up to five elements:

\begin{enumerate}
\item A motion vector for reference 1, $\BlockData[j][i][\Vect][1]$, consisting of 
integral horizontal and vertical elements $\BlockData[j][i][\Vect][1][0]$ and 
$\BlockData[j][i][\Vect][1][1]$.
\item A motion vector for reference 2, $\BlockData[j][i][\Vect][2]$, consisting of 
integral horizontal and vertical elements $\BlockData[j][i][\Vect][2][0]$ and 
$\BlockData[j][i][\Vect][2][1]$.
\item A set of integral DC values for each component, $\BlockData[j][i][\DC][Y]$,
 $\BlockData[j][i][\DC][C1]$, and $\BlockData[j][i][\DC][C2]$.
\item A reference prediction mode, $\BlockData[j][i][\RMode]$, taking values \Intra, 
\RefOneOnly, \RefTwoOnly, or \RefOneAndTwo~and indicating which references
(if any) are to be used for predicting block $(i,j)$.
\item A global motion mode flag, $\BlockData[j][i][\GMode]$.
\end{enumerate}

\subsubsection{Block motion data initialisation}

\label{motioninit}

This section specifies the operation of the $initialise\_motion\_data()$ process.
 It shall set the dimensions of the block motion parameter arrays according to the numbers
of blocks and superblocks defined in Section {motiondatadimensions}.

The array $\BlockData$ shall be set to have horizontal dimension $\BlocksX$ and 
vertical dimension $\BlocksY$.

The array $\SBSplit$ shall be set to have horizontal dimension $\SuperblocksX$ 
and vertical dimension $\SuperblocksY$.

\subsection{Motion data decoding process}
\label{decodingprocess}

This section defines the $block\_motion\_data()$ process for extracting
block motion data elements.

This process depends upon the picture prediction parameters (Section
 \ref{picpredparams}).

Block motion data elements shall be coded differentially with respect to a spatial
prediction.  The spatial prediction processes for the block motion elements are 
defined in Section \ref{spatialprediction}

The decoding process for the block motion data shall consist of: 
\begin{enumerate}
\item decoding the superblock split modes,
\item decoding the prediction modes in each superblock according to the split mode, and
\item decoding the motion vectors and DC values according to the split mode and the
 decoded mode for each block.
\end{enumerate}

The motion vector elements are further decomposed into horizontal and vertical 
components which are encoded as separate parts. The DC values are further
decomposed into the the components which are encoded as separate parts. 

The coded data for each part (splitting mode, prediction mode, vector component,
or DC component values) shall consist of an entropy coded block
 preceded by a length code. 

\begin{pseudo}{block\_motion\_data}{}
\bsCODE{initialise\_motion\_data()}{\ref{motioninit}}
\bsCODE{superblock\_split\_modes()}{\ref{superblocksplit}}
\bsCODE{prediction\_modes()}{\ref{blockpredmodes}}
\bsCODE{vector\_elements(1, 0)}{\ref{blockmvelements}}
\bsCODE{vector\_elements(1, 1)}{\ref{blockmvelements}}
\bsIF{num\_refs()==2}
    \bsCODE{vector\_elements(2,0)}{\ref{blockmvelements}}
    \bsCODE{vector\_elements(2,1)}{\ref{blockmvelements}}
\bsEND
\bsCODE{dc\_values(Y)}{\ref{DCvalues}}
\bsCODE{dc\_values(C1)}{\ref{DCvalues}}
\bsCODE{dc\_values(C2)}{\ref{DCvalues}}
\end{pseudo}

\begin{informative}
The superblock splitting modes determine the number, and location, of 
prediction mode values to be decoded -- there
must be one for each `prediction unit' (block, 2x2 array or blocks, or 4x4 array or
blocks) within a superblock. Together, the split 
mode and the prediction mode determine the number and location of all other 
motion data parts, which can each then be decoded in parallel. Indeed,
by attempting to decode the maximum possible number of prediction residue 
values for all motion data elements, the first 
two motion data elements may also be decoded in parallel with the others. 
Once all residue values are decoded, excess
values can be discarded, the location of values determined and actual 
values reconstructed by prediction. This approach
may be particularly valuable in hardware. Decoding may proceed in this way, 
as the arithmetic decoding engine allows bits to be read beyond the nominal end of an
 arithmetically-coded chunk by inserting 1s, hence allowing virtual values to be read.
\end{informative}

\subsubsection{Superblock splitting modes}
\label{superblocksplit}

This section defines the decoding of the superblock splitting mode values. 

The superblock splitting mode shall determine the number of prediction modes
coded for each superblock.

$superblock\_split\_modes()$ process shall be defined as follows:

\begin{pseudo}{superblock\_split\_modes}{}
\bsITEM{length}{uint}{}
\bsCODE{\ABitsLeft= 8*length}
\bsCODE{byte\_align()}
\bsCODE{ctx\_labels=[\SBSplitFollowOne,\SBSplitFollowTwo,\SBSplitData]}
\bsCODE{initialise\_arithmetic\_decoding(ctx\_labels)}{\ref{initarith}}
\bsFOR{ysb=0}{\SuperblocksY-1}
    \bsFOR{xsb=0}{\SuperblocksX-1}
        \bsCODE{sb\_split\_residual=read\_uinta(sb\_split\_contexts() ) }{\ref{sbcontexts}}
        \bsCODE{\SBSplit[ysb][xsb] = sb\_split\_residual}
        \bsCODE{\SBSplit[ysb][xsb]+=split\_prediction(xsb, ysb)}{\ref{splitprediction}}
        \bsCODE{\SBSplit[ysb][xsb] \%= 3}
    \bsEND
\bsEND
\bsCODE{flush\_inputb()}{\ref{blockreadbit}}
\end{pseudo}

\subsubsection{Propagating data between blocks}
\label{propagatedata}

The superblock splitting mode determines the maximum number of values to be
decoded for each block motion data element: 0, 4, or 16. If the splitting mode
is 0 or 1 and a value is decoded it applies to all 16 blocks or to one of the 4 2x2 
sub-arrays of blocks within the superblock. So that prediction of values shall
operate correctly, once decoded a value shall be propagated to all blocks to
which it applies.

The $propagate\_data(xtl, ytl, k,idx)$ shall copy decoded block data from the 
top-left-most block $(xtl, ytl)$ of an array of $k\times k$ blocks, where $k$ shall be 4 if the
splitting mode is 0 and $k$ shall be 2 if the splitting mode is 1. It shall be defined
as follows:

\begin{pseudo}{propagate\_data}{xtl, ytl, k,label}
\bsFOR{y=ytl}{ytl+k-1}
    \bsFOR{x=xtl}{xtl+k-1}
        \bsCODE{\BlockData[y][x][label]=\BlockData[ytl][xtl][label]}
    \bsEND
\bsEND
\end{pseudo}

\subsubsection{Block prediction modes}
\label{blockpredmodes}

The prediction mode process shall decode global motion and reference
 prediction modes required for each superblock according to the
the superblock splitting mode.: 16 values shall be decoded for split mode 2, 
4 values shall be decoded for split mode 1, and 1 value for split mode 0. 

For split modes 0 and 1, decoded values shall placed in the top-left corner block 
of the array (4x4 or 2x2) of blocks to which they apply, and then propagated to the 
other blocks.

The $prediction\_modes()$ process shall be defined as follows:

\begin{pseudo}{prediction\_modes}{}
\bsITEM{length}{uint}{}
\bsCODE{\ABitsLeft= 8*length}
\bsCODE{byte\_align()}
\bsCODE{ctx\_labels=[\PredModeOne,\PredModeTwo,\BlockGlobal]}
\bsCODE{initialise\_arithmetic\_decoding(ctx\_labels)}{\ref{initarith}}
\bsFOR{ysb=0}{\SuperblocksY-1}
    \bsFOR{xsb=0}{\SuperblocksX-1}
        \bsCODE{block\_count = 2^{\SBSplit[ysb][xsb]}}
        \bsCODE{step = 4//block\_count }
        \bsFOR{q=0}{block\_count-1}
            \bsFOR{p=0}{block\_count-1}
                \bsCODE{block\_ref\_mode(4*xsb+p*step, 4*ysb+q*step)}{\ref{blockmode}}
                \bsCODE{propagate\_data(4*xsb+p*step, 4*ysb+q*step, step,\RMode)}{\ref{propagatedata}}
                \bsCODE{block\_global\_mode(4*xsb+p*step, 4*ysb+q*step)}{\ref{blockglobal}}
                \bsCODE{propagate\_data(4*xsb+p*step, 4*ysb+q*step, step,\GMode)}{\ref{propagatedata}}
           \bsEND
        \bsEND
    \bsEND
\bsEND
\bsCODE{flush\_inputb()}{\ref{blockreadbit}}
\end{pseudo}

\paragraph{Block prediction mode}
\label{blockmode}

The $block\_ref\_mode()$ process shall be defined as follows:

\begin{pseudo}{block\_ref\_mode}{x, y}
\bsCODE{\BlockData[y][x][\RMode] = 0}
\bsIF{read\_boola(\PredModeOne)==\true}
    \bsCODE{\BlockData[y][x][\RMode] = 1}
\bsEND
\bsIF{num\_refs() == 2}
    \bsIF{read\_boola(\PredModeTwo)==\true}
        \bsCODE{\BlockData[y][x][\RMode] += 2}
    \bsEND
\bsEND
\bsCODE{\BlockData[y][x][\RMode] \wedge=ref\_mode\_prediction(x, y)}{\ref{modeprediction}}
\end{pseudo}

\paragraph{Block global mode}
\label{blockglobal}
$\ $\newline

The $block\_global\_mode()$ process shall be defined as follows:

\begin{pseudo}{block\_global}{x, y}
\bsCODE{\BlockData[y][x][\GMode]=\false}
\bsIF{\PictureUsingGlobal==\true}
    \bsIF{\BlockData[y][x][\RMode]!=\Intra}
        \bsCODE{block\_global\_residue = read\_boola(\BlockGlobal)}
        \bsCODE{\BlockData[y][x][\GMode] = block\_global\_residue}
        \bsCODE{\BlockData[y][x][\GMode] \wedge= block\_global\_prediction(x, y)}{\ref{blockglobalprediction}}
    \bsEND
\bsEND
\end{pseudo}

\subsubsection{Block motion vector elements}
\label{blockmvelements}

The vector element process shall decode the set of horizontal, or the set of vertical  
motion vector elements associated with one of the reference pictures.

$vector\_elements()$ process shall be defined as follows:

\begin{pseudo}{vector\_elements}{ref,dirn}
\bsITEM{length}{uint}{}
\bsCODE{\ABitsLeft= 8*length}
\bsCODE{byte\_align()}
\bsCODE{ctx\_labels=\begin{array}{l}[\VectorFollowOne,\VectorFollowTwo,\VectorFollowThree,
\VectorFollowFour,\VectorFollowFivePlus,\\
\VectorData,\VectorSign]
\end{array}}
\bsCODE{initialise\_arithmetic\_decoding(ctx\_labels)}{\ref{initarith}}
\bsFOR{ysb=0}{\SuperblocksY-1}
    \bsFOR{xsb=0}{\SuperblocksX-1}
        \bsCODE{block\_count = 2^{\SBSplit[ysb][xsb]}}
        \bsCODE{step = 4//block\_count }
        \bsFOR{q=0}{block\_count-1}
            \bsFOR{p=0}{block\_count-1}
                \bsCODE{block\_vector(4*xsb+p*step, 4*ysb+q*step, ref, dirn)}
                \bsCODE{propagate\_data(4*xsb+p*step, 4*ysb+q*step, step,\Vect)}{\ref{propagatedata}}
           \bsEND
        \bsEND
    \bsEND
\bsEND
\bsCODE{flush\_inputb()}{\ref{blockreadbit}}
\end{pseudo}

The block vector proces shall decode an individual motion vector element. 
It shall be defined as follows:

\begin{pseudo}{block\_vector}{x, y, ref, dirn}
\bsIF{\BlockData[y][x][\RMode][ref] == \true}
    \bsIF{\BlockData[y][x][\GMode]==\false}
        \bsCODE{mv\_residual = read\_sinta(mv\_contexts() ) }{\ref{mvcontexts}}
        \bsCODE{\BlockData[y][x][\Vect][ref][dirn] = mv\_residual}
        \bsCODE{\BlockData[y][x][\Vect][ref][dirn] +=mv\_prediction(x, y, ref, dirn)}
    \bsEND
\bsEND
\end{pseudo}

\subsubsection{DC values}
\label{DCvalues}

The DV value process shall decode the DC values for a intra blocks for a given video component (Y, C1 or C2). It shall be defined as follows:

\begin{pseudo}{dc\_values}{c}
\bsITEM{length}{uint}{}
\bsCODE{\ABitsLeft= 8*length}
\bsCODE{byte\_align()}
\bsCODE{ctx\_labels=[\DCFollowOne,\DCFollowTwoPlus,\DCData,\DCSign]}
\bsCODE{initialise\_arithmetic\_decoding(ctx\_labels)}{\ref{initarith}}
\bsFOR{ysb=0}{\SuperblocksY-1}
    \bsFOR{xsb=0}{\SuperblocksX-1}
        \bsCODE{block\_count = 2^{\SBSplit[ysb][xsb]}}
        \bsCODE{step = 4//block\_count }
        \bsFOR{q=0}{block\_count-1}
            \bsFOR{p=0}{block\_count-1}
                \bsCODE{block\_dc(4*xsb+p*step, 4*ysb+q*step, c)}
                \bsCODE{propagate\_data(4*xsb+p*step, 4*ysb+q*step, step,\DC)}{\ref{propagatedata}}
           \bsEND
        \bsEND
    \bsEND
\bsEND
\bsCODE{flush\_inputb()}{\ref{blockreadbit}}
\end{pseudo}

The block DC process shall decode an individual component DC value. It shall
be defined as follows:

\begin{pseudo}{block\_dc}{x, y,c}
\bsIF{\BlockData[y][x][\RMode]=\Intra}
    \bsCODE{dc\_residual = read\_sinta(dc\_contexts()) }{\ref{dcvaluecontexts}}
    \bsCODE{\BlockData[y][x][\DC][c] = dc\_residual}
    \bsCODE{\BlockData[y][x][\DC][c] +=dc\_prediction(x, y, c)}{\ref{dcprediction}}
\bsEND
\end{pseudo}

\subsubsection{Spatial prediction of motion data elements}

\label{spatialprediction}

\paragraph{Prediction apertures\\}

A consistent convention for prediction apertures is used. The nominal prediction 
aperture for block motion data is defined to be the relevant data to the left, top
and top-left of the data element in question (Figure \ref{predaperture}). 
For the superblock split mode of 
the superblock with index $(i,j)$ this means the superblocks with indices $(i-1,j)$,
$(i,j-1)$ and $(i-1,j-1)$. For the block motion data itself, the same applies where these
indices are {\em block} indices. 

\setlength{\unitlength}{1em}
\begin{figure}[!ht]
\centering
\begin{picture}(15,20)
\multiput(0,0)(8,0){3}%
  {\line(0,1){16}}
\multiput(0,0)(0,8){3}%
  {\line(1,0){16}}
  
%Shading  

\multiput(0,0)0.2,0){40}%  
{\multiput(8,0.1)(0,.2){40}%
  {\tiny.}
}

%Arrows
\put(4,12){\vector(1,-1){6}}
\put(12,12){\vector(0,-1){6}}
\put(4,4){\vector(1,0){6}}
\end{picture}
\caption{Basic prediction aperture}\label{predaperture}
\end{figure}

This is the nominal prediction aperture. Not all data elements in this prediction
aperture may be available, either because they would require negative indices, or
 because the data is not available - for example a block to the left of a block with 
reference mode  \RefTwoOnly may have reference mode \RefOneOnly and so 
can furnish no contribution for a prediction to the
Reference 2 motion vector.

When superblocks have split level 1 or 0, block data shall be propagated
(Section \ref{propagatedata}) across 4 or 16 blocks so as to furnish a prediction. The
effect is illustrated in Figure \ref{splitapertures}.

\setlength{\unitlength}{.75em}
\begin{figure}[!ht]
\centering
\begin{picture}(60,17.5)

\multiput(0,0)(20,0){3}%
{

%Main Grid
\multiput(0,0)(8,0){3}%
  {\line(0,1){16}}
\multiput(0,0)(0,8){3}%
  {\line(1,0){16}}
\multiput(0,0)0.2,0){40}%  

%Shading
\multiput(0,0)0.4,0){20}% 
{\multiput(8,0.2)(0,.4){20}%
  {\tiny.}
}

%Dotted Grid
\multiput(0,0)(0,2){3}%
{\multiput(0,2)(0.5,0){16}%
   {\line(1,0){.25}}
}
\multiput(0,0)(2,0){3}%
{\multiput(2,0)(0,0.5){16}%
   {\line(0,1){.25}}
}

\multiput(8,0)(0,8){2}%
{\multiput(0,4)(0.5,0){16}%
   {\line(1,0){.25}}
}

\multiput(12,0)(0,0.5){32}%
   {\line(0,1){.25}}
}
%Arrows
\put(4,12){\vector(1,-1){5}}
\put(7,7) {\vector(2,-1){1.5}}
\put(10,10){\vector(0,-1){3}}

\put(30,6){\vector(0,-1){3.5}}
\put(27,5) {\vector(1,-1){2}}
\put(27,3){\vector(2,-1){2}}

\put(50,2){\vector(1,0){3.5}}
\put(50,6) {\vector(1,-1){3.5}}
\put(54,6){\vector(0,-1){3.5}}

\end{picture}
\caption{Effect of splitting modes on spatial prediction}\label{splitapertures}
\end{figure}

\paragraph{Superblock split prediction}
\label{splitprediction}
$\ $\newline
$split\_prediction$ returns the mean of the the neighbouring split values:

\begin{pseudo}{split\_prediction}{x, y}
\bsIF{ x==0 \text{ \bf and } y==0 }
    \bsRET{0}
\bsELSEIF{y==0}
    \bsRET{\SBSplit[0][x-1]}
\bsELSEIF{x==0}
    \bsRET{\SBSplit[y-1][0]}
\bsELSE
    \bsCODE{ 
    \begin{array}{ll}
    \text{\bf return} & \mean(\SBSplit[y-1][x-1], \\
                       &  \quad\quad\quad \SBSplit[y][x-1],  \\
                       &  \quad\quad\quad \SBSplit[y-1][x])
    \end{array}
    }
\bsEND
\end{pseudo}

\paragraph{Block mode prediction}
\label{modeprediction}
$\ $\newline
The $ref\_mode\_prediction()$ function shall return a value that represents a majority
 verdict for the presence of each of the references individually. It shall be defined
 as follows:

\begin{pseudo}{ref\_mode\_prediction}{x, y}
\bsIF{ x==0 \text{ \bf and } y==0 }
    \bsRET{\Intra}
\bsELSEIF{y==0}
    \bsRET{\BlockData[0][x-1][\RMode]}
\bsELSEIF{x==0}
    \bsRET{\BlockData[y-1][0][\RMode]}
\bsELSE
    \bsCODE{num\_ref1\_nbrs=\BlockData[y-1][x][\RMode] \& 1}
    \bsCODE{num\_ref1\_nbrs +=\BlockData[y-1][x-1][\RMode] \& 1}
    \bsCODE{num\_ref1\_nbrs +=\BlockData[y][x-1][\RMode] \& 1}
    \bsCODE{pred=num\_ref1\_nbrs//2}
    \bsCODE{num\_ref2\_nbrs=(\BlockData[y-1][x][\RMode]\gg 1) \& 1}
    \bsCODE{num\_ref2\_nbrs +=(\BlockData[y-1][x-1][\RMode] \gg 1) \& 1}
    \bsCODE{num\_ref2\_nbrs +=(\BlockData[y][x-1][\RMode] \gg 1) \& 1}
    \bsCODE{pred \wedge= (num\_ref2\_nbrs//2)\ll 1}
    \bsRET{pred}
\bsEND
\end{pseudo}

\paragraph{Block global flag prediction}
\label{blockglobalprediction}
$\ $\newline
The $block\_global\_prediction()$ function shall return a value that represents a majority
 verdict of the neighbouring blocks. It shall be defined as follows:

\begin{pseudo}{block\_global\_prediction}{x, y}
\bsIF{ x==0 \text{ \bf and } y==0 }
    \bsRET{\false}
\bsELSEIF{ y==0 }
    \bsRET{\BlockData[0][x-1][\GMode]}
\bsELSEIF{x==0}
    \bsRET{\BlockData[y-1][0][\GMode]}
\bsELSE
    \bsCODE{
    \begin{array}{ll}
    \text{\bf return} & \majority(\BlockData[y-1][x-1][\GMode], \\
    & \quad\quad\quad \BlockData[y-1][x][\GMode],  \\
    & \quad\quad\quad \BlockData[y][x-1][\GMode]) 
    \end{array}
    }
\bsEND
\end{pseudo}

\paragraph{Motion vector prediction}
\label{mvprediction}
$\ $\newline
Motion vectors shall be predicted using the median of available block vectors 
in the aperture. A vector shall be available for prediction if:
\begin{enumerate}
\item its block falls within the picture area,
\item its prediction mode allows it to be defined, and
\item it is not a global motion block. 
\end{enumerate}

The $mv\_prediction(x, y, ref, dirn)$ shall return motion values according to
the following rules:

{\bf Case 1.}  If $x==0$ and $y==0$, the value $0$ shall be returned.

{\bf Case 2.} If $x>0$ and $y==0$ then:
\begin{enumerate}
   \item If  $\BlockData[0][x-1][\GMode]==\false$  and 
$(\BlockData[0][x-1][\RMode] \& ref) != 0$ then vector element $\BlockData[0][x-1][\Vect][ref][dirn]$ shall be returned,
   \item otherwise, $0$ shall be returned
\end{enumerate}

{\bf Case 3.} If $x==0$ and $y>0$ then:
\begin{enumerate}
   \item If  $\BlockData[y-1][0][\GMode]==\false$ and 
$(\BlockData[y-1][0][\RMode] \& ref)!=0$ then vector element
$\BlockData[y-1][0][\Vect][ref][dirn]$ shall be returned,
   \item otherwise, $0$ shall be returned
\end{enumerate}

{\bf Case 4.} If both $x>0$ and $y>0$ then all 3 blocks in the prediction aperture 
may potentially contribute to the prediction. Define the set $values=\{\}$. The prediction 
shall be the median of the available vector elements, as defined in the following
pseudocode:

\begin{pseudo*}
\bsIF{x>0 \text{ \bf and } y>0 }
    \bsIF{\BlockData[y][x-1][\GMode]==\false}
        \bsIF{(\BlockData[y][x-1][\RMode] \& ref) != 0}
            \bsCODE{values = values\cup\{\BlockData[y][x-1][\Vect][ref][dirn] \} }
        \bsEND
    \bsEND
    \bsIF{\BlockData[y-1][x][\GMode]==\false}
        \bsIF{(\BlockData[y-1][x][\RMode] \& ref) != 0}
            \bsCODE{values = values\cup\{\BlockData[y-1][x][\Vect][ref][dirn] \} }
        \bsEND
    \bsEND
    \bsIF{\BlockData[y-1][x-1][\GMode]==\false}
        \bsIF{(\BlockData[y-1][x-1][\RMode] \& ref) != 0}
            \bsCODE{values = values\cup\{\BlockData[y-1][x-1][\Vect][ref][dirn] \} }
        \bsEND
    \bsEND

    \bsRET{\median(values)}{\ref{integerops}}
\bsEND
\end{pseudo*}

(Note that the median of an empty set is zero.)

\paragraph{DC value prediction}
\label{dcprediction}
$\ $\newline
DC values shall be predicted using the unbiased mean of available values 
in the prediction aperture. 

The process $dc\_prediction(x, y, c)$ shall return values according to
the following rules:

{\bf Case 1.}  If $x==0$ and $y==0$, $0$ shall be returned.

{\bf Case 2.} If $x>0$ and $y==0$ then:
\begin{enumerate}
   \item If $\BlockData[0][x-1][\RMode]==\Intra$, $\BlockData[0][x-1][\DC][c]$ 
shall be returned,
   \item otherwise, $0$ shall be returned.
\end{enumerate}

{\bf Case 3.} If $x==0$ and $y>0$ then:
\begin{enumerate}
   \item If $\BlockData[y-1][0][\RMode]==\Intra$, $\BlockData[y-1][0][\DC][c]$
shall be returned,
   \item otherwise, 0 shall be returned.
\end{enumerate}

{\bf Case 4.} If both $x>0$ and $y>0$ then all 3 blocks in the prediction aperture may
 potentially contribute to the prediction. Define a set $values=\{\}$. The prediction shall
be the unbiased mean of available values, as defined in the following pseudocode:

\begin{pseudo*}
\bsIF{ x>0 \text{ \bf and } y>0 }
    \bsIF{\BlockData[y][x-1][\RMode]==\Intra}
        \bsCODE{values = values\cup\{\BlockData[y][x-1][\DC][c] \} }
    \bsEND
    \bsIF{\BlockData[y-1][x][\RMode]==\Intra}
        \bsCODE{values = values\cup\{\BlockData[y-1][x][ref][\DC][c] \} }
    \bsEND
    \bsIF{\BlockData[y-1][x-1][\RMode]==\Intra}
        \bsCODE{values = values\cup\{\BlockData[y-1][x-1][ref][\DC][c] \} }
    \bsEND
    \bsIF{values!=\{\}}
        \bsRET{pred =\mean(values)}
    \bsELSE
        \bsRET{0}
    \bsEND
\bsEND
\end{pseudo*}

\subsubsection{Block motion parameter contexts}

\paragraph{Superblock splitting mode}\label{sbcontexts}
$\ $\newline
The $sb\_split\_contexts()$ function shall return a context label map $c$ with the 
following values:

\begin{itemize}
\item $c[FOLLOW] = [ \SBSplitFollowOne, \SBSplitFollowTwo ]$
\item $c[DATA] = \SBSplitData$
\end{itemize}

\paragraph{Motion vectors}
\label{mvcontexts}
$\ $\newline
The $mv\_contexts()$ function shall return a context label map $c$ with the 
following values:

\begin{itemize}
\item $c[FOLLOW] = [ \VectorFollowOne, \VectorFollowTwo, \VectorFollowThree, \VectorFollowFour, \VectorFollowFivePlus ]$
\item $c[DATA] = \VectorData$
\item $c[SIGN] = \VectorSign$
\end{itemize}

\paragraph{DC values}
\label{dcvaluecontexts}

The $dc\_contexts()$ function shall return a context label map $c$ with the 
following values:

\begin{itemize}
\item $c[FOLLOW] = [ \DCFollowOne, \DCFollowTwoPlus ]$
\item $c[DATA] = \DCData$
\item $c[SIGN] = \DCSign$
\end{itemize}