P14AB08 Implantation d'un encodeur vidéo MJPEG sur RX64M » History » Version 25

axel BARRIEUX, 04/07/2021 01:59 PM

1 2 axel BARRIEUX
h1=. P14AB08 Implantation d'un encodeur vidéo MJPEG sur RX64M
2 2 axel BARRIEUX
3 2 axel BARRIEUX
p=. !https://forge.clermont-universite.fr/attachments/download/16158/P14AB08_renesas82_20140409101105_20140409101131.jpeg!
4 2 axel BARRIEUX
5 2 axel BARRIEUX
---
6 2 axel BARRIEUX
7 2 axel BARRIEUX
*Projet GE2-GE3 2014*
8 2 axel BARRIEUX
*Entreprise / Client* : Renesas Electronics/ Sébastien Walger
9 2 axel BARRIEUX
*Auteurs* : Clément Leyssene / Geoffrey Raynal
10 2 axel BARRIEUX
*Responsable Projet* : Michel James
11 2 axel BARRIEUX
*Tuteur industriel* : Isabelle Goi
12 2 axel BARRIEUX
13 3 axel BARRIEUX
h1=.  Sommaire
14 2 axel BARRIEUX
15 2 axel BARRIEUX
[[1. Résumé]] 
16 2 axel BARRIEUX
[[2. Abstract]] 
17 2 axel BARRIEUX
[[3. Introduction]] 
18 2 axel BARRIEUX
[[4. Présentation du Sujet]] 
19 2 axel BARRIEUX
        
