Format de fil
Pour les intégrations qui diffusent depuis un serveur plutôt qu’un navigateur : le transport, les flux, les octets.
Alpha — à lire d’abord
Tout ce qui est sur cette page est alpha : cela peut changer sans période de dépréciation, et un changement peut vous obliger à réécrire. La librairie que documente le reste de cette section le cache précisément pour que la plupart des intégrations n’aient jamais à le lire.
Parlez-nous avant de bâtir dessus. Si vous pouvez faire tourner notre module dans un navigateur, faites-le plutôt.
Il y a un cas pour lequel cette page existe : la vidéo ne passe pas par un navigateur que vous maîtrisez. Une téléconsultation dont le serveur média détient déjà le flux, un fichier enregistré rejoué pour une validation, une application mobile avec sa propre chaîne de capture — ceux-là ne peuvent pas charger un module ES, et parlent au transport directement.
Le transport
WebTransport, c’est-à-dire HTTP/3 sur QUIC. Une session par mesure, ouverte contre le serveur d’analyse de l’environnement que vous mesurez — le même hôte que la librairie déduit d’elle-même, sur le port HTTPS standard :
https://api-webtransport.<hôte de votre environnement>/measures?accessTokenValue=<jeton>&visual=<…>
Quel hôte, cela dépend de votre environnement :
| Environnement | Adresse de session |
|---|---|
| Production | https://api-webtransport.saphere.ai/measures |
| Test | https://api-webtransport.test.saphere.ai/measures |
Une intégration de serveur à serveur n’est pas pour autant de celles qu’on branche seul : dites-nous la forme de votre source avant de commencer.
Le jeton d’accès voyage dans l’adresse, sous le paramètre de requête accessTokenValue : un navigateur ne peut poser aucun en-tête sur une poignée de main WebTransport, et l’interface est la même pour tous. Il se frappe exactement comme pour la librairie, avec la permission measurement.realtime, et la poignée de main le consomme.
Un seul chemin, et une session qui déclare ce qu’elle enverra
Il n’y a qu’une adresse. Ce qu’une session enverra se déclare dans ses paramètres, un par modalité — ce qui est ce qui permettra d’ajouter une modalité sans ajouter d’adresse.
https://api-webtransport.<hôte de votre environnement>/measures
?accessTokenValue=<jeton>
&visual=<ce que la caméra envoie>
&format=<conteneur> # vidéo seulement
&timeOrigin=<millisecondes> # facultatif, images seulement
&loggerId=<uuid> # facultatif
visual | Ce que vous envoyez | Ce que le serveur fait |
|---|---|---|
images-parts | des recadrages RGB — un visage, un torse | les mesure tels quels |
images-full | des images RGB entières | trouve le visage, recadre, mesure |
video-parts | une vidéo d’un recadrage | la découpe en images, les mesure telles quelles |
video-full | une vidéo d’images entières | découpe, trouve le visage, recadre, mesure |
format dit le conteneur — webm, mp4, ou h264 pour un flux brut en Annexe B — et n’appartient qu’à une session vidéo : déclaré sur une session d’images, il est refusé, parce que rien ne le lirait.
timeOrigin est facultatif, et n’appartient qu’à une session d’images : l’origine de vos horodatages, en millisecondes, un nombre entier de 0 à 2147483647 — 0 quand il est absent. Le serveur la retire du time de chaque image à son arrivée, si bien que les temps qu’il renvoie comptent depuis votre origine plutôt que depuis là où se trouvait votre horloge : avec timeOrigin=2000, une image capturée à 2010 est une image à 10, et le sont aussi le point hr et les variables calculés sur elle. Prenez-la sur l’horloge qui horodate vos images, juste avant d’ouvrir la session — aucune image ne peut être plus ancienne que l’origine. Déclaré sur une session vidéo, il est refusé : là, les temps se lisent dans votre conteneur, ils ne sont pas envoyés. Tout temps que le serveur garde ou renvoie est sur cette échelle, à partir de 0 — y compris la durée que l’API donne, après coup, pour une mesure temps réel.
loggerId est facultatif et ne fait qu’informer : un UUID tiré au hasard qui identifie l’instance de votre page, et que le serveur écrit sur les lignes de journal de la session pour qu’une session se retrouve jusqu’à la page qui l’a ouverte. Une valeur qui n’est pas un UUID est ignorée — jamais un motif de refus — et rien de ce que fait le serveur n’en dépend.
voice est la modalité suivante. Elle est déjà dans le vocabulaire, et une session qui la déclare est refusée — rien ne mesure encore une voix, et servir une telle session sur sa seule moitié visuelle vous laisserait croire qu’une mesure a lieu là où il n’y en a aucune.
Tout est vérifié à la poignée de main, avant que rien ne soit écrit, si bien qu’aucune mesure n’existe et qu’aucun jeton n’est dépensé pour une session qui n’aurait rien mesuré. Les contrôles se font famille par famille, dans l’ordre du tableau : la capacité, la forme du jeton, ce que la session déclare, puis le jeton et le compte. La première famille qui refuse répond ; à l’intérieur d’une famille, une session qui cumule deux fautes peut recevoir l’un ou l’autre statut.
| Statut | Quand |
|---|---|
503 | Le serveur est plein ou sous pression mémoire. Rien n’a encore été lu : c’est un réessayez dans un instant, jamais un problème de jeton. |
401 | Pas d’accessTokenValue, ou une valeur qui n’a pas la forme d’un jeton. |
400 | visual absent ou inconnu ; format absent ou inconnu sur une session vidéo ; format déclaré sur une session d’images ; timeOrigin qui n’est pas un nombre entier de 0 à 2147483647, ou déclaré sur une session vidéo. |
501 | voice déclaré ; une session d’images entières alors que le serveur ne sait pas détecter de visage ; une session vidéo alors qu’il ne sait pas décoder de vidéo. |
401 | Le jeton est expiré, déjà dépensé, révoqué, frappé sans measurement.realtime, ou son compte a été désactivé. |
403 | La mesure temps réel n’est pas disponible sur votre compte : aucun coût n’y a été posé. Ou le crédit restant du mois ne couvre pas la première tranche, qu’une session paie à son ouverture. |
Seule une session qui s’ouvre dépense son jeton, et sa première tranche de crédit. Un navigateur n’expose pas ces statuts — sa promesse ready échoue de la même façon pour tous —, ils sont donc là pour un client à vous.
Entrée : un flux par source
Vous ouvrez un flux unidirectionnel — le serveur ne fait que le lire —, écrivez ce que votre session n’a pas déjà dit, puis envoyez. Sur une session d’images, un message par image, bout à bout ; sur une session vidéo, les octets du conteneur tels quels.
| Champ d’en-tête | Octets | Valeur |
|---|---|---|
content | 1 | 0 visage, 1 torse — images-parts et video-parts seulement |
Tous les entiers sont non signés et gros-boutistes.
| Champ de message | Octets | Valeur |
|---|---|---|
index | 4 | la capture à laquelle cette image appartient. Il peut sauter. |
time | 4 | l’horodatage de capture, en millisecondes. Il ne recule jamais au sein d’un flux, et n’est jamais plus ancien que le timeOrigin de la session. |
flags | 1 | bit 0 : la charge est compressée en brotli. Les sept autres sont réservés. |
width | 2 | la largeur de cette image, de 1 à 1920 — la hauteur qu’elle implique ne peut pas non plus dépasser 1920, et l’image ne peut pas compter plus de pixels que 1920 × 1080 |
length | 4 | la longueur de la charge, de 1 octet à 10 Mio |
La charge est du RGB sur 8 bits, entrelacé — R, G, B pour chaque pixel, sans alpha, pas du BGR. index et time sont des entiers non signés de 32 bits : comptez time depuis le début de votre capture, et non depuis l’époque Unix, dont les millisecondes ne tiennent plus sur 32 bits (le plafond est 4294967295 ms, soit environ 49,7 jours).
En code, un message d’une session d’images :
// Le flux d'une session `images-parts` s'ouvre, une seule fois, sur son octet `content` : `0` visage, `1` torse.
function encodeMessage({ index, time, width, rgb }) { // rgb : width × height × 3 octets
const message = new Uint8Array(15 + rgb.length)
const view = new DataView(message.buffer) // gros-boutiste, ce qui est la valeur par défaut
view.setUint32(0, index) // la capture à laquelle cette image appartient
view.setUint32(4, time) // son horodatage de capture, en millisecondes
view.setUint8(8, 0) // drapeaux : bit 0 à zéro, la charge n'est pas compressée
view.setUint16(9, width)
view.setUint32(11, rgb.length) // la longueur de la charge
message.set(rgb, 15)
return message
}
Cinq choses ne s’en devinent pas :
- La hauteur ne voyage pas. Une charge RGB décompressée pèse
width × height × 3, donc la hauteur se déduit de la longueur — et ce qui est gagné n’est pas un octet, c’est le droit de changer de taille d’une image à l’autre : un recadrage suit un visage qui bouge. Une longueur qui ne fait pas des lignes entières est refusée plutôt que devinée. indexest celui de la capture, et il saute. Une image sans visage n’est jamais envoyée, donc la suite a des trous. Ne renumérotez pas pour les refermer : le trou est ce qui dit qu’un moment n’a pas été mesuré.timeest l’horodatage de capture, pas celui de l’envoi. C’est lui dont la mesure tire une fréquence cardiaque. Le déduire d’un compteur d’images divise le pouls par la cadence que vous avez supposée, et l’erreur est silencieuse — l’indice de qualité ne l’attrapera pas.- La compression est par message. Le drapeau est relu à chaque image, si bien qu’un émetteur peut cesser de compresser sous charge sans rien renégocier.
- Un flux par contenu. Un second flux du même contenu met fin à la session : il ouvrirait une seconde mesure de la même chose, et entrelacerait deux signaux sans qu’aucune erreur ne soit levée. Cela vaut même une fois le premier flux terminé : un contenu ne s’ouvre pas deux fois dans une session. Un flux d’un autre contenu est accepté — c’est ainsi qu’un visage et un torse voyagent ensemble —, tandis qu’une session d’images entières ne porte qu’un flux en tout.
Un flux malformé met fin à la session, il n’est pas sauté. Un octet de contenu inconnu, une largeur ou une hauteur hors bornes, une charge vide ou démesurée, une longueur décompressée qui ne fait pas des lignes entières, un horodatage qui recule ou qui est plus ancien que le timeOrigin déclaré par la session, un flux qui s’arrête au milieu d’un message, un second flux du même contenu : chacun ferme la session entière, avec le code de fermeture 1 et la raison measure stream failed. Le code 1 est celui du serveur, et pas seulement pour un flux malformé : une panne du côté du serveur met fin à la session de la même façon. Quand le serveur lui-même s’arrête — pour un redémarrage, par exemple —, il ferme toutes les sessions ouvertes avec le code 0 et la raison Server shutting down : ouvrez-en une nouvelle, avec un nouveau jeton. Quand vous fermez une session vous-même, la convention de la librairie est 2 pour un arrêt demandé, 3 pour un abandon et 4 quand sa propre chaîne de capture est tombée.
Le crédit se paie d’avance, par tranche de 60 secondes : la première à l’ouverture de la session — une session dont le crédit ne la couvre pas est refusée à la poignée de main, en 403 —, puis une au début de chaque minute de plus que la session reste ouverte, qu’elle reçoive des données ou non. Une session dont le crédit ne couvre plus la tranche suivante est fermée par le serveur, avec le code de fermeture 5 et la raison credit exceeded — voir le système de crédits dans la FAQ. Rien de ce qui a été reçu n’est perdu : ce qui a été mesuré le reste. Rien n’est décompté à la fermeture, la tranche en cours étant déjà payée ; la session la plus courte coûte une tranche.
Une session vidéo ne porte aucun message
Après son en-tête — l’octet de contenu sur une session video-parts, rien du tout sur une session video-full —, une session vidéo prend les octets du conteneur, tels quels : aucun cadrage par image, le conteneur ayant déjà le sien. Le serveur découpe les images lui-même, et quatre de ses règles vous concernent :
mp4veut dire mp4 fragmenté. Un mp4 ordinaire porte son index à la fin, si bien qu’un flux qui en porte un ne rend aucune image. Ce que produit l’enregistreur d’un navigateur est déjà fragmenté ; un fichier poussé depuis un disque, généralement pas.- La cadence est un plafond, pas une cible. Le serveur garde au plus 30 images par seconde et suit votre source en dessous — le décodeur ne recopie jamais une image pour atteindre une cadence. Les horodatages qu’il emploie sont ceux que votre conteneur porte.
- Rien n’est redimensionné. Les images sont décodées à la taille de votre source, ce qui est aussi pourquoi aucune dimension n’est déclarée. Une source qui change de résolution en cours de route est refusée, de même qu’une image dont un côté dépasse 1920 ou qui compte plus de pixels que 1920 × 1080 — une source portrait en 1080 × 1920 est acceptée, un carré de 1920 × 1920 ne l’est pas.
- Les horodatages négatifs de tête sont recalés ; les illisibles, et ceux qui reculent, sont refusés. Un conteneur à liste d’édition — une capture iOS, typiquement — commence légitimement quelques images avant zéro : l’échelle est décalée pour que rien ne précède zéro, tous les écarts étant préservés — et les écarts sont la seule chose qu’une fréquence cardiaque lit. Une image dont l’horodatage ne se lit pas refuse la session plutôt que de deviner.
Sortie : un flux par nature
Le serveur ouvre les flux de retour, un par nature. Chacun commence par un octet qui le nomme, puis porte des messages JSON cadrés par leur longueur — quatre octets de longueur gros-boutiste, puis la charge.
| Octet | Flux | Ce qu’il porte |
|---|---|---|
0 | hr | l’onde de pouls : { index, time, value } |
1 | br | l’onde respiratoire : { index, time, value } |
2 | variables | les grandeurs, une fois par seconde — la forme même que la librairie rapporte |
3 | session | l’identifiant de la mesure : { measureId } |
session arrive en premier. Le serveur l’ouvre dès que la session est établie, y écrit un seul message et le ferme. measureId nomme la mesure que cette session enregistre : transmettez-le à votre serveur, qui lit la mesure avec sa clé d’API — l’essentiel, et ses sorties une fois enregistrées.
La liste des natures est ouverte. Une nature que votre lecteur ne connaît pas se lit jusqu’au bout et se jette, jamais comme une erreur : des natures peuvent s’ajouter, et un client qui s’arrêterait sur une inconnue casserait le jour où elles arrivent.
Il n’y a aucun discriminant dans un message : le flux a dit sa nature une fois, à son début. C’est ce qui permet à un lecteur de ne s’abonner qu’aux grandeurs et de ne jamais décoder une onde qu’il ne dessine pas. Le lecteur doit tout de même lire ce flux, et le jeter : un flux que personne ne lit finit par retenir les autres.
Les deux signaux ont la même forme, et c’est délibéré : un lecteur qui sait dessiner l’un sait dessiner l’autre, et un signal ajouté plus tard ne lui apprendra rien de nouveau. Un point dit trois choses — où il se place dans son signal, quand il a été capturé, et ce qu’il vaut.
Ils n’arrivent pas au même rythme, parce qu’ils ne se lisent pas sur la même chose. Le pouls donne un point par image de visage mesurée ; la respiration, un point par image de torse mesurée — c’est le mouvement de la cage thoracique, là où la respiration a lieu. Les deux index sautent, et pour la même raison : une capture sans visage à mesurer — ou sans torse — ne donne pas de point. Une session qui n’envoie pas de torse n’a donc aucune onde respiratoire à tracer — pas plus qu’une session d’images entières, images-full ou video-full : le serveur trouve le visage dans une image entière, pas le torse. Sa fréquence respiratoire vient alors de la lente modulation de l’onde de pouls — variables dit laquelle des deux vous lisez.
La value d’un point respiratoire est un déplacement, pas un niveau : le mouvement vertical cumulé de la cage thoracique, en cent-vingt-huitièmes de la hauteur du recadrage du torse sur lequel il a été mesuré — une unité qui ne change pas avec la taille du recadrage. Son origine est là où se trouvait la première image, et elle dérive lentement, si bien que seule la variation veut dire quelque chose. Calez un graphe sur le minimum et le maximum de ce qu’il montre, jamais sur zéro.
Une session vidéo, de bout en bout
Ce qui suit est le client entier, en une page. C’est du code de navigateur — WebTransport est une interface de navigateur — et une intégration serveur n’en diffère que d’une ligne : Node n’a pas de WebTransport à lui, et @fails-components/webtransport fournit un client de même interface (import { WebTransport } from "@fails-components/webtransport").
L’envoi
Une session, un flux unidirectionnel, aucun en-tête — la session a tout déclaré dans son adresse —, puis votre vidéo telle qu’elle vient.
const origin = "https://api-webtransport.<votre hôte>"
const url = `${origin}/measures`
+ `?visual=video-full` // des images entières, dans un conteneur : le serveur cherche le visage
+ `&format=webm` // le conteneur — déclaré ici, et non sur le fil
+ `&accessTokenValue=${encodeURIComponent(token)}`
const session = new WebTransport(url)
const unanswered = new Promise((_, reject) =>
setTimeout(reject, 10_000, new Error("la poignée de main n'a pas reçu de réponse en 10 secondes")))
await Promise.race([session.ready, unanswered]) // l'attente est bornée, comme la librairie la borne
const writer = (await session.createUnidirectionalStream()).getWriter()
// Aucun en-tête : une session qui envoie des images entières n'a plus rien à déclarer, et son conteneur
// est dans l'adresse. La taille des images est celle de votre source, que le serveur lit dans le flux.
// Directement les octets du conteneur. Rien ne les cadre : votre vidéo, octet pour octet.
const camera = await navigator.mediaDevices.getUserMedia({ video: true, audio: false })
const mimeType = ["video/webm;codecs=h264", "video/webm"].find(type => MediaRecorder.isTypeSupported(type))
const recorder = new MediaRecorder(camera, { mimeType, videoBitsPerSecond: 2_500_000 })
recorder.ondataavailable = async event => {
if (event.data.size === 0) return
await writer.ready // contre-pression : QUIC fait attendre
await writer.write(new Uint8Array(await event.data.arrayBuffer()))
}
recorder.start(200) // un fragment toutes les 200 ms
L’attente de ready est bornée à dix secondes, comme la librairie la borne : certains navigateurs n’acceptent ni ne refusent la poignée de main — voir ce que le navigateur doit fournir.
La fin se fait en deux gestes, dans cet ordre. await writer.close() termine la vidéo — et la mesure n’est pas finie pour autant : des images sont encore dans le décodeur et leurs résultats arrivent encore. Fermez la session une fois que vous avez lu ce que vous étiez venu chercher.
La réception
Le serveur ouvre session en premier, dès que la session est établie ; puis un flux par nature, à la première valeur de cette nature : l’onde de pouls en une seconde environ, les grandeurs vers sept secondes, l’onde respiratoire dès qu’une image de torse a été mesurée — ce qui, sur une session d’images entières comme celle-ci, n’arrive jamais. Acceptez donc les flux entrants pendant toute la session, et lisez chacun à côté des autres — une boucle qui attend la fin d’un flux ne voit jamais le suivant.
const KINDS = ["hr", "br", "variables", "session"]
const incoming = session.incomingUnidirectionalStreams.getReader()
for (;;) {
const { value, done } = await incoming.read()
if (done) break
readOutputStream(value, onMessage) // pas attendu : les flux se lisent de front
}
Puis le lecteur lui-même. QUIC livre des morceaux, pas des messages : une frontière tombe au milieu d’un cadre aussi volontiers qu’ailleurs, et l’octet de nature peut arriver seul. D’où le tampon.
async function readOutputStream(stream, onMessage) {
const reader = stream.getReader()
let buffer = new Uint8Array(0)
let kind = null
for (;;) {
const { value, done } = await reader.read()
if (done) return
const merged = new Uint8Array(buffer.length + value.length)
merged.set(buffer, 0)
merged.set(value, buffer.length)
buffer = merged
if (kind === null) {
if (buffer.length < 1) continue
kind = KINDS[buffer[0]] ?? `inconnu(${buffer[0]})`
buffer = buffer.subarray(1) // la nature se lit une fois, et une seule
}
for (;;) {
if (buffer.length < 4) break
const length = new DataView(buffer.buffer, buffer.byteOffset)
.getUint32(0, false)
if (buffer.length < 4 + length) break
const payload = buffer.subarray(4, 4 + length)
onMessage(kind, JSON.parse(new TextDecoder().decode(payload)))
buffer = buffer.subarray(4 + length)
}
}
}
Ce qui redescend
function onMessage(kind, message) {
if (kind === "hr") chart.push(message.time, message.value)
if (kind === "br") breathing.push(message.time, message.value)
if (kind === "variables") panel.show(message)
if (kind === "session") measureId = message.measureId // pour votre serveur, ensuite
// toute autre nature : l'ignorer — la liste est ouverte
}
hr arrive à la cadence des images de visage mesurées, br à celle des images de torse mesurées, et variables une fois par seconde de capture (un fichier poussé plus vite que le réel les reçoit plus vite) — rien du tout tant que la fenêtre est trop courte, si bien qu’un silence au début veut dire pas encore, jamais rien à mesurer.
Champ de variables | Ce qu’il faut en faire |
|---|---|
heartRate, breathingRate | Les deux chiffres qu’un utilisateur attend : battements par minute, et respirations par minute. L’un comme l’autre peut valoir null quand le signal ne permet pas de lecture — testez avant de formater ; heartRateIntervals et breathingSource aussi. |
breathingSource, breathingQuality, breathingWindowS | D’où la fréquence respiratoire a été lue — motion du torse, bvp de l’onde de pouls —, avec quelle netteté (de 0 à 1), et sur combien de secondes. Les deux dernières valent null pour bvp. Une session qui envoie un torse peut aussi rapporter bvp, tant que la lecture du torse n’a pas abouti — elle demande plusieurs dizaines de secondes, et reprend à zéro après plus de deux secondes sans torse —, si bien que breathingSource peut changer en cours de mesure. |
Délai de breathingRate | Une fréquence lue sur le torse demande environ 30 secondes : le serveur refuse de nommer un rythme tant qu’une lecture d’il y a dix secondes ne confirme pas celle du moment. Un rythme qui dérive est suivi ; un thorax qui ne respire pas ne donne aucune lecture du torse plutôt qu’un chiffre ; et plus de deux secondes sans torse font reprendre la lecture à zéro. |
stars, sqi | La qualité du signal, en un nombre entier d’étoiles de 0 à 5 et en indice brut de 0 à 1. |
mature | false tant que dix secondes n’ont pas été mesurées. Dites « mesure en cours », pas un chiffre. |
confident | false quand la qualité ne franchit pas le seuil, ou quand des images ont manqué — environ 40 % des dix dernières secondes ou davantage — au point que le signal est en grande partie comblé plutôt que mesuré, même si sa qualité paraît correcte. Le champ ne dit pas lequel des deux. Montrez-le comme provisoire. |
sdnn, rmssd, pnn50, sd1, sd2, lfHf | La variabilité — en millisecondes, sauf pnn50, un pourcentage, et lfHf, un rapport —, null quand la qualité n’a pas permis de la calculer. |
heartRateIntervals, beats, rejected | La fréquence par les intervalles, en battements par minute, et combien d’intervalles entre battements ont été retenus et écartés. |
time | Le temps de capture de l’image pour laquelle ces valeurs ont été calculées, en millisecondes — la même échelle que le time des points hr et br, votre timeOrigin déjà retiré. C’est un nombre entier. |
healthIndex | Réservé : il demande l’âge du sujet, qu’une session n’a aujourd’hui aucun moyen de recevoir, si bien qu’il vaut toujours null. |
Un champ de variabilité à null veut dire aucune mesure — jamais zéro, qui serait la lecture d’un cœur parfaitement régulier.
hr et br portent chacun index, la capture à laquelle leur point appartient, et tous deux sautent : une capture sans visage à mesurer — pour br, sans torse — ne donne pas de point. Dessinez ces trous comme des trous. Refermer la ligne dirait à un lecteur que le signal était continu alors qu’il ne l’était pas, et l’index est la seule chose qui dise le contraire. Une image qui atteint la mesure sans pouvoir y être mesurée donne tout de même un point, à la valeur précédente : un palier n’est pas un trou, et rien sur le fil ne distingue les deux. Sur une session vidéo vous n’envoyez aucun index : celui qui revient est le rang, à partir de 0, de chaque image que le serveur a gardée — pas une position dans votre source.
Ne recalculez pas
Les points d’onde sont ceux du serveur, calculés sur le signal entier qu’il détient. En tirer votre propre fréquence cardiaque, sur la tranche que vous avez reçue, produirait une seconde valeur, différente et sans autorité derrière elle.Cinq choses à ne pas manquer
- Rien n’est déclaré de la taille, et rien n’est redimensionné. Les images sont décodées à la taille de votre source — aucun côté au-delà de 1920 et pas plus de pixels que 1920 × 1080, au-delà de quoi la session est refusée. Le paysage 1920 × 1080 comme le portrait 1080 × 1920 tiennent. Envoyer une source plus petite reste la façon la moins chère d’utiliser moins de bande passante et de calcul, de votre côté comme du nôtre.
mp4veut dire mp4 fragmenté. Un mp4 ordinaire porte son index à la fin, donc un flux qui en est fait ne rend aucune image. Un enregistreur de navigateur produit déjà des fragments ; un fichier poussé depuis un disque, en général non.- La cadence est un plafond, et elle a un plancher. Trente images par seconde au plus, et la cadence de votre source en dessous — le décodeur ne recopie jamais une image, si bien qu’une source à 25 images est mesurée à 25. Mais la mesure elle-même avance sur une grille de 30 pas par seconde : quand deux images sont distantes de plus de 50 ms — toute source sous 20 images par seconde, et une source à 20 dès que sa cadence a de la gigue —, elle comble l’écart en répétant l’image courante, et ces répétitions comptent comme des images manquantes pour
confident. Envoyez 25 images par seconde ou davantage. - Les horodatages viennent de votre conteneur, image par image, et ce sont eux dont se lit une fréquence cardiaque. Un conteneur écrit avec une base de temps inventée ou constante rend un pouls plausible et pourtant faux, que l’indice de qualité ne rattrapera pas.
- Écrivez avec la contre-pression.
await writer.readyavant chaque écriture. Sans elle, un lien lent devient de la mémoire dans votre propre processus, et la panne apparaît là où elle n’a pas commencé.
Ce qui n’est pas arrêté
Étant alpha, voici où cela bouge : le chemin vidéo n’accepte pas d’horodatages par image qui lui soient propres, le serveur ne trouve pas de torse dans une image entière — la respiration ne se lit sur la cage thoracique que si vous en envoyez le recadrage —, et composer un visage depuis une image entière que vous envoyez aussi n’est pas implémenté : une image entière est mesurée par la détection du serveur, ou pas du tout.