add label for ref

455-Codage_Sources/Cours/chap1.tex

@@ -396,7 +396,7 @@ On va associer un code $\underline{c}(x_{1:N})$ à $x_{1:N}$ qui sera un nombre
 
 On essaie de représenter $\c(x_{1:N})$ avec peu de bits si $x_{1:N}$ est très probable et avec plus de bits si $x_{1:N}$ est moins probable.
 
-\subsubsection{Algorithme de codage arithmétique en précision inifinie}
+\subsubsection{Algorithme de codage arithmétique en précision inifinie}\label{sec:arithm}
 
 On considère une source binaire sans mémoire décritre par $p=(p_0,p_1)^T$ et ayant généré $x = (x_1 ... x_n)$ à coder.
 
@@ -405,10 +405,17 @@ On considère une source binaire sans mémoire décritre par $p=(p_0,p_1)^T$ et
 
 \item \textbf{Étapes : pour n allant de 1 à N}
 \begin{enumerate}
-\item Si $x_n=0$ alors $l_n=l_{n-1}$ et $h_n=l_{n-1}+(h_{n-1}-l_{n-1})p_0$
+\item Si $x_n=0$ alors $  \begin{cases}
-\item Si $x_n=1$ alors $l_n=l_{n-1}+(h_{n-1}-l_{n-1})p_0$ et $h_n=h_{n-1}$
+l_n=l_{n-1} \\
-\item $n = n+1$
+h_n=l_{n-1}+(h_{n-1}-l_{n-1})p_0
-\item Si $n\leq N$, aller en 1.
+\end{cases}$
+
+\item Si $x_n=1$ alors $
+  \begin{cases}
+    l_n=l_{n-1}+(h_{n-1}-l_{n-1})p_0 \\ h_n=h_{n-1}
+\end{cases}
+$
+
 \item On a $h_N-l_N=p(x_{1:N})$
 \end{enumerate}
 
@@ -418,6 +425,56 @@ On considère une source binaire sans mémoire décritre par $p=(p_0,p_1)^T$ et
 \[ \overline{c}(\vec{x}) = \lfloor \lambda(\vec{x}) \rfloor _{\mu(\vec{x)+1}} \]
 \end{enumerate}
 où $\lfloor a \rfloor _{\lambda}$ est la représentation binaire de $a$ tronquée à $\lambda$ bits. (Exemple : $\lfloor 0,1011 \rfloor _2 = 0,10$)\\
