Date & Timestamp for Tasmota-32 WebCam build

[LucidEye]

I believe it would be very useful to many users if the Tasmota32 WebCam build had a feature which would overlay a basic date & timestamp on the webcam image. I believe the usefulness of this is self apparent, and I am actually surprised that this feature doesn't already exist. Trying to use a 3rd-party Linux app to add a timestamp to an already existing image is clunky and time-consuming at best. And tying to add timestamps to an image sequence of thousands of images taken for compiling into a time-lapse video is excruciatingly slow and cumbersome... Is there some reason that Tasmota can't place a timestamp on it's image stream? If this feature can't be added to the base code, can it be done using Berry? And if so are there any working Berry code examples of how this could be done?
Was thinking of something like this timestamp at the top of the image...

[Staars]

Do you mean to embed this into the stored JPEG image file?
This is at least not trivial.

Starting the camera driver alone grabs about 700 kB of PSRAM. This is already enough to prevent decoding the 1600x1200 max. image size in 16 bit color depth of the OV2640 sensor of the widely used cheap ESP32 cam boards with 4 MB PSRAM.

Thus it might be possible to use a smaller image size and then this will create a degradation of image quality by decoding and reencoding.

A theoretical and quite hacky approach could be to exchange the last few MCU‘s of the JPEG stream and print the date string into the lower right corner of the image. I am not even sure, that this is really possible to achieve.

Overall I would definitely prefer to move these steps to stronger hardware and just use sane naming conventions for the image files. Even a Raspberry Pi is a hardware monster in comparison to an ESP32.

[LucidEye]