20 2 axel BARRIEUX
p(((. [[1. Renesas]] 
21 2 axel BARRIEUX
[[2. Le projet]] 
22 2 axel BARRIEUX
    
23 2 axel BARRIEUX
[[5. Cahier des Charges]] 
24 2 axel BARRIEUX
[[6. Developpement]] 
25 2 axel BARRIEUX
        
26 2 axel BARRIEUX
p(((. [[1. Problématiques]] 
27 2 axel BARRIEUX
        [[2. Faisabilité]] 
28 2 axel BARRIEUX
        [[3. Etude Théorique]] 
29 2 axel BARRIEUX
        [[4. Solutions]] 
30 2 axel BARRIEUX
    
31 2 axel BARRIEUX
[[7. Gestion de Projet]] 
32 2 axel BARRIEUX
       
33 2 axel BARRIEUX
p(((. [[1. W.B.S.]] 
34 2 axel BARRIEUX
[[2. Gantt]] 
35 2 axel BARRIEUX
   
36 2 axel BARRIEUX
[[8. Notes d'application]] 
37 2 axel BARRIEUX
      
38 2 axel BARRIEUX
p(((. [[1. sujet 1]] 
39 2 axel BARRIEUX
[[2. sujet 2]] 
40 2 axel BARRIEUX
   
41 2 axel BARRIEUX
[[9. Bilan]] 
42 2 axel BARRIEUX
       
43 2 axel BARRIEUX
p(((. [[1. Etat d'avancement]] 
44 2 axel BARRIEUX
[[2. Analyse Critique]] 
45 2 axel BARRIEUX
[[3. Perspectives]] 
46 2 axel BARRIEUX
    
47 1 axel BARRIEUX
[[10. Bibliographie]] 
48 3 axel BARRIEUX
49 3 axel BARRIEUX
---
50 3 axel BARRIEUX
51 3 axel BARRIEUX
h1=. Résumé
52 3 axel BARRIEUX
53 3 axel BARRIEUX
Ce projet concerne la réalisation d'un encodeur vidéo de type Motion-JPEG sur un microcontrôleur Renesas, le RX64M. Cette entreprise souhaite la réalisation d’un tel projet afin de démontrer les performances de leur nouveau microcontrôleur et pouvoir proposer au client des applications fonctionnelles.
54 3 axel BARRIEUX
Pour ce projet nous disposons d'une carte possédant le microcontrôleur, qui sera relié d'un côté à une caméra et de l'autre à un ordinateur.
55 3 axel BARRIEUX
L’objectif sera d’envoyer un flux vidéo de la caméra vers le microcontrôleur qui traitera les données et les encodera, puis ce dernier enverra ces données vers un ordinateur qui affichera la vidéo à l’écran.
56 3 axel BARRIEUX
57 3 axel BARRIEUX
*Mots clés:
58 3 axel BARRIEUX
RX64M
59 3 axel BARRIEUX
MJPEG
60 3 axel BARRIEUX
Encodage JPEG*
61 3 axel BARRIEUX
62 3 axel BARRIEUX
---
63 3 axel BARRIEUX
64 3 axel BARRIEUX
h1=. Abstract
65 3 axel BARRIEUX
66 3 axel BARRIEUX
This project involves the implementation of a video encoder type Motion-JPEG on a Renesas microcontroler, the RX64M. The company wants the realization of such a project to demonstrate the performance of their new microcontroller and to be able to offer the customer functional applications.
67 3 axel BARRIEUX
In this project we have a board with the RX64M microcontroller, which is connected on one side to a camera and a computer to the other.
68 3 axel BARRIEUX
The objective is to send a video stream from the camera to the microcontroller, which will process the data and encode, then it will send the data to a computer that displays the video on the screen.
69 3 axel BARRIEUX
70 3 axel BARRIEUX
*Key words:
71 3 axel BARRIEUX
RX64M
72 3 axel BARRIEUX
MJPEG
73 3 axel BARRIEUX
JPEG Encoding*
74 3 axel BARRIEUX
75 3 axel BARRIEUX
---
76 3 axel BARRIEUX
77 3 axel BARRIEUX
h1=. Introduction
78 3 axel BARRIEUX
79 3 axel BARRIEUX
En 1 heure, 6000h de vidéo sont postées sur le site YouTube?. Une heure de vidéo non compressée en haute définition sans son a une taille de 625 Gio, soit 78 DVD. Le problème est donc de pouvoir réaliser des vidéos qui puissent être stockées sur des supports tels que les CD, les DVD, ou plus récemment, dans nos téléphones portables. C'est dans cette problématique que les encodages vidéos sont apparus, certains sont utilisés pour que la qualité de la vidéo soit excellente et d'autres pour réduire au maximum la taille du fichier.
80 3 axel BARRIEUX
81 3 axel BARRIEUX
Dans le cadre de la formation de Génie électrique à Polytech, les étudiants ingénieurs ont l'opportunité de réaliser un projet industriel, répartie en deux phases. La première étape se déroule lors de la quatrième année pendant une durée de 48H, qui consiste en une phase d'étude avec la faisabilité, la gestion de projet et les recherches liées au projet. Par la suite, lors de la cinquième et dernière année, une phase de 250h permet de concrétiser le travail de quatrième année et de réaliser ce qui a été demandé dans le cahier des charges. Ces projets industriels permettent aux étudiants de se confronter au monde de l'entreprise à leur futur travail d'ingénieur, mais en restant encadré par des enseignants du milieu génie électrique ainsi que par des tuteurs industriels.
82 3 axel BARRIEUX
83 3 axel BARRIEUX
La société Renesas Electronics, représentée par notre client Sébastien Walger, a récemment développé un nouveau microcontrôleur, le RX64M et souhaite pouvoir présenter à ses clients des applications fonctionnelles de cette nouvelle cible, afin de démontrer les performances de leur microcontrôleur. C'est dans cette perspective que Renesas a confié à Polytech le projet de réaliser cette application. Notre objectif est d’implanter sur cette cible Renesas RX64M des algorithmes d’encodage MJPEG en utilisant un flux vidéo provenant d’une caméra, puis de l'envoyer sur un ordinateur qui décodera et affichera à l'écran le résultat.
84 3 axel BARRIEUX
L’enjeu de ce projet est de réussir à implanter un encodeur complexe et volumineux sur une cible beaucoup moins puissante qu’un ordinateur.
85 3 axel BARRIEUX
86 3 axel BARRIEUX
h1=. Présentation du Sujet
87 3 axel BARRIEUX
88 3 axel BARRIEUX
*%{color:red}+1. Renesas+%*
89 4 axel BARRIEUX
90 4 axel BARRIEUX
p<. !https://forge.clermont-universite.fr/attachments/download/16159/P14AB08_Renesas_blue_20140401171140_20140401171202.png!
91 4 axel BARRIEUX
92 4 axel BARRIEUX
Renesas Electronics est une entreprise japonaise basée à Tokyo créé en novembre 2002 de la fusion d’HITACHI Ltd et de MITSUBISHI ELECTRIC CORPORATION et compte près de 28500 salariés à travers le monde. Cette société est le leader mondial des fournisseurs de microcontrôleurs et est un fournisseur de solutions de semi-conducteurs avancés. Il assure également la conception, fabrication, vente et service après-vente des systèmes de semi-conducteurs pour la téléphonie mobile, l’automobile, l’électronique de puissance, les mémoires, les LCD, les circuits intégrés RF et système sur puce.
93 4 axel BARRIEUX
94 4 axel BARRIEUX
*%{color:red}+2. Le projet+%*
95 4 axel BARRIEUX
96 4 axel BARRIEUX
Notre projet est d'utiliser le microcontrôleur fourni par Renesas, le RX64M, pour encoder le flux vidéo provenant d'une caméra en MJPEG, puis de le transférer via liaison filaire sur un ordinateur qui décompressera la vidéo pour l'afficher à l'écran
97 4 axel BARRIEUX
98 5 axel BARRIEUX
*%{color:#00008B}+2.1 Synoptique général du sujet+%*
99 5 axel BARRIEUX
100 5 axel BARRIEUX
p<. !https://forge.clermont-universite.fr/attachments/download/16160/P14AB08_synoptique_20140401173233_20140404082959.png!
101 5 axel BARRIEUX
102 5 axel BARRIEUX
*%{color:#00008B}+2.2 Pourquoi encoder?+%*
103 5 axel BARRIEUX
104 5 axel BARRIEUX
Nous pouvons nous poser de ce besoin d'encoder, en effet pourquoi ne pas envoyer tout simplement le flux vidéo de la caméra vers l'ordinateur ?
105 5 axel BARRIEUX
En regardant les spécifications de la caméra, nous nous rendons compte qu'elle a une résolution de 640*480 pixels, de trois couleurs pour chaque pixel réparti sur 8 bits avec un débit maximal de 30 images par seconde.
106 5 axel BARRIEUX
Nous obtenons donc un flux de 640*480*3*8*30=221184000 bits/s= 221,2 Mbit/s, ce flux sature le protocole USB.2 qui est limité à 175Mbits/s, d'où cette nécessité de réduire la taille du flux vidéo en le compressant. Nous allons par la suite présenter la méthode d'encodage que nous devons utiliser.
107 5 axel BARRIEUX
108 5 axel BARRIEUX
*%{color:#00008B}+2.3 Définition des termes du sujet+%*
109 5 axel BARRIEUX
110 5 axel BARRIEUX
*+2.2.1 Le MJPEG+*
111 5 axel BARRIEUX
112 5 axel BARRIEUX
Motion JPEG (M-JPEG ou MJPEG) est un format vidéo dans lequel chaque image vidéo ou une séquence vidéo numérique est compressé séparément comme une image JPEG. Initialement développé pour les applications PC multimédias, M-JPEG est maintenant utilisé par les appareils de capture vidéo, tels que des appareils photo numériques, caméras IP, et des webcams. Nous allons donc nous intéresser lors de ce projet au fonctionnement de l'encodage JPEG.
113 5 axel BARRIEUX
114 5 axel BARRIEUX
*+2.2.2 L'encodage JPEG+*
115 5 axel BARRIEUX
116 5 axel BARRIEUX
JPEG est l’acronyme de Joint Photographic Experts Group. Il a été développé par un comité d'expert qui édite des normes de compression pour l’image fixe durant les années 1978 à 1980. Le groupe JPEG a spécifié la norme en 1991. La norme officielle et définitive a été adoptée en 1992.
117 5 axel BARRIEUX
118 5 axel BARRIEUX
La compression JPEG permet de réaliser des compressions d'image avec ou sans perte: -avec pertes ou compression irréversibles. C’est le JPEG « classique ». Il permet des taux de compression de 3 à 100.
119 5 axel BARRIEUX
-sans pertes ou compression réversible. Il n’y a pas de pertes d’information et il est donc possible de revenir aux valeurs originales de l’image. Les gains en termes de compression sont alors plus modestes, avec un taux de compression de l’ordre de 2 à 8.
120 5 axel BARRIEUX
Pour les besoins du projet, nous allons utiliser la première méthode afin de réduire au maximum la taille des images et donc de la vidéo.
121 5 axel BARRIEUX
122 5 axel BARRIEUX
Voici comment s'organise le processus de compression et de décompression d'une image JPEG:
123 6 axel BARRIEUX
124 6 axel BARRIEUX
p=. !https://forge.clermont-universite.fr/attachments/download/16161/P14AB08_organigramme_compression_20140404090556_20140404090606.png!
125 6 axel BARRIEUX
126 6 axel BARRIEUX
Les différentes étapes de cet algorithme seront expliquées plus en détail dans la partie étude théorique.
127 6 axel BARRIEUX
128 6 axel BARRIEUX
---
129 6 axel BARRIEUX
130 6 axel BARRIEUX
h1=. Cahier des Charges
131 6 axel BARRIEUX
132 6 axel BARRIEUX
- Réaliser un encodeur JPEG sur un microcontrôleur RX64M
133 6 axel BARRIEUX
- Récupérer le flux vidéo d’une caméra via une liaison parallèle
134 6 axel BARRIEUX
- Transférer le flux compressé du RX64M vers un ordinateur via liaison filaire
135 6 axel BARRIEUX
- Afficher la vidéo en utilisant la fonction streaming de VLC
136 6 axel BARRIEUX
- Si le temps le permet, remplacer la liaison filaire par un protocole Ethernet
137 7 axel BARRIEUX
138 7 axel BARRIEUX
p=. !https://forge.clermont-universite.fr/attachments/download/16162/P14AB08_cahier_des_charges_20140424152344_20140424152415.png!
139 7 axel BARRIEUX
140 7 axel BARRIEUX
---
141 7 axel BARRIEUX
142 7 axel BARRIEUX
h1=. Développement
143 7 axel BARRIEUX
144 7 axel BARRIEUX
---
145 7 axel BARRIEUX
146 7 axel BARRIEUX
h2<. Problématique
147 7 axel BARRIEUX
148 7 axel BARRIEUX
Le projet comporte deux aspects importants, le transport de données d’un point à un autre et l’implémentation d’un algorithme complexe dans un appareil beaucoup moins puissant qu’un microprocesseur d’ordinateur.
149 7 axel BARRIEUX
D’une part il s’agit de transférer une vidéo ou une suite d’image de la carte du microcontrôleur vers l’ordinateur à une vitesse suffisante pour que l’image retransmise ne soit pas saccadée.
150 7 axel BARRIEUX
D’autre part l’encodeur d’image JPEG est un code complexe qui existe depuis environ 30 ans et qui a été optimisé depuis pour être utilisé principalement sur les ordinateurs. Il y a donc une réelle difficulté à adapter ce code sur la cible qui nous est fournie.
151 7 axel BARRIEUX
152 7 axel BARRIEUX
---
153 7 axel BARRIEUX
154 7 axel BARRIEUX
h2<. Faisabilité
155 7 axel BARRIEUX
156 7 axel BARRIEUX
Après réflexion, nous avons pensé que le projet serait réalisable si le transfert de donnée par liaison filaire suffit, si ce dernier est saturé nous devrons utiliser le protocole Ethernet, il est clair que le projet ne pourrait pas être terminé si nous avons à mettre en place un tel protocole, mais il aurait des chances d'être terminé si le client nous fournit les codes permettant d'utiliser le protocole Ethernet.
157 7 axel BARRIEUX
158 7 axel BARRIEUX
---
159 7 axel BARRIEUX
160 7 axel BARRIEUX
h2<. Etude Théorique
161 7 axel BARRIEUX
162 7 axel BARRIEUX
Comme dit précédemment, pour réaliser l'encodage MJPEG, il faut traiter le flux vidéo comme une succession d'images JPEG.
163 7 axel BARRIEUX
Pour cela, il faut décomposer les différentes étapes de ce processus. Dans un premier temps, il s’agit de séparer l'image en blocs de 8x8 pixels. La caméra a une résolution de 640x480 pixel, ce qui nous donne 4800 blocs à traiter. Les parties transformations des couleurs et sous échantillonnage sont déjà réalisées par la caméra qui envoie le flux vidéo en YCbCr, le signal Y correspond à la luminance (noir et blanc), plus deux informations de chrominance : Cb (bleu moins Y) et Cr (rouge moins Y), le signal Y est composé de la somme des couleurs rouge, bleu et vert.
164 7 axel BARRIEUX
165 7 axel BARRIEUX
p(((. P14AB08_YCbCr.jpeg?
166 7 axel BARRIEUX
167 7 axel BARRIEUX
Des équations permettent de calculer les YCbCr à partir des couleurs RVB:
168 7 axel BARRIEUX
169 7 axel BARRIEUX
Y= 0,299*R + 0,587*G + 0,114*B
170 7 axel BARRIEUX
Cb= -0,1687*R - 0,3314*G + 0,5*B +128
171 7 axel BARRIEUX
Cr= 0,5*R - 0,4187*G - 0,0813*B +128
172 7 axel BARRIEUX
173 7 axel BARRIEUX
Pour la suite, nous allons utiliser la matrice 8x8 suivante qui correspond à un bloc d'une image:
174 7 axel BARRIEUX
175 8 axel BARRIEUX
p=. !https://forge.clermont-universite.fr/attachments/download/16163/P14AB08_matrice_initiale_20140411111753_20140411111805.png!
176 8 axel BARRIEUX
177 8 axel BARRIEUX
h3<. +La DCT+
178 8 axel BARRIEUX
179 8 axel BARRIEUX
L'étape suivante est la DCT (Discrete Cosine Transform, en français, transformé en cosinus discret), qui permet de supprimer les variations d'intensité dans une image comme sur la figure 4, l’image de droite est avant la DCT, il y a sur son spectre de nombreuses variations, après la transformation DCT, les variations sur le spectre sont nettement plus atténués, sans causé de différence notable avec l’image initiale. Cette transformation numérique est appliquée à chaque bloc.
180 9 axel BARRIEUX
181 9 axel BARRIEUX
p=. !https://forge.clermont-universite.fr/attachments/download/16164/P14AB08_DCT_20140409112347_20140409112359.png!
182 9 axel BARRIEUX
183 9 axel BARRIEUX
La transformée DCT s’exprime mathématiquement par :
184 10 axel BARRIEUX
185 10 axel BARRIEUX
p=. !https://forge.clermont-universite.fr/attachments/download/16165/P14AB08_DCT_calcul_20140409112347_20140409112414.png!
186 11 axel BARRIEUX
187 11 axel BARRIEUX
p=. !https://forge.clermont-universite.fr/attachments/download/16166/P14AB08_DCT_calcul_1_20140409112347_20140409112429.png!
188 11 axel BARRIEUX
189 11 axel BARRIEUX
Et N = nombre de pixel, ici N=8.
190 11 axel BARRIEUX
191 11 axel BARRIEUX
On écrit ensuite dans un nouveau tableau de la même taille que N, les amplitudes de chacun des cosinus composant le signal. Ils sont classés en faisant apparaître les hautes fréquences vers le coin inférieur droit du tableau. La DCT est une opération théoriquement sans perte d'informations, mais étant donné que nous n'utilisons pas les fonctions cosinus pour nos calculs, mais des approximations de ces valeurs, il en résulte une certaine perte d'information.
192 11 axel BARRIEUX
193 11 axel BARRIEUX
Ce qui nous permet d'obtenir en utilisant la matrice initiale:
194 12 axel BARRIEUX
195 12 axel BARRIEUX
p=. !https://forge.clermont-universite.fr/attachments/download/16167/P14AB08_matrice_DCT_20140411111753_20140411111824.png!
196 12 axel BARRIEUX
197 12 axel BARRIEUX
La 1re valeur à l'indice (0,0) est le coefficient continu, elle correspond à une valeur "moyenne'' de la grandeur d'ensemble de la matrice d'entrée, en effet elle représente un nombre proportionnel à la somme de toutes les valeurs du signal. Les autres valeurs de la DCT représentent des écarts par rapport à cette moyenne. On remarque que les valeurs de la matrice à s'approcher de 0 lorsqu'on s'éloigne du coin supérieur gauche, c'est-à-dire lorsqu'on monte dans les plus hautes fréquences. Cela traduit le fait que l'information d'une image est concentrée dans les basses fréquences.
198 12 axel BARRIEUX
NB : Comme un pixel est un bloc de 8x8 avec 3 composantes (Y, Cb, Cr), la DCT est appliquée séparément à trois blocs de 8x8:
199 12 axel BARRIEUX
Le premier bloc est le bloc 8x8 qui contient la luminance.
200 12 axel BARRIEUX
Le second bloc 8x8 est le bloc qui contient la valeur Cb.
201 12 axel BARRIEUX
Et de même, le troisième bloc de 8x8 contient les valeurs Cr.
202 12 axel BARRIEUX
203 12 axel BARRIEUX
Tandis que la DCT convertit l'image dans son domaine de fréquence et élimine une certaine variation, elle produit plus d'informations qu'elle en élimine: les valeurs du domaine spatial sont de -128 à 128, les valeurs de la matrice après DCT sont de -1024 à 1024. Un second procédé de compression, la quantification, est utilisé pour éliminer l'excès de ces informations.
204 12 axel BARRIEUX
205 12 axel BARRIEUX
h3<. +La quantification+
206 12 axel BARRIEUX
207 12 axel BARRIEUX
Après la DCT, l'image est décrite dans le domaine fréquentiel dans les moindres détails, cependant, l’œil humain ne peut pas remarquer les différents changements très lumineux ou de couleurs très sombres. La quantification permet de diminuer la précision du stockage des entiers de la matrice DCT en supprimant les hautes fréquences, ce qui permet de réduire le nombre de bits occupés par chaque entier.
208 12 axel BARRIEUX
C'est l'étape où se produit le plus de perte d'information, la diminution de précision doit être plus forte dans les hautes fréquences. La perte de précision va donc être de plus en plus grande lorsqu'on s'éloigne de la position (0,0).
209 12 axel BARRIEUX
Une matrice de quantification est utilisée pour cette étape, soit Q cette matrice, elle sera définie, la plupart du temps par :
210 12 axel BARRIEUX
211 12 axel BARRIEUX
Q(i,j)= 1+K .(1+i+j ), avec i l'indice de ligne, j l'indice de colonne et K le facteur de qualité (choisi entre 1 et 25).
212 12 axel BARRIEUX
213 12 axel BARRIEUX
On choisit une matrice de quantification avec un facteur de qualité = 2 :
214 13 axel BARRIEUX
215 13 axel BARRIEUX
p=. !https://forge.clermont-universite.fr/attachments/download/16168/P14AB08_matrice_quantification_20140411111753_20140411114727.png!
216 13 axel BARRIEUX
217 13 axel BARRIEUX
Chaque amplitude est divisée par le nombre correspondant dans le tableau. Par exemple, la valeur moyenne est divisée par 3, et l'amplitude associée à la plus haute fréquence est divisée par 31.
218 13 axel BARRIEUX
Les amplitudes en bas à droite vont être divisées par des coefficients beaucoup plus grands.
219 13 axel BARRIEUX
En utilisant la matrice DCT calculée précédemment et en la divisant par la matrice de quantification on obtient :
220 14 axel BARRIEUX
221 14 axel BARRIEUX
p=. !https://forge.clermont-universite.fr/attachments/download/16169/P14AB08_matrice_quantifiee_20140411111753_20140411114742.png!
222 14 axel BARRIEUX
223 14 axel BARRIEUX
Lors de l'arrondi à l'entier le plus proche, les valeurs des hautes fréquences seront probablement ramenées à 0. C'est à ce moment que l'on perd en qualité, il faut veiller à choisir une matrice de qualité adéquate pour ne pas détériorer l'image :
224 14 axel BARRIEUX
225 15 axel BARRIEUX
p=. !https://forge.clermont-universite.fr/attachments/download/16170/P14AB08_quantification_20140411090307_20140411090336.png!
226 15 axel BARRIEUX
227 15 axel BARRIEUX
Si la quantification est trop forte (= taux de compression trop élevé), il y aura trop peu de coefficients non nuls pour représenter fidèlement le bloc. Le problème apparaîtra lors du décodage nécessaire pour l'affichage de l'image : à l’écran, la division en blocs deviendra visible, et l'image aura un aspect « pixelisé ».
228 15 axel BARRIEUX
229 15 axel BARRIEUX
h3<. +compression de Huffman+
230 15 axel BARRIEUX
231 15 axel BARRIEUX
*Le ZigZag*
232 15 axel BARRIEUX
233 15 axel BARRIEUX
L'étape suivante est la compression de Huffman, pour cela on commence par parcourir la matrice en ZigZag? :
234 16 axel BARRIEUX
235 16 axel BARRIEUX
p=. !https://forge.clermont-universite.fr/attachments/download/16171/P14AB08_zigzag_20140411090307_20140411090400.png!
236 16 axel BARRIEUX
237 16 axel BARRIEUX
Cette technique a la propriété de parcourir les éléments de la matrice en commençant par les basses fréquences et de continuer sur des fréquences de plus en plus hautes. Étant donné que la matrice quantifiée contient de nombreux coefficients nuls, la séquence zigzag va engendrer une suite de 0.
238 16 axel BARRIEUX
Dans notre cas :
239 17 axel BARRIEUX
240 17 axel BARRIEUX
p=. !https://forge.clermont-universite.fr/attachments/download/16172/P14AB08_matrice_zigzag_20140411111753_20140411114713.png!
241 17 axel BARRIEUX
242 17 axel BARRIEUX
Par la suite, la norme JPEG demande de séparer la première valeur (en rouge) du reste, cette valeur sera appelée DC, et le reste des 63 valeurs AC.
243 17 axel BARRIEUX
244 17 axel BARRIEUX
*Algorithme RLE*
245 17 axel BARRIEUX
246 17 axel BARRIEUX
Ce résultat est par la suite traité selon un algorithme de type RLE (run-length encoding) pour compresser, cet algorithme repose sur une idée assez simple : au lieu de répéter plusieurs fois un même symbole, on indique le nombre de fois qu’on le répète, puis ce symbole :
247 18 axel BARRIEUX
248 18 axel BARRIEUX
p=. !https://forge.clermont-universite.fr/attachments/download/16173/P14AB08_matrice_rle_20140411111753_20140411114802.png!
249 18 axel BARRIEUX
250 18 axel BARRIEUX
En rouge correspond le symbole et en vert le nombre de répétition de ce dernier, la lettre 'e' est là pour signaler la fin de la chaine.
251 18 axel BARRIEUX
252 18 axel BARRIEUX
La suite est d'utilisé l'algorithme de Huffman qui est plus complexe. Au lieu de stocker la valeur réelle, la norme JPEG précise qu’il faut stocker la taille minimale en bits dans lequel nous pouvons conserver cette valeur (cela s'appelle la catégorie de cette valeur), puis une représentation binaire codée comme ci dessous:
253 18 axel BARRIEUX
254 19 axel BARRIEUX
p=. !https://forge.clermont-universite.fr/attachments/download/16174/P14AB08_DC_huffman_20140424152344_20140424152442.png!
255 19 axel BARRIEUX
256 19 axel BARRIEUX
À gauche correspond les intervalles de valeurs que peut avoir la valeur DC, et à droite dans quelle catégorie il faut la ranger, les valeurs après la catégorie 11 (ou B) ne seront jamais atteinte. Par la suite il faut faire correspondre à ces catégories un dictionnaire, comme ci dessous:
257 20 axel BARRIEUX
258 20 axel BARRIEUX
p=. !https://forge.clermont-universite.fr/attachments/download/16175/P14AB08_Dico_huffman_20140424152344_20140424152456.png!
259 20 axel BARRIEUX
260 20 axel BARRIEUX
C’est une table standard pour appliquer le codage de Huffman, cette table est seulement valable pour la luminance, en effet, pour les chrominances, il sera plus adapté d’utilisé une autre table.
261 20 axel BARRIEUX
Les valeurs qui sont censées être les plus utilisés sont codées sur le plus petit nombre de bits, ici deux.
262 20 axel BARRIEUX
263 20 axel BARRIEUX
Pour les valeurs AC il faut tenir compte de la catégorie du nombre mais aussi du « run » c’est-à-dire le nombre de zéros qui précède cette valeur. On utilise donc de la même façon que pour les variables DC la table de Huffman ci dessous :
264 20 axel BARRIEUX
265 21 axel BARRIEUX
p=. !https://forge.clermont-universite.fr/attachments/download/16176/P14AB08_AC_20140427174650_20140427174715.png!
266 21 axel BARRIEUX
267 21 axel BARRIEUX
Il s’agit d’une table standard aussi calculée en fonction de la physiologie de l’œil et des tests menés sur plusieurs individus. Si le block contient 16 zéros d’affilés il faut l’indiquer avec une valeur particulière présente sur la table précédente.
268 21 axel BARRIEUX
269 21 axel BARRIEUX
---
270 21 axel BARRIEUX
271 23 axel BARRIEUX
 int DCT_transform(int DCT[COTE_MAX][COTE_MAX], int value[COTE_MAX][COTE_MAX])
272 23 axel BARRIEUX
 {
273 23 axel BARRIEUX
     int i,j,x,y;
274 23 axel BARRIEUX
     float calc = 0;
275 23 axel BARRIEUX
     for(i=0; i<COTE_MAX; i++)
276 23 axel BARRIEUX
     {
277 23 axel BARRIEUX
         for(j=0; j<COTE_MAX; j++)
278 23 axel BARRIEUX
         {
279 23 axel BARRIEUX
             for(x=0; x<COTE_MAX; x++)
280 23 axel BARRIEUX
             {
281 23 axel BARRIEUX
                 for(y=0; y<COTE_MAX; y++)
282 23 axel BARRIEUX
                 {
283 23 axel BARRIEUX
                     calc+=value[x][y]*(float)LUT[x][i]*(float)LUT[y][j];
284 23 axel BARRIEUX
                 }
285 23 axel BARRIEUX
             }
286 23 axel BARRIEUX
             if(i==0)
287 23 axel BARRIEUX
             {
288 23 axel BARRIEUX
                 calc=calc/Racine_2;
289 23 axel BARRIEUX
             }
290 23 axel BARRIEUX
             if(j==0)
291 23 axel BARRIEUX
             {
292 23 axel BARRIEUX
                 calc=calc/Racine_2;
293 23 axel BARRIEUX
             }
294 23 axel BARRIEUX
             calc= calc *((float)2/(float)COTE_MAX);
295 23 axel BARRIEUX
             DCT[i][j]= arrondi(calc);                    // round value, transform float to int
296 23 axel BARRIEUX
             calc = 0;
297 23 axel BARRIEUX
         }
298 23 axel BARRIEUX
     }
299 23 axel BARRIEUX
     DCT[0][0]=DCT[0][0]-1024;
300 23 axel BARRIEUX
     return 0;
301 23 axel BARRIEUX
 }
302 23 axel BARRIEUX
 /** step of quantifization, input : Q, DCT  ; output : DCT **/
303 23 axel BARRIEUX
 int Quantifization(int DCT[COTE_MAX][COTE_MAX], int Q[COTE_MAX][COTE_MAX])
304 23 axel BARRIEUX
 {
305 23 axel BARRIEUX
     int i,j;
306 23 axel BARRIEUX
     for(i=0; i<COTE_MAX; i++)
307 23 axel BARRIEUX
     {
308 23 axel BARRIEUX
         for(j=0; j<COTE_MAX; j++)
309 23 axel BARRIEUX
         {
310 23 axel BARRIEUX
             DCT[i][j]=arrondi((float)DCT[i][j]/(float)Q[i][j]);
311 23 axel BARRIEUX
         }
312 23 axel BARRIEUX
     }
313 23 axel BARRIEUX
     return 0;
314 23 axel BARRIEUX
 }
315 21 axel BARRIEUX
316 23 axel BARRIEUX
h3<. +La quantification+
317 21 axel BARRIEUX
318 23 axel BARRIEUX
Après des recherches, il semble plus adéquat d’utiliser des tables de quantification standard de la norme pour la compression JPEG :
319 24 axel BARRIEUX
320 24 axel BARRIEUX
p=. !https://forge.clermont-universite.fr/attachments/download/16177/P14AB08_quantification1_20140424152947_20140424153014.png!
321 24 axel BARRIEUX
La matrice de gauche sur la figure 12 correspond à une matrice de quantification pour la luminance et celle à droite correspond à une matrice pour la chrominance.
322 24 axel BARRIEUX
La programmation des parties découpages en blocs de 8 pixels, DCT, Quantification, ZigZag? et RLE est codée et testée, la partie Huffman est commencée mais non terminée:
323 24 axel BARRIEUX
324 24 axel BARRIEUX
 int facteur_qualite = 2;
325 24 axel BARRIEUX
int Quantifization(int DCT[COTE_MAX][COTE_MAX])
326 24 axel BARRIEUX
 {
327 24 axel BARRIEUX
    int i,j;
328 24 axel BARRIEUX
    for(i=0; i<COTE_MAX; i++)
329 24 axel BARRIEUX
        for(j=0; j<COTE_MAX; j++)
330 24 axel BARRIEUX
         {
331 24 axel BARRIEUX
            DCT[i][j]=arrondi((float)DCT[i][j]/(float)Q[i][j]);
332 24 axel BARRIEUX
        }
333 24 axel BARRIEUX
    return 0;
334 24 axel BARRIEUX
}
335 24 axel BARRIEUX
336 24 axel BARRIEUX
h3<. +Le ZigZag+
337 24 axel BARRIEUX
338 24 axel BARRIEUX
 int zig_zag(int matrice_quantifiee[COTE_MAX][COTE_MAX],int value[COTE_MAX*COTE_MAX], char index)
339 24 axel BARRIEUX
 {
340 24 axel BARRIEUX
     int i,j,colonne,crois;
341 24 axel BARRIEUX
     i=0;
342 24 axel BARRIEUX
     j=0;
343 24 axel BARRIEUX
     colonne=0;
344 24 axel BARRIEUX
     crois=0;
345 24 axel BARRIEUX
     while (i < COTE_MAX && j < COTE_MAX)
346 24 axel BARRIEUX
      {
347 24 axel BARRIEUX
         value[colonne]=matrice_quantifiee[i][j];
348 24 axel BARRIEUX
         colonne++;
349 24 axel BARRIEUX
         if (i == 0 || i == COTE_MAX-1)
350 24 axel BARRIEUX
          {
351 24 axel BARRIEUX
             if (j == COTE_MAX-1)
352 24 axel BARRIEUX
              {
353 24 axel BARRIEUX
                 j = j - 1;
354 24 axel BARRIEUX
                 i = i + 1;
355 24 axel BARRIEUX
             }
356 24 axel BARRIEUX
             j = j + 1;
357 24 axel BARRIEUX
             value[colonne]=matrice_quantifiee[i][j];
358 24 axel BARRIEUX
             colonne++;
359 24 axel BARRIEUX
         }
360 24 axel BARRIEUX
         else
361 24 axel BARRIEUX
          {
362 24 axel BARRIEUX
             if (j == 0 || j == COTE_MAX-1)
363 24 axel BARRIEUX
              {
364 24 axel BARRIEUX
                 if (i == COTE_MAX-1)
365 24 axel BARRIEUX
                  {
366 24 axel BARRIEUX
                     i = i - 1;
367 24 axel BARRIEUX
                     j = j + 1;
368 24 axel BARRIEUX
                 }
369 24 axel BARRIEUX
                 i = i + 1;
370 24 axel BARRIEUX
                 value[colonne]=matrice_quantifiee[i][j];
371 24 axel BARRIEUX
                 colonne++;
372 24 axel BARRIEUX
             }
373 24 axel BARRIEUX
          }
374 24 axel BARRIEUX
          if (i == 0 || j == COTE_MAX-1)
375 24 axel BARRIEUX
           {
376 24 axel BARRIEUX
              crois = 0;
377 24 axel BARRIEUX
          }
378 24 axel BARRIEUX
          if (j == 0 || i == COTE_MAX-1)
379 24 axel BARRIEUX
           {
380 24 axel BARRIEUX
              crois = 1;
381 24 axel BARRIEUX
            }
382 24 axel BARRIEUX
            if (crois==1)
383 24 axel BARRIEUX
             {
384 24 axel BARRIEUX
                i = i - 1;
385 24 axel BARRIEUX
                j = j + 1;
386 24 axel BARRIEUX
            }
387 24 axel BARRIEUX
            else
388 24 axel BARRIEUX
             {
389 24 axel BARRIEUX
                i = i + 1;
390 24 axel BARRIEUX
                j = j - 1;
391 24 axel BARRIEUX
            }
392 24 axel BARRIEUX
      }
393 24 axel BARRIEUX
      return 0;
394 24 axel BARRIEUX
}
395 25 axel BARRIEUX
396 25 axel BARRIEUX
h3<. +Algorithme RLE+
397 25 axel BARRIEUX
398 25 axel BARRIEUX
 int transformRLC(int mat_zigzag[COTE_MAX*COTE_MAX], Table_RLE table_RLE[COTE_MAX*COTE_MAX], char index)
399 25 axel BARRIEUX
 {
400 25 axel BARRIEUX
     int i=0;
401 25 axel BARRIEUX
     int j=0;
402 25 axel BARRIEUX
     char nb_occ;
403 25 axel BARRIEUX
     char ok=0;
404 25 axel BARRIEUX
     char pos_RLE=0;
405 25 axel BARRIEUX
     dcvalue[index].DC= mat_zigzag[0];
406 25 axel BARRIEUX
     while(i<(COTE_MAX*COTE_MAX))
407 25 axel BARRIEUX
      {
408 25 axel BARRIEUX
         nb_occ = 0;
409 25 axel BARRIEUX
         while((mat_zigzag[i] == 0 && nb_occ<16)&&i<63)
410 25 axel BARRIEUX
          {
411 25 axel BARRIEUX
             nb_occ++;
412 25 axel BARRIEUX
             i++;
413 25 axel BARRIEUX
         }
414 25 axel BARRIEUX
         if(nb_occ > 15)
415 25 axel BARRIEUX
          {
416 25 axel BARRIEUX
             table_RLE[pos_RLE].nb_occ = 0;
417 25 axel BARRIEUX
             table_RLE[pos_RLE].valeur = 0;
418 25 axel BARRIEUX
             break;
419 25 axel BARRIEUX
         }
420 25 axel BARRIEUX
         else
421 25 axel BARRIEUX
          {
422 25 axel BARRIEUX
            table_RLE[pos_RLE].nb_occ=nb_occ;            // nb occurrence first
423 25 axel BARRIEUX
            table_RLE[pos_RLE].valeur=mat_zigzag[i];     // value from zigzag
424 25 axel BARRIEUX
         }
425 25 axel BARRIEUX
         i++;
426 25 axel BARRIEUX
         pos_RLE++;
427 25 axel BARRIEUX
     }
428 25 axel BARRIEUX
     table_RLE[pos_RLE].nb_occ = 0;
429 25 axel BARRIEUX
     table_RLE[pos_RLE].valeur = 0;
430 25 axel BARRIEUX
     return 0;
431 25 axel BARRIEUX
}
432 25 axel BARRIEUX
433 25 axel BARRIEUX
---
434 25 axel BARRIEUX
435 25 axel BARRIEUX
h1=. Gestion de Projet
436 25 axel BARRIEUX
437 25 axel BARRIEUX
---
438 25 axel BARRIEUX
439 25 axel BARRIEUX
h2<. W.B.S.