Event Stream est une spécification de format de fichier. Il s'agit d'une norme de stockage de flux d'événements et peut être utilisé pour transmettre des événements entre appareils électroniques. La spécification inclut un système de versioning, afin de permettre des changements massifs tout en gardant une rétrocompatibilité. L'extension recommandée pour les fichiers Event Stream est .es .
Pour un octet b , b[0] désigne le LSB (bit le moins significatif) et b[7] désigne le MSB (bit le plus significatif).
Chaque fichier Event Stream commence par un en-tête de 15 octets :
| Position | Contenu |
|---|---|
| Octets 0 à 11 | 0x45 0x76 0x65 0x6e 0x74 0x20 0x53 0x74 0x72 0x65 0x61 0x6d ( flux d'événements codé en ASCII) |
| Octet 12 | Version majeure |
| Octet 13 | Version mineure |
| Octet 14 | Version du correctif |
La numérotation des versions suit la convention de gestion des versions sémantiques. Les octets 15 jusqu'à la fin dépendent de la version. La description du contenu est donnée ci-dessous.
Le fichier peut représenter cinq types de flux : les événements génériques, les événements DVS, les événements ATIS, les événements d'affichage asynchrone et modulaire et les événements de couleur. Le type est stocké dans l'octet 15 :
| Octet 15 | Type de flux |
|---|---|
0x00 | Événements génériques |
0x01 | Événements DEP |
0x02 | Événements ATIS |
0x03 | Événements d'affichage asynchrone et modulaire |
0x04 | Événements de couleur |
Les octets 16 jusqu'à la fin peuvent être l'un des réinitialisations , débordements , octets 0 , octets de taille et octets de données . L'ordre possible de ces octets est donné par la machine à états :
Les octets codent les données suivantes :
| Nom d'octet | MSB | Bit 6 | Bit 5 | Bit 4 | Bit 3 | Bit 2 | Bit 1 | LSB |
|---|---|---|---|---|---|---|---|---|
| réinitialiser | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 0 |
| débordement | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 |
| octet 0 | t[7] | t[6] | t[5] | t[4] | t[3] | t[2] | t[1] | t[0] |
| taille octet | s[6] | s[5] | s[4] | s[3] | s[2] | s[1] | s[0] | is_last |
| octet de données | d[7] | d[6] | d[5] | d[4] | d[3] | d[2] | d[1] | d[0] |
la réinitialisation est un octet spécial inséré lorsque cela est jugé nécessaire pour corriger les erreurs de la machine d'état résultant d'erreurs de bits.
t code le temps écoulé depuis l'événement précédent en microsecondes et ne peut pas être 0b11111110 ni 0b11111111 . Si ce temps est égal ou supérieur à 0b11111110 microsecondes, un ou plusieurs octets de débordement sont insérés avant l'événement. Le temps réel écoulé depuis le dernier événement peut être calculé comme l'horodatage de l'événement en cours plus 0b11111110 microsecondes multiplié par le nombre d'octets de débordement .
La charge utile de données de chaque événement commence par un ou plusieurs octets de taille, qui codent le nombre d'octets de données à lire. Le nombre n d’octets de données à lire est donné par :
n = ∑ (s_i) << (7 * i)
où s_i, i ∈ [0, k - 1] désigne la (i + 1)ème valeur s et k le nombre d'octets de taille. Le nombre minimum d'octets de taille dépend du nombre d'octets de données. Les événements du même flux peuvent avoir différents nombres d'octets de données et différents nombres d'octets de taille. n octets de données nécessitent au moins Γlb(n + 1) / 7⅂ octets de taille, où Γ…⅂ est la fonction plafond et lb(…) est le logarithme binaire. Les applications ou les appareils générant des événements génériques sont encouragés à utiliser ce nombre minimal, bien que la spécification Event Stream autorise un plus grand nombre d'octets de taille.
is_last est égal à 0 pour le dernier octet de taille avant les octets de données, et 1 sinon.
d code les données fournies par l'utilisateur.
Les octets 16 à 19 codent la largeur et la hauteur du capteur :
| Nom d'octet | MSB | Bit 6 | Bit 5 | Bit 4 | Bit 3 | Bit 2 | Bit 1 | LSB |
|---|---|---|---|---|---|---|---|---|
| octet 16 | w[7] | w[6] | w[5] | w[4] | w[3] | w[2] | w[1] | w[0] |
| octet 17 | w[15] | w[14] | w[13] | w[12] | w[11] | w[10] | w[9] | w[8] |
| octet 18 | h[7] | h[6] | h[5] | h[4] | h[3] | h[2] | h[1] | h[0] |
| octet 19 | h[15] | h[14] | h[13] | h[12] | h[11] | h[10] | h[9] | h[8] |
w (respectivement h ) code la largeur (respectivement la hauteur) du capteur. La coordonnée x (respectivement y) d'un événement doit être comprise dans la plage entière [0, w - 1] (respectivement [0, h - 1] ).
Les octets 20 jusqu'à la fin peuvent être l'un des réinitialisations , débordements , octets 0 , octets 1 , octets 2 , octets 3 et octets 4 . L'ordre possible de ces octets est donné par la machine à états :
Les octets codent les données suivantes :
| Nom d'octet | MSB | Bit 6 | Bit 5 | Bit 4 | Bit 3 | Bit 2 | Bit 1 | LSB |
|---|---|---|---|---|---|---|---|---|
| réinitialiser | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 0 |
| débordement | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 |
| octet 0 | t[6] | t[5] | t[4] | t[3] | t[2] | t[1] | t[0] | is_increase |
| octet 1 | x[7] | x[6] | x[5] | x[4] | x[3] | x[2] | x[1] | x[0] |
| octet 2 | x[15] | x[14] | x[13] | x[12] | x[11] | x[10] | x[9] | x[8] |
| octet 3 | y[7] | y[6] | y[5] | y[4] | y[3] | y[2] | y[1] | y[0] |
| octet 4 | y[15] | y[14] | y[13] | y[12] | y[11] | y[10] | y[9] | y[8] |
la réinitialisation est un événement spécial inséré lorsque cela est jugé nécessaire pour corriger les erreurs de la machine d'état résultant d'erreurs de bits. les octets de réinitialisation doivent être insérés cinq à la fois, de sorte qu'au moins un octet soit lu en état d'inactivité .
t code le temps écoulé depuis l'événement précédent en microsecondes et ne peut pas être 0b1111111 . Si ce temps est égal ou supérieur à 0b1111111 microsecondes, un ou plusieurs octets de débordement sont insérés avant l'événement. Le temps réel écoulé depuis le dernier événement peut être calculé comme l'horodatage de l'événement en cours plus 0b1111111 microsecondes multiplié par le nombre d'octets de débordement .
is_increase est égal à 1 pour les événements d'augmentation légère, et 0 sinon.
x et y codent les coordonnées de pixels associées à l'événement.
Les octets 16 à 19 codent la largeur et la hauteur du capteur :
| Nom d'octet | MSB | Bit 6 | Bit 5 | Bit 4 | Bit 3 | Bit 2 | Bit 1 | LSB |
|---|---|---|---|---|---|---|---|---|
| octet 16 | w[7] | w[6] | w[5] | w[4] | w[3] | w[2] | w[1] | w[0] |
| octet 17 | w[15] | w[14] | w[13] | w[12] | w[11] | w[10] | w[9] | w[8] |
| octet 18 | h[7] | h[6] | h[5] | h[4] | h[3] | h[2] | h[1] | h[0] |
| octet 19 | h[15] | h[14] | h[13] | h[12] | h[11] | h[10] | h[9] | h[8] |
w (respectivement h ) code la largeur (respectivement la hauteur) du capteur. La coordonnée x (respectivement y) d'un événement doit être comprise dans la plage entière [0, w - 1] (respectivement [0, h - 1] ).
Les octets 20 jusqu'à la fin peuvent être l'un des réinitialisations , débordements , octets 0 , octets 1 , octets 2 , octets 3 et octets 4 . L'ordre possible de ces octets est donné par la machine à états :
Les octets codent les données suivantes :
| Nom d'octet | MSB | Bit 6 | Bit 5 | Bit 4 | Bit 3 | Bit 2 | Bit 1 | LSB |
|---|---|---|---|---|---|---|---|---|
| réinitialiser | 1 | 1 | 1 | 1 | 1 | 1 | 0 | 0 |
| débordement | 1 | 1 | 1 | 1 | 1 | 1 | overflow[1] | overflow[0] |
| octet 0 | t[5] | t[4] | t[3] | t[2] | t[1] | t[0] | polarity | is_tc |
| octet 1 | x[7] | x[6] | x[5] | x[4] | x[3] | x[2] | x[1] | x[0] |
| octet 2 | x[15] | x[14] | x[13] | x[12] | x[11] | x[10] | x[9] | x[8] |
| octet 3 | y[7] | y[6] | y[5] | y[4] | y[3] | y[2] | y[1] | y[0] |
| octet 4 | y[15] | y[14] | y[13] | y[12] | y[11] | y[10] | y[9] | y[8] |
la réinitialisation est un événement spécial inséré lorsque cela est jugé nécessaire pour corriger les erreurs de la machine d'état résultant d'erreurs de bits. les octets de réinitialisation doivent être insérés cinq à la fois, de sorte qu'au moins un octet soit lu en état d'inactivité .
t code le temps écoulé depuis l'événement précédent en microsecondes et ne peut pas être 0b111111 . Si ce temps est égal ou supérieur à 0b111111 microsecondes, un ou plusieurs octets de débordement sont insérés avant l'événement. Le temps réel écoulé depuis le dernier événement peut être calculé comme l'horodatage de l'événement en cours plus 0b111111 microsecondes multiplié par le nombre codé par overflow[0] , overflow[1] pour chaque événement de débordement .
is_tc vaut 0 pour un événement DVS, et 1 pour un franchissement de seuil (une demi-mesure d'exposition). polarity stocke is_increase pour un événement DVS et is_second pour le franchissement de seuil.
x et y codent les coordonnées de pixels associées à l'événement.
Les octets 16 jusqu'à la fin peuvent être l'un des éléments suivants : reset , overflow , byte 0 , byte 1 , byte 2 et byte_3 . L'ordre possible de ces octets est donné par la machine à états :
Les octets codent les données suivantes :
| Nom d'octet | MSB | Bit 6 | Bit 5 | Bit 4 | Bit 3 | Bit 2 | Bit 1 | LSB |
|---|---|---|---|---|---|---|---|---|
| réinitialiser | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 0 |
| débordement | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 |
| octet 0 | t[7] | t[6] | t[5] | t[4] | t[3] | t[2] | t[1] | t[0] |
| octet 1 | x[7] | x[6] | x[5] | x[4] | x[3] | x[2] | x[1] | x[0] |
| octet 2 | y[7] | y[6] | y[5] | y[4] | y[3] | y[2] | y[1] | y[0] |
| octet 3 | s[7] | s[6] | s[5] | s[4] | s[3] | s[2] | s[1] | s[0] |
la réinitialisation est un événement spécial inséré lorsque cela est jugé nécessaire pour corriger les erreurs de la machine à états résultant d'erreurs de bits. les octets de réinitialisation doivent être insérés quatre à la fois, de sorte qu'au moins un octet soit lu en état d'inactivité .
t code le temps écoulé depuis l'événement précédent en microsecondes et ne peut pas être 0b11111110 ni 0b11111111 . Si ce temps est égal ou supérieur à 0b11111110 microsecondes, un ou plusieurs octets de débordement sont insérés avant l'événement. Le temps réel écoulé depuis le dernier événement peut être calculé comme l'horodatage de l'événement en cours plus 0b11111110 microsecondes multiplié par le nombre d'octets de débordement .
x et y codent les coordonnées de pixels associées à l'événement.
s code l'étape actuelle dans la pyramide. En dehors de l'affichage, sa valeur doit être 0b00000000 (voir la documentation de l'affichage asynchrone et modulaire pour plus de détails).
Les octets 16 à 19 codent la largeur et la hauteur du capteur :
| Nom d'octet | MSB | Bit 6 | Bit 5 | Bit 4 | Bit 3 | Bit 2 | Bit 1 | LSB |
|---|---|---|---|---|---|---|---|---|
| octet 16 | w[7] | w[6] | w[5] | w[4] | w[3] | w[2] | w[1] | w[0] |
| octet 17 | w[15] | w[14] | w[13] | w[12] | w[11] | w[10] | w[9] | w[8] |
| octet 18 | h[7] | h[6] | h[5] | h[4] | h[3] | h[2] | h[1] | h[0] |
| octet 19 | h[15] | h[14] | h[13] | h[12] | h[11] | h[10] | h[9] | h[8] |
w (respectivement h ) code la largeur (respectivement la hauteur) du capteur. La coordonnée x (respectivement y) d'un événement doit être comprise dans la plage entière [0, w - 1] (respectivement [0, h - 1] ).
Les octets 20 jusqu'à la fin peuvent être l'un des réinitialisations , débordements , octets 0 , octets 1 , octets 2 , octets 3 , octets 4 , octets 5 , octets 6 et octets 7 . L'ordre possible de ces octets est donné par la machine à états :
Les octets codent les données suivantes :
| Nom d'octet | MSB | Bit 6 | Bit 5 | Bit 4 | Bit 3 | Bit 2 | Bit 1 | LSB |
|---|---|---|---|---|---|---|---|---|
| réinitialiser | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 0 |
| débordement | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 |
| octet 0 | t[7] | t[6] | t[5] | t[4] | t[3] | t[2] | t[1] | t[0] |
| octet 1 | x[7] | x[6] | x[5] | x[4] | x[3] | x[2] | x[1] | x[0] |
| octet 2 | x[15] | x[14] | x[13] | x[12] | x[11] | x[10] | x[9] | x[8] |
| octet 3 | y[7] | y[6] | y[5] | y[4] | y[3] | y[2] | y[1] | y[0] |
| octet 4 | y[15] | y[14] | y[13] | y[12] | y[11] | y[10] | y[9] | y[8] |
| octet 5 | r[7] | r[6] | r[5] | r[4] | r[3] | r[2] | r[1] | r[0] |
| octet 6 | g[7] | g[6] | g[5] | g[4] | g[3] | g[2] | g[1] | g[0] |
| octet 7 | b[7] | b[6] | b[5] | b[4] | b[3] | b[2] | b[1] | b[0] |
la réinitialisation est un événement spécial inséré lorsque cela est jugé nécessaire pour corriger les erreurs de la machine d'état résultant d'erreurs de bits. les octets de réinitialisation doivent être insérés hauteur à la fois, de sorte qu'au moins un octet soit lu en état d'inactivité .
t code le temps écoulé depuis l'événement précédent en microsecondes et ne peut pas être 0b11111110 ni 0b11111111 . Si ce temps est égal ou supérieur à 0b11111110 microsecondes, un ou plusieurs octets de débordement sont insérés avant l'événement. Le temps réel écoulé depuis le dernier événement peut être calculé comme l'horodatage de l'événement en cours plus 0b11111110 microsecondes multiplié par le nombre d'octets de débordement .
x et y codent les coordonnées de pixels associées à l'événement.
r , g et b codent les composantes de couleur rouge, verte et bleue.
Consultez le fichier LICENSE pour connaître les droits et limitations de licence (GNU GPLv3).