I actually have several R-Pi based security cameras running "Pikrellcam" (that's what the screenshot was from) and they work very nicely, when you have a convenient outlet available to power them. And as you saw, Pikrellcam has a timestamp, and it can even be customized via a config file.
However, the problem I have in this specific application prevents me from using something like a Raspberry Pi because of it's power requirements as well as it's size. I need a very small camera that fits in a very small weatherproof enclosure and is powered by a small 10 watt solar panel and a 4.5Ah SLA battery. This is all installed in a location that is far away from any AC power. The camera also needs to "sleep" at night to conserve battery power. The only hardware that fits these requirements is the ESP32. Trying to do this with even a Pi Zero W would require a 30-50 watt panel and a huge 30-40 Ah battery as the Pi zero uses about 7 times more power than the ESP32-Cam modules. But a security camera with no timestamp is really not much use if you need to record motion events or compile time lapse videos from a sequence of thousands of images. I can use 3rd party apps running on another machine to record the stream from the ESP32, but trying to add a timestamp after the initial images have already been taken and transferred to the 3rd party app is just so slow and problematic. I didn't think that it would be so difficult to simply have a timestamp appear on the Tasmota Webcam image stream.

[sfromis]

Depending on the details of your recording setup - if you already can have "a sequence of thousands of images", those files should inherently have a file system timestamp already, and then I'd find it very plausible for time lapse software to be able to grab those - as a pretty basic feature.

[LucidEye]

Yeah, that's what I thought as well, but so far I haven't been able to find any Linux FOSS apps that can do this. I did find a couple of Python scripts that can supposedly pull a timestamp from the EXIF data, but not the file-name, and trying to batch process almost 10k images at a time is just too time consuming on my old PC.

[joba-1]

Does tasmota have direct access to the framebuffer of the images before they are encoded to jpeg? 1600x1200x8bit is already ~3x700kB, so maybe not.
But if yes: At that level copying a few prepared bitpatterns representing the digits 0-9 should be very easy for the esp compared to jpeg encoding.
Still a lot of programming work though.

[LucidEye]

I'm only using 1280x720... that's plenty of resolution for my use-case. And with that I get about 4-5 FPS over the WiFi @ 80% signal strength... which is just fine for pulling time lapse sequences or motion-activated video recording. I mean considering the hardware we're dealing with, anything higher than 1280x720 and you start running into useless frame-rates or the device becomes too unstable from lack of PSRAM. I really don't understand all the details of the image processing, but isn't there some way to create a superimposed text overlay onto the jpeg images before they are streamed? And wouldn't there be a way to have it only available for the resolutions where it doesn't cause PSRAM issues? Would still be better than nothing.

[Staars]

1280x720 should be possible with regards to memory. CPU load would go up for sure, which could reduce stability for various reasons and re-encoding will reduce image quality.
Yes, it is worth a try, and I would give it a shot if I find some time. I am thinking about pure Berry here.

[LucidEye]

Well, if it's any help, I usually set WcClock 10 just to make sure the camera is taking the least toll on CPU as possible... I figure the camera and CPU don't need to crank out frames if they can only manage 5FPS @ 1280x720.
I've read that Berry is similar to Python... is there any online "code transposer" one might use to convert this Python script to Berry... or maybe run it through an AI to get something close to workable?

def add_timestamp_to_image(image_path, output_path, font_size=30, text_color=(255, 255, 255), position=(10, 10)):
    """
    Adds a current timestamp to an image.

    Args:
        image_path (str): The path to the input image.
        output_path (str): The path to save the output image with the timestamp.
        font_size (int): The size of the timestamp text.
        text_color (tuple): The RGB color of the timestamp text (e.g., (255, 255, 255) for white).
        position (tuple): The (x, y) coordinates where the timestamp should be placed.
    """
    try:
        # Open the image
        img = Image.open(image_path)
        draw = ImageDraw.Draw(img)

        # Get current timestamp
        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")

        # Define font (you might need to provide a path to a .ttf file if you want a specific font)
        try:
            font = ImageFont.truetype("arial.ttf", font_size) # Using a common font like Arial
        except IOError:
            font = ImageFont.load_default() # Fallback to default font if Arial not found

        # Add the timestamp to the image
        draw.text(position, timestamp, font=font, fill=text_color)

        # Save the modified image
        img.save(output_path)
        print(f"Timestamp added successfully to {output_path}")

    except FileNotFoundError:
        print(f"Error: Image file not found at {image_path}")
    except Exception as e:
        print(f"An error occurred: {e}")

# Example usage:
if __name__ == "__main__":
    input_image = "input.jpg"  # Replace with your input image file
    output_image = "output_with_timestamp.jpg"

    # Create a dummy image for testing if input.jpg doesn't exist
    try:
        Image.new('RGB', (600, 400), color = 'red').save(input_image)
        print(f"Created a dummy image: {input_image}")
    except Exception as e:
        print(f"Could not create dummy image: {e}")

    add_timestamp_to_image(input_image, output_image)```

[Noschvie]

I would run the timestamp embedding process on a Raspberry Pi, but using a RAM disk and without putting strain on the SD card.

[LucidEye]

Like I've mentioned, I am shooting daily time lapse sequences... 1 fame every 10-15 seconds every 24 hours... which ends up being between 5000 and 8000 raw images per day. As it is, I already have an R-Pi that is grabbing the time-lapse frames from the ESP32's Tasmota jpeg stream. This R-Pi is running my home automation software and runs on an SSD, not an SD card. Then, every day, I have to copy all the raw image files from that Pi to my PC to compile them into a video using KDENLive. Trying to extract an EXIF timestamp from 5000-8000 image files and re-encode them all is simply not practical, especially for a Raspberry Pi that is already grabbing images every 10-15 seconds 24-7, while also running my home automation software. Having to batch process this many images daily using any 3rd party apps to place a timestamp on the images after the fact is just not working. I need the raw images to already have the timestamp embedded before they are grabbed by the recording device. I need these videos as evidence for a legal case we are building against our neighbors who are illegally running an industrial/commercial business out of a property that is zoned for residential use only, so it is important for the videos to have date-time-stamps that correlate to the other videos we have which do have timestamps, otherwise they may not hold up in court as evidence. Believe me, I would much rather just use another R-Pi based security camera running the same software all my other security cameras are using, but for this particular camera, my only option for power is a solar panel and battery which also isn't practical for a raspberry pi due to it's power consumption.

[joba-1]

if this is used as evidence I would not alter the original jpeg encoding of the cam. Could be important to qualify it as unmodified.
Have you looked into exiftool? It can add metadata (including time) to jpegs without reencoding the binary image parts.

Isn’t KDENlive a GUI tool? Have you looked into ffmpeg to produce video from images from the commandline?

I would write a 2 line cron script on the Pi to wget the image and then add the time to metadata with exiftool. Or if you insist to have the time visible in the video, use convert commandline tool to add text to an image (I would still keep the original for evidence).
Then another cron calling ffmpeg once every 24h to produce the video from the files.

Your special usecase - one small image every 5s - might be doable on the esp. For video in general to decode jpeg, add text and encode in realtime I don't think it could work. Prove me wrong :)

[LucidEye]

Yes, not altering the images after the fact is important... that is one more reason why I am asking for the timestamp feature be added to Tasmota, so the timestamp is already on the image stream before the images are recorded/saved by an external device. I wouldn't be here asking for this feature if I haden't already tried every possible alternative I could think of.

Yes, the first thing I tried was ffmpeg, but it does not allow me to set the individual frame duration the same way KDENLive does. With KDENLive I can compress a 24 hour sequence of images down to a 3 minute time lapse video without any frames being dropped. I was not able to accomplish that using the CLI ffmpeg app. Ffmpeg allows you to set overall video duration and playback frame-rate... it does not allow you to set individual frame duration. This causes frames to be dropped when compiling a video from an image sequence in order for ffmpeg to fit the video into the overall runtime duration.

As I have already explained twice now, it is not practical to have the R-Pi that is grabbing the images to perform any further post processing as it is running my home automation software, in fact it is that automation software that is doing the image capture... so I can not overload the pi with further image processing, and I don't have another pi I can dedicate to this.

[LucidEye]

I have also been looking for any alternative ESP32-CAM module firmware that has a timestamp feature... and so far I have only found this one Arduino sketch. I believe it overlays the timestamp in the framebuffer before writing the image to the jpeg stream. Of course this is also useless to me because it does not have any of the Tasmota features I need to use such as camera controls like white balance and exposure adjustment... also doesn't have Rules... I use these Tasmota features to set camera settings at sunrise and sunset to keep exposure as constant as possible throughout the time lapse sequence. But maybe the code could be useful... wish I knew more about coding or I would attempt to make this work myself, but under the circumstances I just don't have the time to learn how to do this on my own.... that and I don't currently have another ESP32-CAM module to test alternative firmware on :-(

#include <WiFi.h>
#include "esp_timer.h"
#include "img_converters.h"
#include "Arduino.h"
#include "fb_gfx.h"
#include "soc/soc.h"
#include "soc/rtc_cntl_reg.h"
#include "esp_http_server.h"
#include <time.h>

// Replace with your network credentials
const char* ssid = "xxxxxxxx";
const char* password = "xxxxxxxxx";

// NTP Server settings
const char* ntpServer = "pool.ntp.org";
const long gmtOffset_sec = 19800; // IST (UTC+5:30) = 5.5 * 3600 = 19800 seconds
const int daylightOffset_sec = 0; // No daylight saving for IST

#define PART_BOUNDARY "123456789000000000000987654321"

// Camera model configuration
#define CAMERA_MODEL_AI_THINKER
#if defined(CAMERA_MODEL_AI_THINKER)
  #define PWDN_GPIO_NUM     32
  #define RESET_GPIO_NUM    -1
  #define XCLK_GPIO_NUM      0
  #define SIOD_GPIO_NUM     26
  #define SIOC_GPIO_NUM     27
  #define Y9_GPIO_NUM       35
  #define Y8_GPIO_NUM       34
  #define Y7_GPIO_NUM       39
  #define Y6_GPIO_NUM       36
  #define Y5_GPIO_NUM       21
  #define Y4_GPIO_NUM       19
  #define Y3_GPIO_NUM       18
  #define Y2_GPIO_NUM        5
  #define VSYNC_GPIO_NUM    25
  #define HREF_GPIO_NUM     23
  #define PCLK_GPIO_NUM     22
#else
  #error "Camera model not selected"
#endif

static const char* _STREAM_CONTENT_TYPE = "multipart/x-mixed-replace;boundary=" PART_BOUNDARY;
static const char* _STREAM_BOUNDARY = "\r\n--" PART_BOUNDARY "\r\n";
static const char* _STREAM_PART = "Content-Type: image/jpeg\r\nContent-Length: %u\r\n\r\n";

httpd_handle_t stream_httpd = NULL;

static esp_err_t stream_handler(httpd_req_t *req) {
  camera_fb_t * fb = NULL;
  esp_err_t res = ESP_OK;
  size_t _jpg_buf_len = 0;
  uint8_t * _jpg_buf = NULL;
  char * part_buf[64];

  res = httpd_resp_set_type(req, _STREAM_CONTENT_TYPE);
  if (res != ESP_OK) {
    return res;
  }

  while (true) {
    fb = esp_camera_fb_get();
    if (!fb) {
      Serial.println("Camera capture failed");
      res = ESP_FAIL;
    } else {
      // Get current time and date
      time_t now;
      struct tm timeinfo;
      char time_str[30]; // Increased size for date and time
      time(&now);
      localtime_r(&now, &timeinfo);
      strftime(time_str, sizeof(time_str), "%m/%d/%Y %I:%M:%S %p", &timeinfo); // MM/DD/YYYY HH:MM AM/PM

      if (fb->width > 400) {
        if (fb->format != PIXFORMAT_RGB565) {
          // Convert to JPEG if not in RGB565 (should not happen with our config)
          bool jpeg_converted = frame2jpg(fb, 80, &_jpg_buf, &_jpg_buf_len);
          esp_camera_fb_return(fb);
          fb = NULL;
          if (!jpeg_converted) {
            Serial.println("JPEG compression failed");
            res = ESP_FAIL;
          }
        } else {
          // Create fb_data_t structure for fb_gfx_print
          fb_data_t fb_data;
          fb_data.data = fb->buf;
          fb_data.width = fb->width;
          fb_data.height = fb->height;
          fb_data.format = FB_RGB565; // Use RGB565 format
          fb_data.bytes_per_pixel = 2; // RGB565 uses 2 bytes per pixel

          // Overlay date and time on RGB565 frame using fb_gfx_print
          fb_gfx_print(&fb_data, 10, 10, 0xFFFF, time_str); // White text at (10,10)

          // Convert to JPEG for streaming
          bool jpeg_converted = frame2jpg(fb, 80, &_jpg_buf, &_jpg_buf_len);
          esp_camera_fb_return(fb);
          fb = NULL;
          if (!jpeg_converted) {
            Serial.println("JPEG compression failed");
            res = ESP_FAIL;
          }
        }
      }
    }
    if (res == ESP_OK) {
      size_t hlen = snprintf((char *)part_buf, 64, _STREAM_PART, _jpg_buf_len);
      res = httpd_resp_send_chunk(req, (const char *)part_buf, hlen);
    }
    if (res == ESP_OK) {
      res = httpd_resp_send_chunk(req, (const char *)_jpg_buf, _jpg_buf_len);
    }
    if (res == ESP_OK) {
      res = httpd_resp_send_chunk(req, _STREAM_BOUNDARY, strlen(_STREAM_BOUNDARY));
    }
    if (fb) {
      esp_camera_fb_return(fb);
      fb = NULL;
      _jpg_buf = NULL;
    } else if (_jpg_buf) {
      free(_jpg_buf);
      _jpg_buf = NULL;
    }
    if (res != ESP_OK) {
      break;
    }
  }
  return res;
}

void startCameraServer() {
  httpd_config_t config = HTTPD_DEFAULT_CONFIG();
  config.server_port = 80;

  httpd_uri_t index_uri = {
    .uri       = "/",
    .method    = HTTP_GET,
    .handler   = stream_handler,
    .user_ctx  = NULL
  };
  
  if (httpd_start(&stream_httpd, &config) == ESP_OK) {
    httpd_register_uri_handler(stream_httpd, &index_uri);
  }
}

void setup() {
  WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 0);
  Serial.begin(115200);
  Serial.setDebugOutput(false);
  
  camera_config_t config;
  config.ledc_channel = LEDC_CHANNEL_0;
  config.ledc_timer = LEDC_TIMER_0;
  config.pin_d0 = Y2_GPIO_NUM;
  config.pin_d1 = Y3_GPIO_NUM;
  config.pin_d2 = Y4_GPIO_NUM;
  config.pin_d3 = Y5_GPIO_NUM;
  config.pin_d4 = Y6_GPIO_NUM;
  config.pin_d5 = Y7_GPIO_NUM;
  config.pin_d6 = Y8_GPIO_NUM;
  config.pin_d7 = Y9_GPIO_NUM;
  config.pin_xclk = XCLK_GPIO_NUM;
  config.pin_pclk = PCLK_GPIO_NUM;
  config.pin_vsync = VSYNC_GPIO_NUM;
  config.pin_href = HREF_GPIO_NUM;
  config.pin_sccb_sda = SIOD_GPIO_NUM;
  config.pin_sccb_scl = SIOC_GPIO_NUM;
  config.pin_pwdn = PWDN_GPIO_NUM;
  config.pin_reset = RESET_GPIO_NUM;
  config.xclk_freq_hz = 20000000;
  config.pixel_format = PIXFORMAT_RGB565; // Use RGB565 for fb_gfx_print compatibility
  
  if (psramFound()) {
    config.frame_size = FRAMESIZE_VGA; // Reduced to VGA to avoid memory issues
    config.jpeg_quality = 10;
    config.fb_count = 2;
  } else {
    config.frame_size = FRAMESIZE_SVGA;
    config.jpeg_quality = 12;
    config.fb_count = 1;
  }
  
  // Camera init
  esp_err_t err = esp_camera_init(&config);
  if (err != ESP_OK) {
    Serial.printf("Camera init failed with error 0x%x", err);
    return;
  }
  
  // Wi-Fi connection
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("");
  Serial.println("WiFi connected");

  // Initialize NTP
  configTime(gmtOffset_sec, daylightOffset_sec, ntpServer);
  Serial.println("Waiting for NTP time sync...");
  delay(2000); // Wait for time sync
  time_t now;
  struct tm timeinfo;
  time(&now);
  localtime_r(&now, &timeinfo);
  if (timeinfo.tm_year < (2025 - 1900)) {
    Serial.println("Failed to obtain time");
  } else {
    Serial.println("Time synchronized");
  }
  
  Serial.print("Camera Stream Ready! Go to: http://");
  Serial.print(WiFi.localIP());
  
  // Start streaming web server
  startCameraServer();
}

void loop() {
  delay(1);
}

[sfromis]

With static images (instead of a stream), it should be feasible to use Berry to grab the image buffer, and modify it before making it available to access via http, using the cam module and img class which can be added with a custom compile. Not saying that the above is meant to be "the only way", just that it would not take much programming to do something like that, if there's enough PSRAM for the image size.

In a simple case, the code could already contain bitmaps for the chars to be used in the timestamp, haven't looked around for smarter ways.

[LucidEye]

Ok... how would that work? Would that mean the ESP32 would need to store those static images locally, like on an SD card? Or would it hold the latest post-processed jpg image in PSRAM, in parallel to the latest pre-processed raw image in the framebuffer... and then the external capture device just grabs whatever post-processed jpg is there at that moment?

I just double-checked the image capture settings in my automation software, and I am actually capturing the timelapse stills from the...
http://xxx.xxx.xxx.xxx:80/wc.jpg
URL
There are also...
http://xxx.xxx.xxx.xxx:80/wc.mjpg
http://xxx.xxx.xxx.xxx:80/snapshot.jpg
URLs. Does it matter which one is used?

This is what the memory looks like running the camera at 1280x720. The compressed jpg still-images are <300kb at 1280x720...

This is the current (daytime) Wc settings...

{"WC":{"Stream":1,"Resolution":13,"Mirror":0,"Flip":0,"Saturation":0,"Brightness":-2,"Contrast":-1,"SpecialEffect":0,"AWB":1,"WBMode":1,"AWBGain":1,"AEC":1,"AECValue":200,"AELevel":2,"AECDSP":1,"AGC":1,"AGCGain":20,"GainCeiling":0,"GammaCorrect":1,"LensCorrect":1,"WPC":1,"DCW":1,"BPC":1,"Colorbar":0,"Feature":0,"Auth":0,"Rtsp":0}}

[sfromis]

How it would work would depend on how it was coded, unsurprisingly. You'd not need to store the image on a SD card. As long as the buffer can reside in memory, you have options. And with 4MB of PSRAM, you have good chances of "having fun".

Here's some overly rudimentary code getting the image into a bytes buffer with 16-bit color pixels (not the only option). Overwriting a selected part should be reasonably simple, and maybe convert to a "normal" image format like jpeg, before making it available externally. Maybe by calling a server with the blob, maybe code a small server able to return the blob. Or write it to a local file system, if that serves your use case.

var i = img()
import cam
cam.setup(4)  # resolution
cam.get_image(i, i.RGB565)
print(i.info())
var buf = i.get_buffer()
print('size', size(buf))

Your http endpoints are the same, except of course that mjpg is video instead of still.

With your intended use case, you should probably take steps to be extra sure of having a correct time stamp.

To be clear, I've not really worked with that module and class, merely made a quick test case based on finding it in the docs.
https://tasmota.github.io/docs/Berry/#cam-module

[Staars]

This is obviously the crappiest image possible and only 240*240, but it proves, that the data flow is possible.
This was (in pseudo-code):

1. cam.get_image(RGB565)
2. create bytes() view on img buffer (using toptr from introspect)
3. draw in Berry date and time on this buffer
4. convert_to(JPEG)
5. save to file

I will have to rework parts of cam and img module, which have some issues with the latest updates to JPEGDEC (a while ago).

The principle may also work with the webcam driver using wcstore command.

[Staars]

I am still testing some things. The camera seems to be out of focus, I just grabbed this from the drawer. I have no idea about the blocky artefacts at the bottom ATM.

Anyway ... 1280x720 pixels are in reach and in the first few minutes writing to an SD-card there was no obvious memory leak.

Here is a bit of code to show how much there is to do:

import cam
import string
import introspect

# -------------------------------------------------
# GLOBALS
# -------------------------------------------------
var img_obj = nil
var w = 0
var h = 0
var mapped_buf = nil
var FONT = [
    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, # space
    0x00,0x0C,0x0C,0x00,0x00,0x0C,0x0C,0x00, # :
    0x3E,0x63,0x63,0x6B,0x6B,0x63,0x63,0x3E, # 0
    0x0C,0x1C,0x3C,0x0C,0x0C,0x0C,0x0C,0x3F, # 1
    0x3E,0x63,0x03,0x06,0x1C,0x30,0x63,0x7F, # 2
    0x3E,0x63,0x03,0x0E,0x03,0x63,0x63,0x3E, # 3
    0x06,0x0E,0x1E,0x36,0x66,0x7F,0x06,0x06, # 4
    0x7F,0x60,0x60,0x7E,0x03,0x63,0x63,0x3E, # 5
    0x1C,0x30,0x60,0x7E,0x63,0x63,0x63,0x3E, # 6
    0x7F,0x63,0x06,0x0C,0x0C,0x0C,0x0C,0x0C, # 7
    0x3E,0x63,0x63,0x3E,0x63,0x63,0x63,0x3E, # 8
    0x3E,0x63,0x63,0x63,0x3F,0x03,0x06,0x0C  # 9
]

# -------------------------------------------------
# 1. SETUP CAMERA (CALL ONCE)
# -------------------------------------------------
def setup_camera()
    if img_obj != nil
        print("Camera already initialized.")
        return true
    end

    img_obj = img()
    if !cam.setup(13)
        print("ERROR: cam.setup(13) failed")
        img_obj = nil
        return false
    end

    print("Camera initialized: 1280x720")
    return true
end

# -------------------------------------------------
# 2. CAPTURE IMAGE INTO MAPPED BUFFER
# -------------------------------------------------
def capture_image()
    if img_obj == nil
        img_obj = img()
    end

    cam.get_image(img_obj, img.RGB565)

    var info = img_obj.info()
    w = info["width"]
    h = info["height"]
    var addr = info["buf_addr"]
    var len  = info["size"]

    var ptr = introspect.toptr(addr)
    mapped_buf = bytes(ptr, len)

    return true
end

# -------------------------------------------------
# 3. DRAW HELPERS
# -------------------------------------------------
def draw_text_buf(buf, txt, x0, y0, color)
    var txt_bytes = bytes().fromstring(txt)
    var cx = x0
    var cy = y0
    var idx = 0
    while idx < txt_bytes.size()
        var ch = txt_bytes.get(idx)
        var font_idx = -1
        if ch == 32  font_idx = 0 end
        if ch == 58  font_idx = 1 end
        if ch >= 48 && ch <= 57
            font_idx = ch - 46
        end
        if font_idx >= 0
            var py = 0
            while py < 8
                var row = FONT[font_idx * 8 + py]
                var px = 0
                while px < 8
                    if (row & (1 << (7 - px))) != 0
                        var px_x = cx + px
                        var px_y = cy + py
                        if px_x < w && px_y < h
                            var offset = (px_y * w + px_x) * 2
                            buf.set(offset,     color & 0xFF)
                            buf.set(offset + 1, (color >> 8) & 0xFF)
                        end
                    end
                    px += 1
                end
                py += 1
            end
            cx += 9
        end
        idx += 1
    end
end

def draw_box_buf(buf, x, y, width, height, color)
    var py = y
    while py < y + height
        var px = x
        while px < x + width
            if px < w && py < h
                var offset = (py * w + px) * 2
                buf.set(offset,     color & 0xFF)
                buf.set(offset + 1, (color >> 8) & 0xFF)
            end
            px += 1
        end
        py += 1
    end
end

# -------------------------------------------------
# 4. DRAW TIMESTAMP (TOP-LEFT + TOP-RIGHT)
# -------------------------------------------------
def draw_timestamp()
    if mapped_buf == nil
        print("ERROR: No mapped buffer. Call capture_image() first.")
        return
    end

    var ts = tasmota.rtc()['local']
    var date_str = tasmota.strftime("%Y-%m-%d", ts)
    var time_str = tasmota.strftime("%H:%M:%S", ts)

    # Top-left: date
    draw_box_buf(mapped_buf, 0, 0, 120, 16, 0x0000)
    draw_text_buf(mapped_buf, date_str, 4, 4, 0xFFFF)

    # Top-right: time
    draw_box_buf(mapped_buf, w - 120, 0, 120, 16, 0x0000)
    draw_text_buf(mapped_buf, time_str, w - 116, 4, 0xFFFF)
end

# -------------------------------------------------
# 5. CONVERT TO JPEG
# -------------------------------------------------
def convert_to_jpeg(quality)
    if img_obj == nil
        print("ERROR: No image object.")
        return false
    end
    img_obj.convert_to(img.JPEG, quality)
    return true
end

# -------------------------------------------------
# 6. SAVE TO FILE
# -------------------------------------------------
def save_jpeg()
    if img_obj == nil
        print("ERROR: No image to save.")
        return false
    end

    var ts = tasmota.rtc()['local']
    var date_str = tasmota.strftime("%Y-%m-%d", ts)
    var time_str = tasmota.strftime("%H:%M:%S", ts)

    var date_clean = string.split(date_str, '-').concat('')
    var time_clean = string.split(time_str, ':').concat('')
    var filename = "sd/img_" + date_clean + "_" + time_clean + ".jpg"

    var f = open(filename, "w")
    if f == nil
        print("ERROR: Failed to open file:", filename)
        return false
    end
    f.write(img_obj.get_buffer())
    f.close()

    print("SAVED:", filename)
    return true
end

# -------------------------------------------------
# 7. CLEANUP (call on shutdown)
# -------------------------------------------------
def cleanup()
    img_obj = nil
    mapped_buf = nil
    w = 0
    h = 0
    tasmota.gc()
    print("Cleanup complete.")
end

# -------------------------------------------------
# 8. FULL CAPTURE CYCLE (for timers)
# -------------------------------------------------
def capture_and_save()
    if !capture_image() return end
    draw_timestamp()
    if !convert_to_jpeg(63) return end
    save_jpeg()

    cleanup()
    # Optional: print heap
    var mem = tasmota.memory()
    print("Heap:", mem['heap_free'], "PSRAM:", mem['psram_free'])
end

# =================================================
# USAGE EXAMPLE (in real script or timer)
# =================================================

# 1. Initialize once
setup_camera()

# 2. Capture + save every 10 seconds
tasmota.add_cron("*/10 * * * * *", /-> capture_and_save(), "cam_timer")

# 3. Manual debug calls:
# capture_image()
# draw_timestamp()
# convert_to_jpeg(50)
# save_jpeg()

This will not work with the current official cam module and img class, but I can probably push some updates soon (needs some final tests with more hardware).

But maybe you can adapt it for the webcam driver using:
https://github.com/arendst/Tasmota/blob/ee1d867025a1a692726542ebeae93a7131adef5f/tasmota/tasmota_xdrv_driver/xdrv_81_esp32_webcam_task.ino#L114-133

[LucidEye]

Wow! That's great. Basic, simple, easy-to-read time and date stamps... nothing fancy. Perfect.
I'm ordering a couple more ESP32-CAM modules so I'll have more than one of these things for testing, so it may be several days before I can actually try testing any code, but thank you so much for your efforts so far... looks very promising!

One note however... I was not originally planning on writing any images to an SD card... I am currently grabbing stills remotely every 10-15 seconds from a Raspberry Pi running my home automation software using the Tasmota http://xxx.xxx.xxx.xxx:80/wc.jpg URL. Then I DL those stills from the Pi to my PC and compile them into a time lapse using KDENLive. Is your method saving every new frame to the ESP32's SD card, or just the latest frame so it can be grabbed externally? Seems like saving every frame might fill up the SD card very fast, or overwriting previous frames would cause a lot of wear on the SD card?

[sfromis]

I'd suggest using ESP32-S3 based camera modules, better speed and especially more PSRAM. Modules with ESP32-S3 N16R8 and same OV2640 are commonly sold. The basic cheap ESP32-CAM gets low scores for reliability.

Especially with PSRAM available, it should be workable without saving every image in flash/SD. With a buffer available in PSRAM (or snapped for the request), it should be feasible to provide a similar endpoint to the existing one for a static image, using Berry code. With a rudimentary test, I had no problems serving a jpeg from the camera, without going via the file system.

[LucidEye]

So I've been experimenting with using Claude AI to try building Tasmota Berry scripts that can perform a timestamp overlay, and it keeps telling me that "it isn't possible since Berry can't access the framebuffer directly". However, the AI also kept telling me that it could modify the Tasmota webcam driver to allow for creating a date/time stamp on the image while it's still in the framebuffer and it spit this out... although I don't have enough coding knowledge to know how to integrate this code into the existing driver, and no idea if it will work either way...

/*
 * Add this code to xdrv_81_esp32_webcam_task.ino or xdrv_81_esp32_webcam.ino
 * 
 * This adds timestamp overlay functionality to Tasmota32-webcam
 * Place timestamp with black background in lower-left corner
 * Format: MM/DD/YYYY   HH:MM:SS
 */

// ============================================================================
// TIMESTAMP OVERLAY ADDITIONS
// ============================================================================

// Add these includes at the top of the file (if not already present)
#include <time.h>
#include "esp_sntp.h"

// Add this structure to store timestamp settings (add near other settings structs)
struct WEBCAM_TIMESTAMP {
  bool enabled;           // Enable/disable timestamp
  uint8_t font_scale;     // Font scale (1-3)
  uint8_t padding;        // Padding around text
  uint32_t text_color;    // RGB888 text color
  uint32_t bg_color;      // RGB888 background color
} WcTimestamp;

// Initialize timestamp settings (add to initialization function)
void WcTimestampInit(void) {
  WcTimestamp.enabled = true;
  WcTimestamp.font_scale = 1;
  WcTimestamp.padding = 6;
  WcTimestamp.text_color = 0xFFFFFF;  // White
  WcTimestamp.bg_color = 0x000000;    // Black
}

// Simple 5x7 font bitmap (add this array globally)
static const uint8_t font_5x7[][5] = {
  {0x00, 0x00, 0x00, 0x00, 0x00}, // Space (32)
  {0x00, 0x00, 0x5F, 0x00, 0x00}, // !
  {0x00, 0x07, 0x00, 0x07, 0x00}, // "
  {0x14, 0x7F, 0x14, 0x7F, 0x14}, // #
  {0x24, 0x2A, 0x7F, 0x2A, 0x12}, // $
  {0x23, 0x13, 0x08, 0x64, 0x62}, // %
  {0x36, 0x49, 0x55, 0x22, 0x50}, // &
  {0x00, 0x05, 0x03, 0x00, 0x00}, // '
  {0x00, 0x1C, 0x22, 0x41, 0x00}, // (
  {0x00, 0x41, 0x22, 0x1C, 0x00}, // )
  {0x08, 0x2A, 0x1C, 0x2A, 0x08}, // *
  {0x08, 0x08, 0x3E, 0x08, 0x08}, // +
  {0x00, 0x50, 0x30, 0x00, 0x00}, // ,
  {0x08, 0x08, 0x08, 0x08, 0x08}, // -
  {0x00, 0x60, 0x60, 0x00, 0x00}, // .
  {0x20, 0x10, 0x08, 0x04, 0x02}, // /
  {0x3E, 0x51, 0x49, 0x45, 0x3E}, // 0
  {0x00, 0x42, 0x7F, 0x40, 0x00}, // 1
  {0x42, 0x61, 0x51, 0x49, 0x46}, // 2
  {0x21, 0x41, 0x45, 0x4B, 0x31}, // 3
  {0x18, 0x14, 0x12, 0x7F, 0x10}, // 4
  {0x27, 0x45, 0x45, 0x45, 0x39}, // 5
  {0x3C, 0x4A, 0x49, 0x49, 0x30}, // 6
  {0x01, 0x71, 0x09, 0x05, 0x03}, // 7
  {0x36, 0x49, 0x49, 0x49, 0x36}, // 8
  {0x06, 0x49, 0x49, 0x29, 0x1E}, // 9
  {0x00, 0x36, 0x36, 0x00, 0x00}, // : (58)
};

// Draw a single character on RGB888 buffer
void WcDrawChar(uint8_t *fb, uint16_t width, uint16_t height, 
                uint16_t x, uint16_t y, char c, uint32_t color, uint8_t scale) {
  if (c < 32 || c > 58) return;  // Only support space to colon
  
  const uint8_t *glyph = font_5x7[c - 32];
  
  for (uint8_t col = 0; col < 5; col++) {
    uint8_t line = glyph[col];
    for (uint8_t row = 0; row < 7; row++) {
      if (line & 0x01) {
        // Draw scaled pixel
        for (uint8_t sy = 0; sy < scale; sy++) {
          for (uint8_t sx = 0; sx < scale; sx++) {
            uint16_t px = x + (col * scale) + sx;
            uint16_t py = y + (row * scale) + sy;
            if (px < width && py < height) {
              uint32_t offset = (py * width + px) * 3;
              fb[offset + 0] = (color >> 16) & 0xFF; // R
              fb[offset + 1] = (color >> 8) & 0xFF;  // G
              fb[offset + 2] = color & 0xFF;         // B
            }
          }
        }
      }
      line >>= 1;
    }
  }
}

// Draw filled rectangle on RGB888 buffer
void WcDrawRect(uint8_t *fb, uint16_t width, uint16_t height,
                uint16_t x, uint16_t y, uint16_t w, uint16_t h, uint32_t color) {
  for (uint16_t py = y; py < y + h && py < height; py++) {
    for (uint16_t px = x; px < x + w && px < width; px++) {
      uint32_t offset = (py * width + px) * 3;
      fb[offset + 0] = (color >> 16) & 0xFF; // R
      fb[offset + 1] = (color >> 8) & 0xFF;  // G
      fb[offset + 2] = color & 0xFF;         // B
    }
  }
}

// Draw text string on RGB888 buffer
void WcDrawText(uint8_t *fb, uint16_t width, uint16_t height,
                uint16_t x, uint16_t y, const char *text, 
                uint32_t color, uint8_t scale) {
  uint16_t cursor_x = x;
  while (*text) {
    WcDrawChar(fb, width, height, cursor_x, y, *text, color, scale);
    cursor_x += 6 * scale; // 5 pixels + 1 spacing
    text++;
  }
}

// Get formatted timestamp string
void WcGetTimestamp(char *buffer, size_t buffer_size) {
  time_t now;
  struct tm timeinfo;
  
  time(&now);
  localtime_r(&now, &timeinfo);
  
  // Format: MM/DD/YYYY   HH:MM:SS
  snprintf(buffer, buffer_size, "%02d/%02d/%04d   %02d:%02d:%02d",
           timeinfo.tm_mon + 1,
           timeinfo.tm_mday,
           timeinfo.tm_year + 1900,
           timeinfo.tm_hour,
           timeinfo.tm_min,
           timeinfo.tm_sec);
}

// Main function to overlay timestamp on frame buffer
void WcOverlayTimestamp(camera_fb_t *fb) {
  if (!WcTimestamp.enabled || !fb) return;
  
  // Only process if we have RGB888 format (or convert JPEG first)
  uint8_t *rgb_buf = NULL;
  bool needs_free = false;
  uint16_t width = fb->width;
  uint16_t height = fb->height;
  
  if (fb->format == PIXFORMAT_JPEG) {
    // Need to decode JPEG to RGB888 first
    // This would require JPEG decoder - see existing WcConvertFrame code
    // For now, skip JPEG frames
    AddLog(LOG_LEVEL_DEBUG, "CAM: Timestamp - JPEG format not supported, use RGB888");
    return;
  } else if (fb->format == PIXFORMAT_RGB888) {
    rgb_buf = fb->buf;
  } else {
    return; // Unsupported format
  }
  
  // Get timestamp string
  char timestamp[32];
  WcGetTimestamp(timestamp, sizeof(timestamp));
  
  // Calculate text dimensions
  uint8_t char_width = 6 * WcTimestamp.font_scale;
  uint8_t char_height = 7 * WcTimestamp.font_scale;
  uint16_t text_width = strlen(timestamp) * char_width;
  uint16_t text_height = char_height;
  
  // Position in lower-left with padding
  uint16_t x = WcTimestamp.padding;
  uint16_t y = height - text_height - (WcTimestamp.padding * 2);
  
  // Draw background rectangle
  uint16_t bg_width = text_width + (WcTimestamp.padding * 2);
  uint16_t bg_height = text_height + (WcTimestamp.padding * 2);
  WcDrawRect(rgb_buf, width, height, x, y, bg_width, bg_height, WcTimestamp.bg_color);
  
  // Draw timestamp text
  WcDrawText(rgb_buf, width, height, 
             x + WcTimestamp.padding, 
             y + WcTimestamp.padding, 
             timestamp, 
             WcTimestamp.text_color, 
             WcTimestamp.font_scale);
  
  AddLog(LOG_LEVEL_DEBUG_MORE, "CAM: Timestamp overlay: %s", timestamp);
}

// ============================================================================
// COMMAND HANDLERS
// Add these to the command table
// ============================================================================

void CmndWcTimestamp(void) {
  // Enable/disable timestamp: WcTimestamp 0/1
  if (XdrvMailbox.data_len > 0) {
    WcTimestamp.enabled = (XdrvMailbox.payload != 0);
  }
  ResponseCmndStateText(WcTimestamp.enabled);
}

void CmndWcTimestampScale(void) {
  // Set font scale: WcTimestampScale 1-3
  if ((XdrvMailbox.payload >= 1) && (XdrvMailbox.payload <= 3)) {
    WcTimestamp.font_scale = XdrvMailbox.payload;
  }
  ResponseCmndNumber(WcTimestamp.font_scale);
}

void CmndWcTimestampPadding(void) {
  // Set padding: WcTimestampPadding 0-20
  if ((XdrvMailbox.payload >= 0) && (XdrvMailbox.payload <= 20)) {
    WcTimestamp.padding = XdrvMailbox.payload;
  }
  ResponseCmndNumber(WcTimestamp.padding);
}

// ============================================================================
// INTEGRATION INSTRUCTIONS
// ============================================================================
/*
 * TO INTEGRATE THIS CODE:
 * 
 * 1. Add the structures, functions, and font data above to the driver file
 * 
 * 2. Call WcTimestampInit() in the driver initialization function
 * 
 * 3. Add these commands to the command table (find const char kWebcamCommands[]):
 *    const char kWebcamCommands[] PROGMEM = 
 *      "|" D_CMND_WCTIMESTAMP "|" D_CMND_WCTIMESTAMP_SCALE "|" D_CMND_WCTIMESTAMP_PADDING;
 * 
 * 4. Add to command handler function (find void (* const WebcamCommand[])):
 *    void (* const WebcamCommand[])(void) PROGMEM = {
 *      &CmndWcTimestamp, &CmndWcTimestampScale, &CmndWcTimestampPadding
 *    };
 * 
 * 5. Add command name definitions to i18n file (find #define D_CMND_):
 *    #define D_CMND_WCTIMESTAMP "WcTimestamp"
 *    #define D_CMND_WCTIMESTAMP_SCALE "WcTimestampScale"
 *    #define D_CMND_WCTIMESTAMP_PADDING "WcTimestampPadding"
 * 
 * 6. Call WcOverlayTimestamp(fb) after capturing frame and before encoding/sending
 *    Example location: In the frame capture loop, after esp_camera_fb_get()
 *    
 *    camera_fb_t *fb = esp_camera_fb_get();
 *    if (fb) {
 *      WcOverlayTimestamp(fb);  // Add timestamp overlay
 *      // ... rest of frame processing
 *      esp_camera_fb_return(fb);
 *    }
 * 
 * USAGE COMMANDS:
 * - WcTimestamp 1         : Enable timestamp overlay
 * - WcTimestamp 0         : Disable timestamp overlay
 * - WcTimestampScale 2    : Set font scale (1-3)
 * - WcTimestampPadding 8  : Set padding (0-20 pixels)
 */

[Staars]

Another simple variant to build is a new env in platformio_tasmota_cenv.ini:

[env:tasmota32-webcam_berry]
extends                 = env:tasmota32_base
board                   = esp32-fix
board_build.f_cpu       = 240000000L
build_flags             = ${env:tasmota32_base.build_flags}
                          -DUSE_WEBCAM
                          -DUSE_BERRY_CAM
                          -DUSE_BERRY_IMAGE
                          -DOTA_URL='""'

tested with a fresh local Tasmota clone.

[sfromis]

Again, if you use tasmota32-webcam with unmodified FIRMWARE_WEBCAM, the #undef USE_WS2812 I warned you about will be effected, and the things you do in user_config_override.h are secondary to what is hard enforced by FIRMWARE_WEBCAM

When I linked to show you the content of the default FIRMWARE_WEBCAM, the point is that while using this setup unmodified does not work (due to the Berry code needing to have USE_WS2812), it does illustrate the symbols you need on top of tasmota32_base - instead of only adding the ones you need for additional Berry features.

While it would be workable to put the Berry code in autoexec.be, I like it better to keep such code in its own file (maybe named camstream.be), and then have load('camstream.be') in autoexec.be. This structure is also workable if booting without an autoexec.be and test by issuing the load from the "Berry Scripting Console". Clearly named files also helps understanding.

[sfromis]

@Staars Surprised by the low amount of symbols you included, I tried with the setup you posted, and got no camera started on a cheap ESP32-CAM. Then I added symbols based on the standard compile setup, and then it worked, also with the Berry code.

                              -DCAMERA_MODEL_AI_THINKER
                              -DUSE_WEBCAM_V2
                              -DENABLE_RTSPSERVER

[LucidEye]

OK... now I'm even more confused. Please understand, once again, I am not a programmer. So I really need more details on how and what to do to make this work.

Starrs
You're saying to basically create a new build environment so the berry script can be used, but I don't see how this addresses the "problem" sfromis keeps mentioning about the WS2812. Also I am confused that you say to put this in platformio_tasmota_cenv.ini, but sfromis refers to platformio_tasmota_env32.ini

Sfromis
Are you saying that I need to directly modify the tasmota_configurations_ESP32.h file...
https://github.com/arendst/Tasmota/blob/development/tasmota/include/tasmota_configurations_ESP32.h#L200-L244
So that the WS2812 is #defined in the FIRMWARE-WEBCAM section?
And then I also need to modify the user_config_override.h file to include the USE_BERRY_CAM and USE_BERRY_IMAGE flags?
And that's all I should need to do to the Tasmota32-Webcam build so that it works with the Berry script?

[sfromis]

The docs for making builds does not suggest modifying platformio_tasmota_env32.ini (I was merely referring to where the standard settings are found.
https://tasmota.github.io/docs/Compile-your-build/#customize-your-build
As Staars suggested, the docs also recommends doing you addition of a new build environment in platformio_tasmota_cenv.ini

No, I was not suggesting to modify tasmota_configurations_ESP32.h but it would also work doing it this way. This approach is not the recommended one, as a new copy of Tasmota source could overwrite the standard files, but would not overwrite the files specifically meant for you to modify.

[Staars]

It was a complete fresh git clone and removed .platformio.
Without a build inside a container or something similar we can never be complete sure about unwanted remnants,that influence the build, but it was pretty close to it.
Besides from reading through the code I would expect, that this short version should work.

[LucidEye]

Again, I am not a trained programmer, so most of what you just said is completely Greek to me.
I downloaded the most recent ZIP of the Tasmota-Development branch, which is pretty much the same thing as performing a git clone into a chosen directory, right?
"without a build inside a container" --- I don't really know what containers are or how they work, I have never used anything like Docker if that's what you are referring to.
"and removed .platformio" --- You uninstalled the PlatformIO extension? You deleted the /.platformio directory? I don't understand, please explain in precise detail.

[sfromis]

Yes, "container" was referring to running in Docker. That is a viable approach without installing VSCode, PlatformIO or git. I'm using this way myself, but it is just fine to have the tools installed directly in the operating system. And yes, git clone is similar to downloading+unpacking the .zip (which is also my usual approach).

When reading "removing .platformio", that dot at the start is very important; indeed it refers to removing that specific directory, to avoid PlatformIO reusing parts from previous builds. Sometimes this resolves build issues, but is not always needed.

[LucidEye]

OK... after re-reading over this entire thread, I started over in VS Code, created a new fresh folder where a fresh DL of Tasmota-Development 15.1.0.3 is unzipped.
I used the Tasmota_base build environment.
I manually added all the #define switches that were in FIRMWARE-WEBCAM, as well as BERRY_CAM, BERRY_IMAGE, and WS2812 to user_config_override.h.
The build ran successfully with no errors and only "normal" warnings regarding partition sizes!
I uploaded the firmware via OTA and it installed successfully!
The Tasmota GUI shows the live-stream, and my external Raspberry Pi can grab stills from the http://xxx.xxx.xxx.xxx:80/cam.jpg URL and I see the timestamp!

There is definitely a noticeable lag (about 2 seconds as sfromis noted) between the time the Pi requests an image, and the time it is finally displayed on the Pi. This lag is causing the Pi and Tasmota to throw errors when there is no image ready to grab from the ESP32. This is causing far too many lost frames for it to be usable for compiling timelapse vids, but I'm assuming I can only fix this by getting a better ESP32 or by reducing the WcResolution :-(
This is what I see in the Tasmota Console about 2-3 times a minute...

20:37:35.361 BRY: Exception> 'cam_error' - could not get frame
20:37:35.361 stack traceback:
20:37:35.362 	<native>: in native function
20:37:35.362 	<unknown source>: in function `capture_image`
20:37:35.373 	<unknown source>: in function `send_image`
20:37:35.373 	<unknown source>: in function `<lambda>`
20:37:46.261 CAM: Frame fail
20:38:02.397 CAM: Frame fail
20:38:18.412 CAM: Frame fail

Also, the timestamp in the picture, does NOT match the time the picture was requested (which is also the timestamp in the image filename). The timestamps in the images are reflecting the lag-time after being processed by the Berry script... this is not what I was hoping for :-(
Is there some way to fix this so that the visible timestamp is of the exact time the image was requested by the remote machine instead of a timestamp that shows the post-processing lag?

[LucidEye]

Well, just for kicks I tried refactoring the script to use 24-bit RGB888 color depth, and it wouldn't work, at least not on my older ESP32-CAM device, console was just errors saying it couldn't get the frame. If someone with a better device, like an ESP32-S3 CAM would like to give this a quick test just to see if it will work on better hardware I'd appreciate it. Thank you.
Berry_timestamp_BIG-FONT_24-bit_NEEDS-TESTING.txt

[sfromis]

That test case worked with my webcam with ESP32-S3 8M flash, OV2640. A bit better image quality than your previous code from 12 hours ago. That example also suffered from wrong colors, red/blue was swapped. Testing above 720x1280 still failed.

[LucidEye]

Thank you for testing that. I never expected it to work at anything above 720p. It's encouraging that it works at all... did you happen to notice any difference in the lag between a capture request and jpg delivery? The 16-bit script is consistently getting anywhere from a 1-3 second lag on the visible timestamp vs it's actual capture request time... which may let me increase the frame-grab interval from every 15 seconds to 10 seconds. So, overall I'm really amazed at how well this script works, especially on my older hardware... and it's also an incentive to upgrade asap too.
Thank you once again for your efforts and assistance!

[Staars]

I am currently testing a newer version of my driver and could get up to 1024 x 768 pixel with raw RGB565 from the camera, which reduces JPEG artifacts after compression tremendously.
This seems to drive the camera module and the underlying esp32 camera driver to edge and I am pretty sure, this will not work on every module. Basically it is needed to go down with the clock speed of the camera whenever the resolution goes higher.

I assume that the maximum achievable resolution is undefined behavior and will vary with every setup.

When I am done with my tests, I will probably push a new version in the not so distant future, but there are still some things I am not sure about.

[LucidEye]

Thank you Starrs. I look forward to testing whatever you come up with. In the meantime I'm on the lookout for some better hardware options.
The jpg quality and artifacting are most noticeable when capturing stills in low-light conditions, so when I compile the timelapse video, you can really see the artifacting "moving" all over the video especially at night.
I already keep the WcClock set to 10 (it's lowest setting). When the Berry script is running, setting anything higher than 15 seems to make it unstable and cause more dropped frames.
I know anything dealing with image or video processing really pushes these little MCUs to their limits. Case in point... The Berry timestamp script is working nicely so far, but I noticed that if I leave the video live-stream open while also grabbing stills with the Berry script, the stills will start dropping frames quite a bit because the MCU is just trying to do too much. When that happens I often see this error in the Tasmota Console...

07:19:46.114 BRY: Exception> 'value_error' - size is required
07:19:46.114 stack traceback:
07:19:46.115 	<native>: in native function
07:19:46.115 	<unknown source>: in function `capture_image`
07:19:46.115 	<unknown source>: in function `send_image`
07:19:46.116 	<unknown source>: in function `<lambda>`

Anyway, I ended up deciding on a 12x12 font which is easily readable even if the video is not in full-screen mode.
This is the timestamp script as I'll be using it for now...

import cam
import webserver
import string
import introspect

# To capture timestamped jpg images from the Tasmota ESP32-CAM, use URL http://xxx.xxx.xxx.xxx:80/cam.jpg

class CamStream

    static var FONT = bytes(
        # Each glyph: exactly 24 bytes (12 rows × 2 bytes/row)
        # Each row is exactly 4 hex chars (2 bytes = 12 pixels used, 4 pixels padding)
        
        # space (12x12)
        "0000" "0000" "0000" "0000" "0000" "0000"
        "0000" "0000" "0000" "0000" "0000" "0000"
        
        # : (12x12)
        "0000" "0000" "0000" "0380" "0380" "0000"
        "0000" "0380" "0380" "0000" "0000" "0000"
        
        # / (12x12)
        "0020" "0060" "00C0" "0180" "0300" "0600"
        "0C00" "1800" "3000" "6000" "0000" "0000"
        
        # 0 (12x12)
        "0000" "1F80" "31C0" "60E0" "6060" "6060"
        "6060" "60E0" "31C0" "1F80" "0000" "0000"
        
        # 1 (12x12)
        "0000" "0C00" "1C00" "3C00" "0C00" "0C00"
        "0C00" "0C00" "0C00" "3F00" "0000" "0000"
        
        # 2 (12x12)
        "0000" "1F80" "31C0" "60E0" "00E0" "01C0"
        "0380" "0700" "0E00" "3FE0" "0000" "0000"
        
        # 3 (12x12)
        "0000" "1F80" "31C0" "60E0" "01C0" "0F80"
        "01C0" "60E0" "31C0" "1F80" "0000" "0000"
        
        # 4 (12x12)
        "0000" "0180" "0380" "0780" "0D80" "1980"
        "3FE0" "0180" "0180" "0180" "0000" "0000"
        
        # 5 (12x12)
        "0000" "3FE0" "3000" "3000" "3F80" "01C0"
        "0060" "6060" "30C0" "1F80" "0000" "0000"
        
        # 6 (12x12)
        "0000" "0F80" "1C00" "3000" "3F80" "31C0"
        "6060" "6060" "30C0" "1F80" "0000" "0000"
        
        # 7 (12x12)
        "0000" "3FE0" "0060" "00C0" "0180" "0300"
        "0600" "0C00" "0C00" "0C00" "0000" "0000"
        
        # 8 (12x12)
        "0000" "1F80" "31C0" "31C0" "1F80" "31C0"
        "60E0" "60E0" "31C0" "1F80" "0000" "0000"
        
        # 9 (12x12)
        "0000" "1F80" "31C0" "60E0" "60E0" "31E0"
        "1FE0" "00E0" "01C0" "1F80" "0000" "0000"
        
        # P (12x12)
        "0000" "3F80" "30C0" "30C0" "30C0" "3F80"
        "3000" "3000" "3000" "3000" "0000" "0000"
        
        # A (12x12)
        "0000" "0E00" "1F00" "3180" "3180" "3180"
        "3F80" "60C0" "60C0" "60C0" "0000" "0000"
        
        # M (12x12)
        "0000" "60C0" "71C0" "7BC0" "6EC0" "64C0"
        "60C0" "60C0" "60C0" "60C0" "0000" "0000"
        
        # D (12x12)
        "0000" "3F00" "30C0" "30C0" "3060" "3060"
        "3060" "30C0" "30C0" "3F00" "0000" "0000"
        
        # F (12x12)
        "0000" "3FE0" "3000" "3000" "3000" "3F00"
        "3000" "3000" "3000" "3000" "0000" "0000"
        
        # J (12x12)
        "0000" "00E0" "0060" "0060" "0060" "0060"
        "0060" "6060" "30C0" "1F80" "0000" "0000"
        
        # N (12x12)
        "0000" "60C0" "70C0" "78C0" "6CC0" "66C0"
        "63C0" "61C0" "60C0" "60C0" "0000" "0000"
        
        # O (12x12)
        "0000" "1F80" "31C0" "60E0" "6060" "6060"
        "6060" "60E0" "31C0" "1F80" "0000" "0000"
        
        # S (12x12)
        "0000" "1F80" "31C0" "3000" "1F80" "01C0"
        "0060" "6060" "31C0" "1F80" "0000" "0000"
        
        # T (12x12)
        "0000" "3FC0" "0300" "0300" "0300" "0300"
        "0300" "0300" "0300" "0300" "0000" "0000"
        
        # W (12x12)
        "0000" "60C0" "60C0" "60C0" "60C0" "64C0"
        "6EC0" "7BC0" "71C0" "60C0" "0000" "0000"
        
        # a (12x12) - lowercase
        "0000" "0000" "0000" "0000" "1F80" "01C0"
        "1FC0" "30C0" "31C0" "1FC0" "0000" "0000"
        
        # b (12x12) - lowercase
        "0000" "3000" "3000" "3000" "3F80" "30C0"
        "3060" "3060" "30C0" "3F80" "0000" "0000"
        
        # c (12x12) - lowercase
        "0000" "0000" "0000" "0000" "1F80" "30C0"
        "3000" "3000" "30C0" "1F80" "0000" "0000"
        
        # d (12x12) - lowercase
        "0000" "0060" "0060" "0060" "1FE0" "30E0"
        "6060" "6060" "30E0" "1FE0" "0000" "0000"
        
        # e (12x12) - lowercase
        "0000" "0000" "0000" "0000" "1F80" "30C0"
        "3FC0" "3000" "30C0" "1F80" "0000" "0000"
        
        # g (12x12) - lowercase (with descender)
        "0000" "0000" "0000" "0000" "1FE0" "30E0"
        "6060" "30E0" "1FE0" "0060" "30C0" "1F80"
        
        # h (12x12) - lowercase
        "0000" "3000" "3000" "3000" "3F80" "30C0"
        "3060" "3060" "3060" "3060" "0000" "0000"
        
        # i (12x12) - lowercase
        "0000" "0300" "0300" "0000" "0F00" "0300"
        "0300" "0300" "0300" "0FC0" "0000" "0000"
        
        # l (12x12) - lowercase
        "0000" "0E00" "0600" "0600" "0600" "0600"
        "0600" "0600" "0600" "0380" "0000" "0000"
        
        # n (12x12) - lowercase
        "0000" "0000" "0000" "0000" "3F80" "30C0"
        "3060" "3060" "3060" "3060" "0000" "0000"
        
        # o (12x12) - lowercase
        "0000" "0000" "0000" "0000" "1F80" "30C0"
        "6060" "6060" "30C0" "1F80" "0000" "0000"
        
        # p (12x12) - lowercase (with descender)
        "0000" "0000" "0000" "0000" "3F80" "30C0"
        "3060" "30C0" "3F80" "3000" "3000" "3000"
        
        # r (12x12) - lowercase
        "0000" "0000" "0000" "0000" "3BC0" "3FC0"
        "3000" "3000" "3000" "3000" "0000" "0000"
        
        # t (12x12) - lowercase
        "0000" "0000" "0600" "0600" "1F80" "0600"
        "0600" "0600" "0600" "0380" "0000" "0000"
        
        # u (12x12) - lowercase
        "0000" "0000" "0000" "0000" "3060" "3060"
        "3060" "3060" "30E0" "1FE0" "0000" "0000"
        
        # v (12x12) - lowercase
        "0000" "0000" "0000" "0000" "6060" "6060"
        "30C0" "1980" "0F00" "0600" "0000" "0000"
        
        # y (12x12) - lowercase (with descender)
        "0000" "0000" "0000" "0000" "6060" "6060"
        "30C0" "1980" "0F00" "0600" "0C00" "7800"
    )
    
    var img_obj, w, h, mapped_buf, matrix, glyph_cache
    
    def init()
        self.img_obj = nil
        self.mapped_buf = nil
        self.matrix = nil
        self.glyph_cache = {}
        
        # Pre-create glyph pixmats (12x12, 2-bpp mono)
        self.create_glyph_cache()
        
        self.setup_camera()
        self.web_add_handler()
        tasmota.add_driver(self)
        
        var wifi = tasmota.wifi()
        if wifi && wifi.find('ip')
            print(f"Camera stream ready. Access at http://{wifi['ip']}/cam.jpg")
        else
            print("Camera stream ready. Access at http://<device-ip>/cam.jpg")
        end
    end
    
    def create_glyph_cache()
        # Create pixmat for each character using bitplane constructor
        var chars = " :/0123456789PAMDFJNOSTWabcdeghilnoprtuvy"
        var idx = 0
        while idx < size(chars)
            var ch = chars[idx]
            var font_offset = idx * 12 * 2
            var glyph_bytes = self.FONT[font_offset .. font_offset + 23]
            # Create 12x12 1-bpp pixmat from bitplane data (2 byte per row)
            self.glyph_cache[ch] = pixmat(glyph_bytes, 2)
            idx += 1
        end
    end
    
    def setup_camera()
        if self.img_obj != nil
            print("Camera already initialized.")
            return true
        end

        self.img_obj = img()
        if !cam.setup(13)
            print("ERROR: cam.setup(13) failed")
            self.img_obj = nil
            return false
        end

        print("Camera initialized: 1280x720")
        return true
    end
    
    def capture_image()
        if self.img_obj == nil
            self.img_obj = img()
        end

        cam.get_image(self.img_obj) # old image -> discard 
        cam.get_image(self.img_obj, img.RGB565) # fresh image

        var info = self.img_obj.info()
        self.w = info["width"]
        self.h = info["height"]
        var addr = info["buf_addr"]
        var len  = info["size"]

        var ptr = introspect.toptr(addr)
        self.mapped_buf = bytes(ptr, len)
        
        # Wrap camera buffer in pixmat (2-bpp for RGB565)
        self.matrix = pixmat(self.mapped_buf, self.w, self.h, 2)

        return true
    end
    
    def draw_text(txt, x0, y0, color)
        var cx = x0
        var idx = 0
        while idx < size(txt)
            var ch = txt[idx]
            var glyph = self.glyph_cache.find(ch)
            if glyph != nil
                # Blit 12x12 glyph with RGB565 color tint (mono->color expansion)
                self.matrix.blit(glyph, cx, y0, 255, color)
                cx += 13  # 12px glyph + 1px spacing
            end
            idx += 1
        end
    end
    
    def draw_box(x, y, width, height)
        # Create temporary box pixmat and blit once
        var box = pixmat(width, height, 2)
        box.clear(0x00)  # Black fill
        self.matrix.blit(box, x, y)
        # box will be GC'd after function returns
    end
    
    def draw_timestamp()
        if self.matrix == nil
            print("ERROR: No matrix buffer.")
            return
        end

        var ts = tasmota.rtc()['local']
        # Combine date and time in single string format: "MM/DD/YYYY HH:MM:SS"
        #var timestamp_str = tasmota.strftime("%m/%d/%Y %H:%M:%S", ts)
        
        # Example of following timestamp format - Thu Nov 27 2025  10:24:15 PM
        var timestamp_str = tasmota.strftime("%a %b %e %Y  %l:%M:%S %p", ts)
        
        # Example of following timestamp format - Thu 11/27/2025 10:24:15 PM
        #var timestamp_str = tasmota.strftime("%a %m/%d/%Y  %l:%M:%S %p", ts)


        # Draw timestamp in top-left corner (adjusted for 12x12 font)
        self.draw_box(455, 10, 370, 20)
        self.draw_text(timestamp_str, 459, 15, 0xFFFF)
    end
    
    def convert_to_jpeg(quality)
        if self.img_obj == nil
            print("ERROR: No image object.")
            return false
        end
        self.img_obj.convert_to(img.JPEG, quality)
        return true
    end
    
    def send_image()
        if !self.capture_image()
            webserver.content_open(500, "text/plain")
            webserver.content_send("Error: Failed to capture image")
            return
        end
        
        self.draw_timestamp()
        
        if !self.convert_to_jpeg(63)
            webserver.content_open(500, "text/plain")
            webserver.content_send("Error: Failed to convert to JPEG")
            return
        end
        
        var jpeg_data = self.img_obj.get_buffer()
        
        webserver.content_open(200, "image/jpeg")
        webserver.content_send(jpeg_data)
        
        # Cleanup
        self.img_obj = nil
        self.mapped_buf = nil
        self.matrix = nil
        tasmota.gc()
    end
    
    def web_add_handler()
        webserver.on("/cam.jpg", / -> self.send_image(), webserver.HTTP_GET)
        webserver.on("/cam.jpg", / -> self.send_image(), webserver.HTTP_POST)
    end
end

cam_stream = CamStream()