L'algorithme de décodage "VI"agraVision  
( Retrouvez le KIT du Développeur: ICI)
Par Fantasio.

Principe
================================================================================
Le décodeur consiste en :
* un tampon de 32 lignes de vidéo, 
* la table des permutations (256 octets), 
* un couple :(offset (sur 8 bits) , saut sur 8 bits)).

La table contient 256 nombres de 0 à 31. 
(ou de 1 à 32 suivant comment on numérote). 
C'est ce qu'on trouve dans le key.txt

La clé de décodage proprement dite est constituée du couple 
* offset,
* saut.

- L'offset dit où commencer dans la table,
- Le saut permet de trouver où continuer dans la table.
Le saut est toujours impair, pour des raisons arithmétiques.

Le nombre de combinaisons possibles est de : 256 x (256/2) = 32768.

Lorsqu'on recoit une image du tuner, 
1 - les 32 premières lignes sont stockées dans le tampon (sans ressortir vers la vidéo de la TV).
2 - ensuite, pour chaque ligne qui suit, on utilise la table pour choisir quelle ligne doit sortir vers la vidéo depuis le tampon de lignes => d'où le numéro de 1 à 32.
La ligne recue vient directement remplacée celle qui est émise vers la TV.
3 - avant de passer à la ligne suivante, le décodeur augmente la position courante dans la table de la valeur du saut. Si l'index est supérieur à 256, on enlève 256.

Exemple sur la 33ème ligne : 
================================================================================

Si on suppose par exemple : Offset : 9, saut : 251. (clé de décodage).

* numéro de ligne à remplacer : NumTamponARemplacer = Table[offset] = table[5];
* sortir tampon[NumTamponARemplacer] vers la vidéo.
* mettre la ligne recue dans tampon[NumTamponARemplacer]
* offset nouveau = offset+saut = 9+251=260;
* offset > 256? oui : offset=offset-256 = 4.

On recoit la ligne suivante :
* NumTamponARemplacer = Table[offset] = table[4]
* sortir tampon[NumTamponARemplacer] vers la vidéo.
* mettre la ligne recue dans tampon[NumTamponARemplacer]
* offset nouveau = offset+saut = 4+251=255;
* offset > 256? non => ne rien faire.

et ainsi de suite.


En fait l'exemple a été simplifié car dans la réalité il y a une seule complication :
================================================================================

Si on fait comme décrit, à chaque demi image reçue comportant 288 lignes utiles, il y a  un délai de 32 lignes avant que la première ligne visible sorte vers la TV.
Pour tenir compte de cela, les 32 premières lignes de l'image encodées sont en réalité envoyées dans les 32 dernières lignes de la demi image précédente.
Le tampon commence à se vider complètement des dernières lignes de l'image en cours et à se remplir à partir de la 257ème ligne des lignes de l'image suivante, dans l'ordre 1,2,3,4...jusqu'à 32.
C'est pour ça que l'image schtroumpfée est décalée avec le début de l'image en bas.
Comme on le voit, l'algo est très simple et a été conçu pour pouvoir être mis sur un microcontrôleur 8 bits genre Motorola 68Hxx ou Intel 85x51.

Légalité des informations contenues dans ce document :
================================================================================

Ces informations sont publiques car elles font l'objet d'un brevet qui a été déposé. C'est d'ailleurs de là que sont extraites les infos de feu tu.chemnitz.de.
En revanche, les tables elles-mêmes auraient du rester secrètes. C'est probablement pour cette raison que le site a été fermé. C'est aussi pour cette raison que les softs ne sont et ne devraient jamais avoir de key.txt réel avec. Les sites qui les diffusent sont dans l'illégalité et sont passibles de sanctions pénales en correctionnelle.

Comment fait-on pour trouver le couple (offset,saut) utilisé dans une image :
================================================================================

C'est tout con : on essaie toutes les combinaisons possibles. Comme il n'y en a que 32mille, la puissance d'un micro actuel suffit amplement.
Dans une image réelle, une ligne et celle qui la suit se ressemblent beaucoup.  En revanche, plus deux lignes sont éloignées et moins elles vont se ressembler.
On peut prendre comme mesure de ressemblance, la somme de la valeur absolue des différences  entre les pixels de même numéro des deux lignes à comparer. Plus elle est grande, et moins les deux lignes se ressemblent. Si les deux lignes sont identiques, on aura 0.
Pour calculer la vraisemblance d'une image, on fait simplement la somme des comparaisons des lignes voisines.
Pour choisir l'image la plus vraisemblable, on prend celle qui a la somme la plus faible.
Voilà assez schématiquement comment ça se passe. 
En revanche, optimiser la recherche pour utiliser le moins possible de CPU et de mémoire, c'est une autre histoire. 
Toute l'astuce consiste à réduire le nombre de comparaisons et d'essais au strict minimum.