Flux réseau

Version imprimable

Voir 40 message(s) de cette discussion en une page

31/10/2022, 11h37
cobra38

Citation:

Envoyé par jackk

En fait, je ne comprends pas trop la ligne

Code:

int s = ((size > sizeof(buff)) ? sizeof(buff) : size);

size représente la taille d'un paquet reçu: 1436, 2872 ou 4308 octets. Pourquoi la comparer avec la taille du buffer permettant de stocker la totalité des données envoyées par le serveur?

Je suppose que c'est un code que tu as trouvé sur le net. Pourrais-tu nous donner une référence sur le code d'origine?

j'aurais du commencer effectivement par çà
il s'agit de cela :

https://github.com/HWHardsoft/AZ-Tou...ESP32Video.ino
31/10/2022, 11h50
jackk

j'ai effectué une petite modification dans mon message précédent pendant que tu répondais.
31/10/2022, 11h58
cobra38

Citation:

PS: j'ai trouvé le code. Est-ce que l'image est bien générée avec une ESP32-CAM?

Non , l'image est générée par une cam indépendante via le flux reseau
si j'interroge l'url , celle-ci répond par une image
donc je pensais avoir le plus gros du travail à savoir
retrouver le flux réseau de ma cam
en fait je ne pensais pas avoir le problème de pille de l'ESP32
d'où ma demande ....

PS : j'ai trouvé un autre exemple
https://www.teachmemicro.com/update-...al-web-server/
ce qui confirmerez le code utilisé
31/10/2022, 12h19
jackk

Peut-être que ta webcam possède une meilleure résolution que celle de l'ESP32-CAM et envoie des images de taille plus importante, et donc trop volumineuse pour les 20 Ko du buffer.

Pour le reste, il y a tout de même des parties de code suspectes dont je ne m'explique pas le fonctionnement.
31/10/2022, 12h34
cobra38

1 pièce(s) jointe(s)

j'ai fait une petite modification
dont voici le resultat sur la console

******************************************
Pièce jointe 628096

******************************************
il semblerait que l'image de 1280 x 720 => doit être d'abord compressée
pour rentrer dans 320 x 240
mais comment faire pour compresser cette image "url" avant de la traiter ?
31/10/2022, 13h36
jackk

Tu ne peux pas paramétrer la résolution de ta WEBCAM, le temps de faire des essais?
31/10/2022, 14h16
cobra38

Citation:

Tu ne peux pas paramétrer la résolution de ta WEBCAM, le temps de faire des essais?

Non je ne vois pas comment , j'avais déjà essayé
mais je n'ai que certains réglages à savoir :
- débit binaire en kbps (32 à 6144) regalge '1024=
- fréquence d'images max : 1-25 fps
- qualité : 1-6

même en diminuant le débit binaire à 32 , je n'ai pas constaté de changement

Citation:

Envoyé par cobra38

Ce qui laisse à penser que le programme tourne mais je me l'explique pas car je n'ai pas touché à : uint8_t buff[20000] = { 0 };

Citation:

Le buffer est en variable globale depuis le début.

dans le code posté au message #5 (hier à 15h54) vous aviez
Code:

1 2 3 4 5 6 7 8 if (len <= 0) { Serial.printf("[HTTP] Unknow content size: %d\n", len); } else { // create buffer for read uint8_t buff[1024] = { 0 }; // <= j'ai donc activé cette ligne avec un buffer = 1024 et là c'est le plantage complet // get tcp stream WiFiClient * stream = http.getStreamPtr();
donc le buffer n'était pas en variable globale ==> allocation sur la pile qui est limitée.

maintenant le code que vous postez a bien le buffer en variable globale et vous avez commenté l'allocation sur la pile dans la fonction
Citation:
Envoyé par cobra38
Code:

1 2 3 4 5 } else { // create buffer for read //uint8_t buff[len] = { 0 }; //uint8_t buff[len] = { 0 };
pour moi il n'y rien de mystérieux...

la déclaration en variable globale met les données ni dans la pile, ni dans le tas mais dans un segment mémoire défini à la compilation pour les data. il y a plus de flexibilité

31/10/2022, 15h24
cobra38

Re Jay M

Je pense qu'il y a confusion et je plaide coupable
le uint8_t buff[20000] = { 0 };
était au départ sauf erreur en #1 en variable globale et c'est moi qui ait dé commenté par la suite la ligne pour essais ( mea culpa)

mais je pense que le problème est plus complexe
j'essaie en fait de faire rentrer une image de 1280 x 720 (133k) dans 320 x 240
soit la dimension max pour affichage avec TFT
mon problème restera insoluble si je n'arrive pas :
1) soit à compresser l'image reçue par url
2) soit envoyer par la webcam une image déjà formatée en 320x240

pour le point 2 ce n'est pas possible , je n'ai pas la possibilité de changer la résolution
reste donc le point 1 : mais je n'ai pas trouvé de bibliothèque ad'hoc
je lance donc un appel aux bonnes volontés
31/10/2022, 16h12
Jay M

[QUOTE=cobra38;11888508]
j'essaie en fait de faire rentrer une image de 1280 x 720 (133k) dans 320 x 240
/QUOTE]
vous perdez le ratio en faisant cela (÷4 sur les X et ÷3 sur les Y)

