avoid extract malloc

Author: moononournation

examples/ImgViewer/ImgViewerMjpeg_ESP32P4/MjpegClass.h

@@ -7,28 +7,17 @@
 #pragma once
 
 #if defined(ESP32)
-
-#define READ_BUFFER_SIZE 1024
-
 #include <driver/jpeg_decode.h>
 
+#define READ_BATCH_SIZE 1024
+
 class MjpegClass
 {
 public:
   bool setup(const char *path)
   {
     _input = fopen(path, "r");
-    _inputindex = 0;
-
-    if (!_read_buf)
-    {
-      _read_buf = (uint8_t *)malloc(READ_BUFFER_SIZE);
-    }
-
-    if (!_read_buf)
-    {
-      return false;
-    }
+    _read = 0;
 
     jpeg_decode_engine_cfg_t decode_eng_cfg = {
         .intr_priority = 0,
@@ -62,106 +51,112 @@ class MjpegClass
 
   bool readMjpegBuf()
   {
-    if (_inputindex == 0)
+    if (_read == 0)
     {
-      _buf_read = fread(_read_buf, 1, READ_BUFFER_SIZE, _input);
-      _inputindex += _buf_read;
+      // _mjpeg_buf empty
+      _read = fread(_mjpeg_buf, 1, READ_BATCH_SIZE, _input);
     }
-    _mjpeg_buf_offset = 0;
-    int i = 0;
+    else
+    {
+      // pad previous remain data to the start of _mjpeg_buf
+      memcpy(_mjpeg_buf, _p, _read);
+    }
+
     bool found_FFD8 = false;
-    while ((_buf_read > 0) && (!found_FFD8))
+    _p = _mjpeg_buf;
+    while ((_read > 0) && (!found_FFD8))
     {
-      i = 0;
-      while ((i < _buf_read) && (!found_FFD8))
+      while ((_read > 1) && (!found_FFD8))
       {
-        if ((_read_buf[i] == 0xFF) && (_read_buf[i + 1] == 0xD8)) // JPEG header
+        --_read;
+        if ((*_p++ == 0xFF) && (*_p == 0xD8)) // JPEG header
         {
           // Serial.printf("Found FFD8 at: %d.\n", i);
           found_FFD8 = true;
         }
-        ++i;
       }
-      if (found_FFD8)
+      if (!found_FFD8)
       {
-        --i;
-      }
-      else
-      {
-        _buf_read = fread(_read_buf, 1, READ_BUFFER_SIZE, _input);
+        if (*_p == 0xFF)
+        {
+          _mjpeg_buf[0] = 0xFF;
+          _read = fread(_mjpeg_buf + 1, 1, READ_BATCH_SIZE, _input) + 1;
+        }
+        else
+        {
+          _read = fread(_mjpeg_buf, 1, READ_BATCH_SIZE, _input);
+        }
+        _p = _mjpeg_buf;
       }
     }
-    uint8_t *_p = _read_buf + i;
-    _buf_read -= i;
+
+    if (!found_FFD8)
+    {
+      return false;
+    }
+
+    // rewind 1 byte
+    --_p;
+    ++_read;
+
+    // pad JPEG header to the start of _mjpeg_buf
+    if (_p > _mjpeg_buf)
+    {
+      Serial.println("(_p > _mjpeg_buf)");
+      memcpy(_mjpeg_buf, _p, _read);
+    }
+
+    // skip JPEG header
+    _p += 2;
+    _read -= 2;
+
+    if (_read == 0)
+    {
+      _read = fread(_p, 1, READ_BATCH_SIZE, _input);
+    }
+
     bool found_FFD9 = false;
-    if (_buf_read > 0)
+    while ((_read > 0) && (!found_FFD9))
     {
-      i = 3;
-      while ((_buf_read > 0) && (!found_FFD9))
+      while ((_read > 1) && (!found_FFD9))
       {
-        if ((_mjpeg_buf_offset > 0) && (_mjpeg_buf[_mjpeg_buf_offset - 1] == 0xFF) && (_p[0] == 0xD9)) // JPEG trailer
+        --_read;
+        if ((*_p++ == 0xFF) && (*_p == 0xD9)) // JPEG trailer
         {
           // Serial.printf("Found FFD9 at: %d.\n", i);
           found_FFD9 = true;
         }
-        else
-        {
-          while ((i < _buf_read) && (!found_FFD9))
-          {
-            if ((_p[i] == 0xFF) && (_p[i + 1] == 0xD9)) // JPEG trailer
-            {
-              found_FFD9 = true;
-              ++i;
-            }
-            ++i;
-          }
-        }
-
-        // Serial.printf("i: %d\n", i);
-        memcpy(_mjpeg_buf + _mjpeg_buf_offset, _p, i);
-        _mjpeg_buf_offset += i;
-        size_t o = _buf_read - i;
-        if (o > 0)
-        {
-          // Serial.printf("o: %d\n", o);
-          memcpy(_read_buf, _p + i, o);
-          _buf_read = fread(_read_buf + o, 1, READ_BUFFER_SIZE - o, _input);
-          _p = _read_buf;
-          _inputindex += _buf_read;
-          _buf_read += o;
-          // Serial.printf("_buf_read: %d\n", _buf_read);
-        }
-        else
-        {
-          _buf_read = fread(_read_buf, 1, READ_BUFFER_SIZE, _input);
-          _p = _read_buf;
-          _inputindex += _buf_read;
-        }
-        i = 0;
       }
-      if (found_FFD9)
+
+      if (!found_FFD9)
       {
-        return true;
+        _read += fread(_p + _read, 1, READ_BATCH_SIZE, _input);
+        // Serial.printf("_read: %d\n", _read - 1);
       }
     }
 
+    if (found_FFD9)
+    {
+      ++_p;
+      --_read;
+      return true;
+    }
+
     return false;
   }
 
   bool decodeJpg()
   {
-    _remain = _mjpeg_buf_offset;
-
     jpeg_decode_picture_info_t header_info;
-    ESP_ERROR_CHECK(jpeg_decoder_get_info(_mjpeg_buf, _remain, &header_info));
+    ESP_ERROR_CHECK(jpeg_decoder_get_info(_mjpeg_buf, _p - _mjpeg_buf, &header_info));
     _w = header_info.width;
     _h = header_info.height;
     uint32_t out_size;
     jpeg_decode_cfg_t decode_cfg_rgb = {
         .output_format = JPEG_DECODE_OUT_FORMAT_RGB565,
         .rgb_order = JPEG_DEC_RGB_ELEMENT_ORDER_BGR,
     };
-    ESP_ERROR_CHECK(jpeg_decoder_process(_decoder_engine, &decode_cfg_rgb, (const uint8_t *)_mjpeg_buf, _remain, (uint8_t *)_output_buf, MJPEG_OUTPUT_SIZE, &out_size));
+    ESP_ERROR_CHECK(jpeg_decoder_process(_decoder_engine, &decode_cfg_rgb, (const uint8_t *)_mjpeg_buf, _p - _mjpeg_buf, (uint8_t *)_output_buf, MJPEG_OUTPUT_SIZE, &out_size));
 
     return true;
   }
@@ -191,16 +186,11 @@ class MjpegClass
   uint8_t *_mjpeg_buf;
   uint16_t *_output_buf;
 
-  uint8_t *_read_buf;
-  int32_t _mjpeg_buf_offset = 0;
-
   jpeg_decoder_handle_t _decoder_engine;
-
   int16_t _w = 0, _h = 0;
 
-  int32_t _inputindex = 0;
-  int32_t _buf_read;
-  int32_t _remain = 0;
+  uint8_t *_p;
+  int32_t _read;
 };
 
 #endif // defined(ESP32)