+
+\subsubsection{Codes arithmétique implantable}
+
+Le code arithmétique vu en \ref{sec:arithm} possède plusieurs défauts:
+\begin{itemize}
+\item Il faut coder tout le vecteur généré pour la source pour obtenir le code arithmétique. Ceci introduit du délai de codage.
+\item Les bornes inf et sup de l'intervalle de codage deviennent de plus en plus proches il faut les représenter en précision infinie.
+\end{itemize}
+L'idée du coadge arithmétique ``pratique'' est d'émettre ou de stocker sur le disque les bits de code dès qu'ils sont déterminé sans ambiguité. On peux alors dilater l'intervalle de codage.
+
+\begin{enumerate}
+\item \textbf{Entrée:} $\vec{p}$, $\vec{x}$
+\item \textbf{Initialisation}$l_0=0, \quad h_0 = 1,\quad, f=0, n=1$
+
+\item \textbf{Étapes : pour k allant de 1 à N}
+  \begin{enumerate}
+  \item Si $x_k=0$ alors $  \begin{cases}
+      l_k=l_{k-1} \\
+      h_k=l_{k-1}+(h_{k-1}-l_{k-1})p_0
+    \end{cases}$
+
+  \item Si $x_k=1$ alors $
+    \begin{cases}
+      l_k=l_{k-1}+(h_{k-1}-l_{k-1})p_0 \\ h_k=h_{k-1}
+    \end{cases}
+    $
+  \end{enumerate}
+\item
+  \begin{enumerate}
+  \item Si $[l_k,h_k[ \subset [0,0.5[$ : \\
+    $c = [c,0 \underbracket{1...1}_{f} [$ et $[l_k,h_k [ =  [2l_k,2h_k [ $
+  \item Sinon si $[l_k,h_k[ \subset [0.5,1[$: \\
+    $c =[c,1 \underbracket{0...0}_{f} [$ et $[l_k,h_k[ = [2l_{k}-1,2h_{k}-1[$
+  \item Sinon si $[l_k,h_k[ \subset [0.25,0.75[ $ :\\
+    $f= f+1$, $[l_k,h_k[ = [2l_k-0.5 , 2h_k-0.5[$
+  \end{enumerate}
+\item Tant que $[l_k,h_k[ \subset [0,0.5[ $ ou $[l_k,h_k[ \subset [0.5, 1 [ $ ou  $[l_k,h_k[ \subset [0.25,0.75[$ :\\
+  aller en 4
+\end{enumerate}
+
+\begin{rem}
+  en pratique le codage arithmétique se fait sur des intervalles entiers en partant de $[l_0,h_0[= [0,2^M]$ après découpages, les bornes des intervalles sont arrondies. On test si :
+  \begin{align*}
+    [l_k,h_k] &\subset [0,2^{M-1}[\\
+              &\subset[2^{M-1},2^M[\\
+              &\subset[2^{M-2},2^{M-1}+2^{M-2}]
+  \end{align*}
+Les probabilités d'apparition de chaque symbole sont estimée en cours de codage.
+\end{rem}
+
 \subsubsection{Algorithme de décodage arithmétique en précision infinie}
 Le décodeur arithmétique va chercher à déterminer les selections des sous intervalles faites par le codeur.\\
 
@@ -427,6 +484,7 @@ Le décodeur arithmétique va chercher à déterminer les selections des sous in
   On note $\tilde{\lambda}$ le nombre dont la représentation est $\vec{c}$
 
 \item \textbf{Pour i allant de 1 à n}:
+
   \begin{itemize}
   \item Si $\tilde{\lambda}\in[l_{i-1},l_{i-1}+p_0(h_{i-1}-l_{i-1})]$ alors : $x_i=0$ et $[l_i,h_i[ = [l_{i-1},l_{i-1}+p_0(h_{i-1}-l_{i-1})]$
   \item sinon $x_i=1$ et $[l_i,h_i[ = [l_{i-1}+p_0(h_{i-1}-l_{i-1}),h_{i-1}]$
@@ -436,8 +494,6 @@ Le décodeur arithmétique va chercher à déterminer les selections des sous in
 \subsubsection{Performance}
 
 Il faut montrer que $c(x_{1:N}) \in [l_N,h_N[$ (et qu'alors on pourra décoder), et que cette procédure de codage est efficace, ie $E(\mu(X_1...X_N ))\simeq NH(x)$
-
-
 \begin{itemize}
 \item On sait que $c(\vec{x}) \leq \mu(\vec{x})$ et on veut montrer que :
 \[
@@ -483,18 +539,6 @@ NH(X) + 1 & \leq & \overline{l} & < & NH(X) + 2
 Cette procédure est efficace pour $N\to +\infty$, avec l'$\infty$ petit. Par exemple, pour $N=100$, alors la longueur moyenne sera proche à $1\%$ de l'entropie.
 \end{itemize}
 
-
-\subsubsection{Réalisation pratique}
-En pratique, le codage utilise l'intervalle $[0,2^p[$ où $p$ désigne la précision du codeur arithmétique. (pour le codage H264/AVC, on a $p=9$).
-On réalise des homothéties de centre 0, de rapport $2^p$ ou $2^{p-1}$ avec ou sans émission de bits.
-On estime les probabilités d'apparition des bits en parallèle du codage au codeur et au décodeur, et on modifie la façon de découper les intervalles en fonction de ces probabilités d'apparition estimées.
-On obtient alors un CABAC : Context Adaptative Binary Arithmetic Coder.
-
-\begin{rem}
-Si on a plusieurs symboles à coder (A,B,C), on pourrait faire un codeur arithmétique ternaire, mais on préfaire binariser les données (A=00,B=01,C=10) et utiliser un codeur arithmétique binaire, qui est plus pratique pour les remises à l'échelle.
-\end{rem}
-
-\newpage
 \subsection{Code de Lempel-Ziv-Welch}
 
 \paragraph{Idée}