Discussion :

[cobra38]

Bonjour à tous ,

Je tente désespérément d'afficher l'image d'une camera IP
sur un écran TFT via un ESP32
pour ce la je m'inspire fortement du croquis suivant :

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
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
 
 
#include <esp_littlefs.h>
#include <lfs.h>
#include <lfs_util.h>
#include <LITTLEFS.h>
#include <littlefs_api.h>
 
 /*
 *  Application note: Video surveillance for AZ-Touch and ESP32  
 *  Version 1.0
 *  Copyright (C) 2021  Hartmut Wendt  www.zihatec.de
 *  
 *  Shows a QVGA JPEG picture by a video camera in realtime
 *  
 *  ESP32-cam with Arduino software example is recommend
 *  
 *
 *  Credits:  
 *  Stefan Fambach    www.fambach.net
 *  Github user 0015  https://github.com/0015/IdeasNProjects
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/   
 
 
 
 
 
#include <SPI.h>
#include <WiFi.h>
#include <HTTPClient.h>
#include "settings.h"
#include <TJpg_Decoder.h>
#include <TFT_eSPI.h>
 
String url;
uint8_t buff[20000] = { 0 };
 
WiFiClient client;
 
 
 
TFT_eSPI tft = TFT_eSPI();         // Invoke custom library
 
bool tft_output(int16_t x, int16_t y, uint16_t w, uint16_t h, uint16_t* bitmap)
{
   // Stop further decoding as image is running off bottom of screen
  if ( y >= tft.height() ) return 0;
 
  // This function will clip the image block rendering automatically at the TFT boundaries
  tft.pushImage(x, y, w, h, bitmap);
 
  //This might work instead if you adapt the sketch to use the Adafruit_GFX library
  //tft.drawRGBBitmap(x, y, bitmap, w, h);
 
  // Return 1 to decode next block
  return 1;
}
 
 
void get_jpg_picture(){
 
  if (WiFi.status() != WL_CONNECTED) {
    Serial.println("WiFi not connected!");    
    ESP.restart();
    delay(2000);
  }
 
  HTTPClient http;
 
  Serial.print("[HTTP] begin...\n");
  http.begin(url);
 
  Serial.print("[HTTP] GET...\n");
  int httpCode = http.GET();
 
  Serial.printf("[HTTP] GET... code: %d\n", httpCode);
  // HTTP header has been send and Server response header has been handled
  if (httpCode <= 0) {
    Serial.printf("[HTTP] GET... failed, error: %s\n", http.errorToString(httpCode).c_str());
  } else {
    if (httpCode != HTTP_CODE_OK) {
      Serial.printf("[HTTP] Not OK!\n");
    } else {
      // get lenght of document (is -1 when Server sends no Content-Length header)
      uint32_t len = http.getSize();
      Serial.printf("[HTTP] size: %d\n", len);
 
      if (len <= 0) {
        Serial.printf("[HTTP] Unknow content size: %d\n", len);
      } else {
        // create buffer for read
        //uint8_t buff[len] = { 0 };
 
        // get tcp stream
        WiFiClient * stream = http.getStreamPtr();
 
        // read all data from server
        uint8_t* p = buff;
        int l = len;
        while (http.connected() && (l > 0 || len == -1)) {
          // get available data size
          size_t size = stream->available();
 
          if (size) {
            int s = ((size > sizeof(buff)) ? sizeof(buff) : size);
            int c = stream->readBytes(p, s);
            p += c;
 
            //Serial.printf("[HTTP] read: %d\n", c);
 
            if (l > 0) {
              l -= c;
            }
          }
        }
 
        Serial.println();
        Serial.print("[HTTP] connection closed.\n"); 
 
        // Get the width and height in pixels of the jpeg if you wish
        uint16_t w = 0, h = 0;
        TJpgDec.getJpgSize(&w, &h, (const uint8_t*)buff, len);
        Serial.print("Width = "); Serial.print(w); Serial.print(", height = "); Serial.println(h);
        // check the picture size
        if (w > 320) {
          Serial.println("Picture too large, QVGA supported only!");
          http.end(); 
          return;
        }
 
        // Draw the image, top left at 0,0
        TJpgDec.drawJpg(0, 0, (const uint8_t*)buff, len);
      }
    }
  }
 
  http.end(); 
 
}
 
 
void setup() {
  // put your setup code here, to run once:
  Serial.begin(115200);
  delay(1000);
 
  tft.begin();
  tft.setRotation(3);
  tft.setTextColor(0xFFFF, 0x0000);
  tft.fillScreen(TFT_RED);
  tft.setSwapBytes(true); // We need to swap the colour bytes (endianess)
 
  // The jpeg image can be scaled by a factor of 1, 2, 4, or 8
  TJpgDec.setJpgScale(1); // requires QVGA picture, 320 x 240 resolution
  // TJpgDec.setJpgScale(2); // requires VGA picture, 640 x 480 resolution
 
 
  // The decoder must be given the exact name of the rendering function above
  TJpgDec.setCallback(tft_output);
 
  // Set WiFi to station mode and disconnect from an AP if it was Previously
  // connected
  WiFi.mode(WIFI_STA);
  WiFi.disconnect();
  delay(100);
 
  // Attempt to connect to Wifi network:
  Serial.print("Connecting Wifi: ");
  Serial.println(ssid);
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    Serial.print(".");
    delay(500);
  }
  Serial.println("");
  Serial.println("WiFi connected");
  Serial.println("IP address: ");
  IPAddress ip = WiFi.localIP();
  Serial.println(ip); 
 
  // generate URL
   url = "http://<Username>:<Password>@192.168.1.13/tmpfs/auto.jpg";
 
}
 
 
void loop() {
 
  get_jpg_picture();
}

Pour ce faire, j'ai compris qu'il fallait générer l'url de la caméra IP puis l'afficher
si la quête de l'url fut longue , celle-ci semble être correcte puisque l'image s'affiche à partir de l'invite sur le bandeau
Quand au croquis, il se compile sans erreur majeur mais au lancement du programme après la connexion WIFI
celui reboot sans cesse
et je ne vois pas le problème
dont voici un extrait issu de la console

***************************************************************



***************************************************************


je souhaite connaitre la raison de se "plantage" et quelques pistes pour m'en sortir

merci mille fois

pascal

[jackk]

Salut,
je ne sais pas si c'est çà, mais ton buffer fait 20 Ko et tu essaies d'y copier 73252 octets. tu vas altérer une bonne partie de la RAM située derrière le buffer, ce qui n'est pas bon du tout.

Essaie avec un buffer de 100 Ko si c'est possible (je ne connais pas la taille maxi des tableaux avec les ESP)

[cobra38]

Bonjour jackk

merci d'avoir répondu

Je pense que le problème vient plutôt de la compression d'image qui ne se fait pas
quand au buffer , je n'ai pu augmenter au delà de 50000 mais çà plante toujours
en fait le programme "découpe" les fichiers :

******************************************


******************************************

dans le croquis , il y a une bibliothèque <TJpg_Decoder.h>
celle-ci utilise "LittleFS" qui doit servir à la compression mais là il semble que son utilisation soit absente
du programme

[jackk]

Je pense que le problème vient plutôt de la compression d'image qui ne se fait pas
quand au buffer , je n'ai pu augmenter au delà de 50000 mais çà plante toujours
en fait le programme "découpe" les fichiers :

Ce n'est pas comme ça que je vois les choses: tu es dans une boucle qui récupère ce qu'envoie le serveur suite à ta requête GET. A chaque tour de boucle, l'ESP32 lit ce qui a été recueilli et le concatène dans le tableau avec ce qui a été précédemment lu.
Au bout d'un certain nombre de lectures, il y a débordement du tableau.
Autrement dit, la somme de tous les octets lus à chaque ligne marquée "read" doit être égale à 138935 octets

Essaie avec différentes tailles de tableau et, si mon raisonnement est correct, tu devrais planter avec un nombre de "read" plus ou moins grand en fonction de la taille du tableau.

Si tu ne peux pas aller au delà de 50 Ko, c'est peut-être parce que la taille de la pile est trop faible. Il faudrait voir comment il est possible de la modifier.

Sinon, il faudrait faire un essai avec le tas (heap) avec une allocation dynamique pour le tableau en mettant la taille dont tu as réellement besoin.

[cobra38]

Bonjour jackk

Là j'avoue que çà dépasse mes compétences

il semblerait donc que toute l'astuce réside dans cette partie
où la boucle s'arrête sasn raison apparente

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
50
51
52
53
54
55
56
57
58
59
60
 
if (httpCode <= 0) {
    Serial.printf("[HTTP] GET... failed, error: %s\n", http.errorToString(httpCode).c_str());
  } else {
    if (httpCode != HTTP_CODE_OK) {
      Serial.printf("[HTTP] Not OK!\n");
    } else {
      // get lenght of document (is -1 when Server sends no Content-Length header)
      uint32_t len = http.getSize();
      Serial.printf("[HTTP] size: %d\n", len);
 
      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();
 
        // read all data from server
        uint8_t* p = buff;
        int l = len;
        while (http.connected() && (l > 0 || len == -1)) {
          // get available data size
          size_t size = stream->available();
 
          if (size) {
            int s = ((size > sizeof(buff)) ? sizeof(buff) : size);
            int c = stream->readBytes(p, s);
            p += c;
 
            Serial.printf("[HTTP] read: %d\n", c);
 
            if (l > 0) {
              l -= c;
            }
          }
		  delay(1);
        }
 
        Serial.println();
        Serial.print("[HTTP] connection closed.\n"); 
 
        // Get the width and height in pixels of the jpeg if you wish
        uint16_t w = 0, h = 0;
        TJpgDec.getJpgSize(&w, &h, (const uint8_t*)buff, len);
        Serial.print("Width = "); Serial.print(w); Serial.print(", height = "); Serial.println(h);
        // check the picture size
        if (w > 320) {
          Serial.println("Picture too large, QVGA supported only!");
          http.end(); 
          return;
        }
 
        // Draw the image, top left at 0,0
        TJpgDec.drawJpg(0, 0, (const uint8_t*)buff, len);
      }
    }
  }

voici le résultat à la console

*****************************************


*****************************************

[jackk]

Je ne comprends pas trop pourquoi tu as créé un nouveau buffer. De plus, avec une taille de 1024 octets, c'est forcément pire.

où la boucle s'arrête sasn raison apparente

Bin si, la raison est un débordement de tableau.
Tu as essayé en modifiant la taille du buffer de ton premier programme (celui qui faisait 20000 octets) pour voir si le nombre d'octets récupérés variait avant plantage?

[Jay M]

essayez avec le tableau en variable globale au lieu de le mettre dans la fonction et bien sûr de taille suffisante pour la plus grosse des images

[Beginner.]

Salut,

Quelqu’un sait pourquoi la taille des tableaux est limitée comme ça ?

Pourtant il me semble que le ESP32 a au moins 520Mo de SRAM, non ?

[cobra38]

essayez avec le tableau en variable globale au lieu de le mettre dans la fonction et bien sûr de taille suffisante pour la plus grosse des images

Bonjour Jay M

lequel ? celui-ci ?

Code :

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

uint8_t buff[80000] = { 0 };

en

Code :

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

int buff[130000] = { 0 };

[Jay M]

si vous utilisez la version 1.8.19 de l'IDE (et pas la version 2) vous pouvez installer l'outil Exception Stack Trace Decoder et voir dans le code où ça a planté

c'est sans doute le watchdog qui se déclenche car une opération est trop longue sans redonner la main.
appelez yield() par exemple après chaque réception d'un buffer HTTP

[Jay M]

C’est parce que buff est un pointeur Maintenant et plus un tableau donc sa taille (quand vous appelez sizeof) c’est celle d’un pointeur, soit 4 octets

Il faut passer la taille allouée

Sinon oui essayez uint8_t buff[120000]; en variable globale

[cobra38]

Bonjour à Tous

Un grand merci à tous ceux qui prennent de leur temps pour me répondre

ce matin et après quelques modifications de principe du croquis par rapport en #1 (// <========)
j'obtiens çà à la console

************************************************


************************************************

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
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
 
 
#include <esp_littlefs.h>
#include <lfs.h>
#include <lfs_util.h>
#include <LITTLEFS.h>
#include <littlefs_api.h>
 
 
#include <SPI.h>
#include <WiFi.h>
#include <HTTPClient.h>
#include "settings.h"
#include <TJpg_Decoder.h>
#include <TFT_eSPI.h>
 
String url;
uint8_t buff[20000] = { 0 };  
 
WiFiClient client;
 
 
 
TFT_eSPI tft = TFT_eSPI();         // Invoke custom library
 
bool tft_output(int16_t x, int16_t y, uint16_t w, uint16_t h, uint16_t* bitmap)
{
   // Stop further decoding as image is running off bottom of screen
  if ( y >= tft.height() ) return 0;
 
  // This function will clip the image block rendering automatically at the TFT boundaries
  tft.pushImage(x, y, w, h, bitmap);
 
  //This might work instead if you adapt the sketch to use the Adafruit_GFX library
  //tft.drawRGBBitmap(x, y, bitmap, w, h);
 
  // Return 1 to decode next block
  return 1;
}
 
 
void get_jpg_picture(){
 
  if (WiFi.status() != WL_CONNECTED) {
    Serial.println("WiFi not connected!");    
    ESP.restart();
    delay(2000);
  }
 
  HTTPClient http;
 
  Serial.print("[HTTP] begin...\n");
  http.begin(url);
 
  Serial.print("[HTTP] GET...\n");
  int httpCode = http.GET();
 
  Serial.printf("[HTTP] GET... code: %d\n", httpCode);
  // HTTP header has been send and Server response header has been handled
  if (httpCode <= 0) {
    Serial.printf("[HTTP] GET... failed, error: %s\n", http.errorToString(httpCode).c_str());
  } else {
    if (httpCode != HTTP_CODE_OK) {
      Serial.printf("[HTTP] Not OK!\n");
    } else {
      // get lenght of document (is -1 when Server sends no Content-Length header)
      //uint32_t len = http.getSize();
	  int len = http.getSize();   // <========================================================
      Serial.printf("[HTTP] size: %d\n", len);
 
      if (len <= 0) {
        Serial.printf("[HTTP] Unknow content size: %d\n", len);
      } else {
        // create buffer for read
        //uint8_t buff[len] = { 0 };
		//uint8_t buff[len] = { 0 };
 
        // get tcp stream
        WiFiClient * stream = http.getStreamPtr();
 
        // read all data from server      // <==================================================
        // uint8_t* p = buff;             // <==================================================
        // int l = len;                   // <==================================================
        while (http.connected() && (len > 0 || len == -1)) {
          // get available data size
          size_t size = stream->available();
 
          if (size) {
			int c = stream->readBytes(buff, ((size > sizeof(buff)) ? sizeof(buff) : size));  
            //int s = ((size > sizeof(buff)) ? sizeof(buff) : size);     // <==================================================
            //int c = stream->readBytes(p, s);                           // <==================================================
            //p += c;                                                    // <==================================================
 
            Serial.printf("[HTTP] read: %d\n", c);
 
            if (len > 0) {
              len -= c;
            }
          }
		  delay(1);
        }
 
        Serial.println();
        Serial.print("[HTTP] connection closed.\n"); 
 
        // Get the width and height in pixels of the jpeg if you wish
        uint16_t w = 0, h = 0;
 
        TJpgDec.getJpgSize(&w, &h, (const uint8_t*)buff, len);
        Serial.print("Width = "); Serial.print(w); Serial.print(", height = "); Serial.println(h);
        // check the picture size
        if (w > 320) {
          Serial.println("Picture too large, QVGA supported only!");
          http.end(); 
          return;
        }
 
        // Draw the image, top left at 0,0
        TJpgDec.drawJpg(0, 0, (const uint8_t*)buff, len);
      }
    }
  }
 
  http.end(); 
 
}
 
 
void setup() {
  // put your setup code here, to run once:
  Serial.begin(115200);
  delay(1000);
 
  tft.begin();
  tft.setRotation(3);
  tft.setTextColor(0xFFFF, 0x0000);
  tft.fillScreen(TFT_RED);
  tft.setSwapBytes(true); // We need to swap the colour bytes (endianess)
 
  // The jpeg image can be scaled by a factor of 1, 2, 4, or 8
  TJpgDec.setJpgScale(2); // requires QVGA picture, 320 x 240 resolution
  // TJpgDec.setJpgScale(2); // requires VGA picture, 640 x 480 resolution
 
 
  // The decoder must be given the exact name of the rendering function above
  TJpgDec.setCallback(tft_output);
 
  // Set WiFi to station mode and disconnect from an AP if it was Previously
  // connected
  WiFi.mode(WIFI_STA);
  WiFi.disconnect();
  delay(100);
 
  // Attempt to connect to Wifi network:
  Serial.print("Connecting Wifi: ");
  Serial.println(ssid);
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    Serial.print(".");
    delay(500);
  }
  Serial.println("");
  Serial.println("WiFi connected");
  Serial.println("IP address: ");
  IPAddress ip = WiFi.localIP();
  Serial.println(ip); 
 
  // generate URL
  url = "http://<----->:<------>@192.168.1.13/tmpfs/auto.jpg";
 
  //url += host;
  //url += site; 
 
 
}
 
 
void loop() {
 
  get_jpg_picture();
}

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 };
et les modifications ont porté seulement sur la variable len et le "formatage" de la variable : int c
par contre il n'affiche toujours pas l'image et çà reste une enigme

[jackk]

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 };
et les modifications ont porté seulement sur la variable len et le "formatage" de la variable : int c
par contre il n'affiche toujours pas l'image et çà reste une enigme

Passer len de uint32_t à int ne va rien changer.

Pour le reste, tu as un peu "triché" en supprimant la ligne

Code :

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

p += c;

qui permet d'avancer dans le buffer. Du coup, comme tu stockes toujours les données reçues au début du buffer, ça ne risque plus de déborder, mais les données que as reçues sont toutes écrasées par les nouvelles. Aucune chance d'afficher l'image.

De plus, à mon avis l'affichage de la console ne correspond pas au code que tu viens de fournir car tu as commenté cette ligne:

Code :

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

//int c = stream->readBytes(p, s);

Je ne vois donc pas comment le nombre affiché après "read : " peut correspondre à la taille du paquet récupéré du serveur vu que tu as commenté la ligne qui en fait la lecture.

[cobra38]

Bonjour jackk

De plus, à mon avis l'affichage de la console ne correspond pas au code que tu viens de fournir car tu as commenté cette ligne:

J'ai remplacé la ligne par :

Code :

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

1
2
 
int c = stream->readBytes(buff, ((size > sizeof(buff)) ? sizeof(buff) : size));

je confirme que la console est bien le reflet du croquis
la preuve c'est que mon buffer est vide ...
donc, avant je le remplissais sans le vider et maintenant je le remplis mais le vide de suite ...

[jackk]

j'ai effectué une petite modification dans mon message précédent pendant que tu répondais.

[Jay M]

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

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

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

Code :

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

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

Code :

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

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é

[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

[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

[jackk]

C’est parce que buff est un pointeur Maintenant et plus un tableau donc sa taille (quand vous appelez sizeof) c’est celle d’un pointeur, soit 4 octets

Il faut passer la taille allouée

Bien vu.

Sinon oui essayez uint8_t buff[120000]; en variable globale

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

[jackk]

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?

PS: j'ai trouvé le code. Est-ce que l'image est bien générée avec une ESP32-CAM?
En passant, ce code est-il vraiment fonctionnel, vu le nombre de trace d'essais laissés en commentaires tels que

Code :

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

        // create buffer for read        //uint8_t buff[len] = { 0 };

Je ne comprends pas non plus la ligne

Code :

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

        uint8_t* p = buff;

qui substitue une variable "buff" locale au tableau "buff" global. Ce qui, comme l'a bien remarqué Jay M, pose problème lors des "sizeof(buff)" qui va donner la taille du pointeur local buff et pas de calle du tableau buff.