un algo simple c'est de prendre un pixel sur 4 sur les X et un sur le 3 sur les Y...
un algo abordable c'est de faire une "bilinear interpolation" vous avez un algo ici --> https://rosettacode.org/wiki/Bilinear_interpolation#C
31/10/2022, 16h33
cobra38

j'ai trouvé çà comme librairie

https://github.com/luisllamasbinabur...-Interpolation

c'est cela ?
31/10/2022, 17h47
Jay M

vu que vous avez déjà un tableau je prendrais directement le code en C du lien précédent
31/10/2022, 18h15
cobra38

Désolé mais je ne comprends pas bien , son utilisation
s'il s'agit bien de :

#include <stdint.h>
31/10/2022, 20h17
jackk

Le problème, c'est qu'il faut réduire l'image à la source puisqu'elle est trop volumineuse pour la charger avec la résolution de la WEBCAM.

PS: il y a peut-être possibilité de la réduire, mais au fur et à mesure de sa réception: un petit buffer pour réceptionner les paquets, et un plus gros pour stocker l'image réduite.
31/10/2022, 20h32
cobra38

Il n'existe pas de librairies capables faire ce travail de compression ?
31/10/2022, 21h08
Jay M

Il me semblait qu’avec la variable globale le chargement total fonctionnait

Pour le code c’est tout ce qui est dans le lien - il y a la définition de la structure et une fonction de compression

parlez-vous de ce code ? svp ?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
 
#include <stdint.h>
typedef struct {
    uint32_t *pixels;
    unsigned int w;
    unsigned int h;
} image_t;
#define getByte(value, n) (value >> (n*8) & 0xFF)
 
uint32_t getpixel(image_t *image, unsigned int x, unsigned int y){
    return image->pixels[(y*image->w)+x];
}
 
float max(float a, float b) { return (a < b) ? a : b; };
float lerp(float s, float e, float t){return s+(e-s)*t;}
float blerp(float c00, float c10, float c01, float c11, float tx, float ty){
    return lerp(lerp(c00, c10, tx), lerp(c01, c11, tx), ty);
}
void putpixel(image_t *image, unsigned int x, unsigned int y, uint32_t color){
    image->pixels[(y*image->w) + x] = color;
}
void scale(image_t *src, image_t *dst, float scalex, float scaley){
    int newWidth = (int)src->w*scalex;
    int newHeight= (int)src->h*scaley;
    int x, y;
    for(x= 0, y=0; y < newHeight; x++){
        if(x > newWidth){
            x = 0; y++;
        }
        //float gx = x / (float)(newWidth) * (src->w - 1);
        //float gy = y / (float)(newHeight) * (src->h - 1);
        // Image should be clamped at the edges and not scaled.
        float gx = max(x / (float)(newWidth) * (src->w) - 0.5f, src->w - 1);
        float gy = max(y / (float)(newHeight) * (src->h) - 0.5, src->h - 1);
        int gxi = (int)gx;
        int gyi = (int)gy;
        uint32_t result=0;
        uint32_t c00 = getpixel(src, gxi, gyi);
        uint32_t c10 = getpixel(src, gxi+1, gyi);
        uint32_t c01 = getpixel(src, gxi, gyi+1);
        uint32_t c11 = getpixel(src, gxi+1, gyi+1);
        uint8_t i;
        for(i = 0; i < 3; i++){
            //((uint8_t*)&result)[i] = blerp( ((uint8_t*)&c00)[i], ((uint8_t*)&c10)[i], ((uint8_t*)&c01)[i], ((uint8_t*)&c11)[i], gxi - gx, gyi - gy); // this is shady
            result |= (uint8_t)blerp(getByte(c00, i), getByte(c10, i), getByte(c01, i), getByte(c11, i), gx - gxi, gy -gyi) << (8*i);
        }
        putpixel(dst,x, y, result);
    }
}

01/11/2022, 09h03
Jay M

Oui c’est ce code

Vous avez une fonction qui prend le pointeur sur la bitmap et sa taille originale et vous passez aussi la taille voulue (facteur de scaling) et la zone de stockage du résultat et ça fait le calcul pour vous.

void scale(image_t *src, image_t *dst, float scalex, float scaley)Nb je n’ai pas essayé le code c’est juste le résultat d’un Google search mais généralement les bouts de code sur ce site sont OK
01/11/2022, 09h36
cobra38
merci Jay M

donc dans mon cas :
Code:

1 2 3 4 5 6 7 #include <stdint.h> ..... image_t *src = 1280 x 720 image_t *dst = 320 x 240 float scalex = -4 float scaley = -3
mais je ne comprends toujours pas comment faire le lien avec :
Code:

1 2 size_t size = stream->available();
car si j'ai tout compris , il faut bien que je divise en utilisant la fonction scale() avant le stockage dans le buffer pour
permettre son utilisation
01/11/2022, 11h03
Jay M

en fait à la relecture du code il font une interpolation bilinéaire mais représentent les couleur des pixels sur 32 bits. ce n'est pas ce que vous avez donc le code ne correspond pas directement et en plus vous voulez réduire donc c'est moins adapté

il faudrait savoir exactement ce que vous recevez quand vous faites le stream->readBytes()

recevez vous une image JPEG ou juste un bitmap sans information ?

la méthode simple de réduction de taille est de ne conserver que une partie des échantillons, éventuellement avec un petit traitement pour éviter l'aliasing

Voir 40 message(s) de cette discussion en une page