Discussion :

[cobra38]

En fait, je ne comprends pas trop la ligne

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

            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

[Jay M]

vu que vous avez déjà un tableau je prendrais directement le code en C du lien précédent

[cobra38]

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

#include <stdint.h>

[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.

[cobra38]

Il n'existe pas de librairies capables faire ce travail de compression ?

[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

[cobra38]

parlez-vous de ce code ? svp ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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);
    }
}

[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

[cobra38]

merci Jay M

donc dans mon cas :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[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

[cobra38]

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

Comment puis-je le savoir ?
mais sur le moteur de recherche , il affiche bien l'image en jpg

Une question svp :
il y a dans le croquis , une librairie :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
 
#include <TFT_eSPI.h>
.........
//====================================================================================
//                                    tft_output
//====================================================================================
bool tft_output(int16_t x, int16_t y, uint16_t w, uint16_t h, uint16_t* bitmap)
{
   // Arrêtez le décodage car l'image sort du bas de l'écran.
  if ( y >= tft.height() ) return 0;
 
   // Cette fonction découpe automatiquement le rendu du bloc d'image aux limites du TFT.
  tft.pushImage(x, y, w, h, bitmap);
 
  //Ceci peut fonctionner à la place si vous adaptez le sketch pour utiliser la bibliothèque Adafruit_GFX.
  //tft.drawRGBBitmap(x, y, bitmap, w, h);
 
  // Retourne 1 pour décoder le bloc suivant
  return 1;
}

la fonction :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
tft.pushImage(x, y, w, h, bitmap);

ne sert-elle pas à mettre l'image reçue aux bonnes dimensions ?

[Beginner.]

Salut,

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 ....

Une chose me turlupine : si on regarde tes screenshots on voit que la taille (size) des données varie sans cesse, j'ai pu relever ces valeurs par exemple :

73252
138935
125082
120086
120587
144550
144361
144426
145324

Or si c'est censé être une image (avec un format donné) ne devrait-on pas avoir la même quantité de données ? Comment faire de la compression si la taille de ces données change tout le temps ? On peut se demander si ces données sont fiables, non ?

Est-ce que tu ne pourrais pas faire des tests indépendants ? Je veux dire avec un PC et un navigateur ? Il y a des outils performants dans le navigateur, on peut analyser les différentes requêtes et leur réponses...

[cobra38]

Bonjour Beginner.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Une chose me turlupine : si on regarde tes screenshots on voit que la talle (size) des données varie sans cesse, j'ai pu relever ces valeurs par exemple :

çà me choque pas , il s'agit d'une image temps réelle de la caméra et l'image n'est pas figée
qu'il y ait des variations çà semble plutôt rassurant çà prouve que je reçois bien les images

[jackk]

S'il s'agissait d'un bitmap, la taille des données serait fixe, mais vu qu'il s'agit d'une image compressée, la taille est forcément différente pour 2 images différentes.

[Beginner.]

Salut,

çà me choque pas , il s'agit d'une image temps réelle de la caméra et l'image n'est pas figée
qu'il y ait des variations çà semble plutôt rassurant çà prouve que je reçois bien les images

Ok et sur un navigateur l'image s'affiche correctement ?

S'il s'agissait d'un bitmap, la taille des données serait fixe, mais vu qu'il s'agit d'une image compressée, la taille est forcément différente pour 2 images différentes.

Ok. J'y connais rien en compression mais du coup je me demande si il est possible de compresser une image déjà compressée...