forked from xiaozhi/xiaozhi-esp32
344 lines
13 KiB
C++
344 lines
13 KiB
C++
#include "sscma_camera.h"
|
||
#include "mcp_server.h"
|
||
#include "display.h"
|
||
#include "board.h"
|
||
#include "system_info.h"
|
||
#include "config.h"
|
||
|
||
#include <esp_log.h>
|
||
#include <esp_heap_caps.h>
|
||
#include <img_converters.h>
|
||
#include <cstring>
|
||
|
||
#define TAG "SscmaCamera"
|
||
|
||
#define IMG_JPEG_BUF_SIZE 48 * 1024
|
||
|
||
SscmaCamera::SscmaCamera(esp_io_expander_handle_t io_exp_handle) {
|
||
sscma_client_io_spi_config_t spi_io_config = {0};
|
||
spi_io_config.sync_gpio_num = BSP_SSCMA_CLIENT_SPI_SYNC;
|
||
spi_io_config.cs_gpio_num = BSP_SSCMA_CLIENT_SPI_CS;
|
||
spi_io_config.pclk_hz = BSP_SSCMA_CLIENT_SPI_CLK;
|
||
spi_io_config.spi_mode = 0;
|
||
spi_io_config.wait_delay = 10; //两个transfer之间至少延时4ms,但当前 FREERTOS_HZ=100, 延时精度只能达到10ms,
|
||
spi_io_config.user_ctx = NULL;
|
||
spi_io_config.io_expander = io_exp_handle;
|
||
spi_io_config.flags.sync_use_expander = BSP_SSCMA_CLIENT_RST_USE_EXPANDER;
|
||
|
||
sscma_client_new_io_spi_bus((sscma_client_spi_bus_handle_t)BSP_SSCMA_CLIENT_SPI_NUM, &spi_io_config, &sscma_client_io_handle_);
|
||
|
||
sscma_client_config_t sscma_client_config = SSCMA_CLIENT_CONFIG_DEFAULT();
|
||
sscma_client_config.event_queue_size = CONFIG_SSCMA_EVENT_QUEUE_SIZE;
|
||
sscma_client_config.tx_buffer_size = CONFIG_SSCMA_TX_BUFFER_SIZE;
|
||
sscma_client_config.rx_buffer_size = CONFIG_SSCMA_RX_BUFFER_SIZE;
|
||
sscma_client_config.process_task_stack = CONFIG_SSCMA_PROCESS_TASK_STACK_SIZE;
|
||
sscma_client_config.process_task_affinity = CONFIG_SSCMA_PROCESS_TASK_AFFINITY;
|
||
sscma_client_config.process_task_priority = CONFIG_SSCMA_PROCESS_TASK_PRIORITY;
|
||
sscma_client_config.monitor_task_stack = CONFIG_SSCMA_MONITOR_TASK_STACK_SIZE;
|
||
sscma_client_config.monitor_task_affinity = CONFIG_SSCMA_MONITOR_TASK_AFFINITY;
|
||
sscma_client_config.monitor_task_priority = CONFIG_SSCMA_MONITOR_TASK_PRIORITY;
|
||
sscma_client_config.reset_gpio_num = BSP_SSCMA_CLIENT_RST;
|
||
sscma_client_config.io_expander = io_exp_handle;
|
||
sscma_client_config.flags.reset_use_expander = BSP_SSCMA_CLIENT_RST_USE_EXPANDER;
|
||
|
||
sscma_client_new(sscma_client_io_handle_, &sscma_client_config, &sscma_client_handle_);
|
||
|
||
sscma_data_queue_ = xQueueCreate(1, sizeof(SscmaData));
|
||
|
||
sscma_client_callback_t callback = {0};
|
||
|
||
callback.on_event = [](sscma_client_handle_t client, const sscma_client_reply_t *reply, void *user_ctx) {
|
||
SscmaCamera* self = static_cast<SscmaCamera*>(user_ctx);
|
||
if (!self) return;
|
||
char *img = NULL;
|
||
int img_size = 0;
|
||
if (sscma_utils_fetch_image_from_reply(reply, &img, &img_size) == ESP_OK)
|
||
{
|
||
ESP_LOGI(TAG, "image_size: %d\n", img_size);
|
||
// 将数据通过队列发送出去
|
||
SscmaData data;
|
||
data.img = (uint8_t*)img;
|
||
data.len = img_size;
|
||
|
||
// 清空队列，保证只保存最新的数据
|
||
SscmaData dummy;
|
||
while (xQueueReceive(self->sscma_data_queue_, &dummy, 0) == pdPASS) {
|
||
if (dummy.img) {
|
||
heap_caps_free(dummy.img);
|
||
}
|
||
}
|
||
xQueueSend(self->sscma_data_queue_, &data, 0);
|
||
// 注意：img 的释放由接收方负责
|
||
}
|
||
};
|
||
callback.on_connect = [](sscma_client_handle_t client, const sscma_client_reply_t *reply, void *user_ctx) {
|
||
ESP_LOGI(TAG, "SSCMA client connected");
|
||
};
|
||
|
||
callback.on_log = [](sscma_client_handle_t client, const sscma_client_reply_t *reply, void *user_ctx) {
|
||
ESP_LOGI(TAG, "log: %s\n", reply->data);
|
||
};
|
||
|
||
sscma_client_register_callback(sscma_client_handle_, &callback, this);
|
||
|
||
sscma_client_init(sscma_client_handle_);
|
||
|
||
ESP_LOGI(TAG, "SSCMA client initialized");
|
||
// 设置分辨率
|
||
// 3 = 640x480
|
||
if (sscma_client_set_sensor(sscma_client_handle_, 1, 3, true)) {
|
||
ESP_LOGE(TAG, "Failed to set sensor");
|
||
sscma_client_del(sscma_client_handle_);
|
||
sscma_client_handle_ = NULL;
|
||
return;
|
||
}
|
||
|
||
// 获取设备信息
|
||
sscma_client_info_t *info;
|
||
if (sscma_client_get_info(sscma_client_handle_, &info, true) == ESP_OK) {
|
||
ESP_LOGI(TAG, "Device Info - ID: %s, Name: %s",
|
||
info->id ? info->id : "NULL",
|
||
info->name ? info->name : "NULL");
|
||
}
|
||
// 初始化JPEG数据的内存
|
||
jpeg_data_.len = 0;
|
||
jpeg_data_.buf = (uint8_t*)heap_caps_malloc(IMG_JPEG_BUF_SIZE, MALLOC_CAP_SPIRAM);;
|
||
if ( jpeg_data_.buf == nullptr ) {
|
||
ESP_LOGE(TAG, "Failed to allocate memory for JPEG buffer");
|
||
return;
|
||
}
|
||
|
||
//初始化JPEG解码
|
||
jpeg_error_t err;
|
||
jpeg_dec_config_t config = { .output_type = JPEG_PIXEL_FORMAT_RGB565_LE, .rotate = JPEG_ROTATE_0D };
|
||
err = jpeg_dec_open(&config, &jpeg_dec_);
|
||
if ( err != JPEG_ERR_OK ) {
|
||
ESP_LOGE(TAG, "Failed to open JPEG decoder");
|
||
return;
|
||
}
|
||
jpeg_io_ = (jpeg_dec_io_t*)heap_caps_malloc(sizeof(jpeg_dec_io_t), MALLOC_CAP_SPIRAM);
|
||
if (!jpeg_io_) {
|
||
ESP_LOGE(TAG, "Failed to allocate memory for JPEG IO");
|
||
jpeg_dec_close(jpeg_dec_);
|
||
return;
|
||
}
|
||
memset(jpeg_io_, 0, sizeof(jpeg_dec_io_t));
|
||
|
||
jpeg_out_ = (jpeg_dec_header_info_t*)heap_caps_aligned_alloc(16, sizeof(jpeg_dec_header_info_t), MALLOC_CAP_SPIRAM);
|
||
if (!jpeg_out_) {
|
||
ESP_LOGE(TAG, "Failed to allocate memory for JPEG output header");
|
||
heap_caps_free(jpeg_io_);
|
||
jpeg_dec_close(jpeg_dec_);
|
||
return;
|
||
}
|
||
memset(jpeg_out_, 0, sizeof(jpeg_dec_header_info_t));
|
||
|
||
// 初始化预览图片的内存
|
||
memset(&preview_image_, 0, sizeof(preview_image_));
|
||
preview_image_.header.magic = LV_IMAGE_HEADER_MAGIC;
|
||
preview_image_.header.cf = LV_COLOR_FORMAT_RGB565;
|
||
preview_image_.header.flags = LV_IMAGE_FLAGS_ALLOCATED | LV_IMAGE_FLAGS_MODIFIABLE;
|
||
preview_image_.header.w = 640;
|
||
preview_image_.header.h = 480;
|
||
|
||
preview_image_.header.stride = preview_image_.header.w * 2;
|
||
preview_image_.data_size = preview_image_.header.w * preview_image_.header.h * 2;
|
||
preview_image_.data = (uint8_t*)heap_caps_malloc(preview_image_.data_size, MALLOC_CAP_SPIRAM);
|
||
if (preview_image_.data == nullptr) {
|
||
ESP_LOGE(TAG, "Failed to allocate memory for preview image");
|
||
return;
|
||
}
|
||
}
|
||
|
||
SscmaCamera::~SscmaCamera() {
|
||
if (preview_image_.data) {
|
||
heap_caps_free((void*)preview_image_.data);
|
||
preview_image_.data = nullptr;
|
||
}
|
||
if (sscma_client_handle_) {
|
||
sscma_client_del(sscma_client_handle_);
|
||
}
|
||
if (sscma_data_queue_) {
|
||
vQueueDelete(sscma_data_queue_);
|
||
}
|
||
if (jpeg_data_.buf) {
|
||
heap_caps_free(jpeg_data_.buf);
|
||
jpeg_data_.buf = nullptr;
|
||
}
|
||
if (jpeg_dec_) {
|
||
jpeg_dec_close(jpeg_dec_);
|
||
jpeg_dec_ = nullptr;
|
||
}
|
||
if (jpeg_io_) {
|
||
heap_caps_free(jpeg_io_);
|
||
jpeg_io_ = nullptr;
|
||
}
|
||
if (jpeg_out_) {
|
||
heap_caps_free(jpeg_out_);
|
||
jpeg_out_ = nullptr;
|
||
}
|
||
}
|
||
|
||
void SscmaCamera::SetExplainUrl(const std::string& url, const std::string& token) {
|
||
explain_url_ = url;
|
||
explain_token_ = token;
|
||
}
|
||
|
||
bool SscmaCamera::Capture() {
|
||
|
||
SscmaData data;
|
||
int ret = 0;
|
||
|
||
if (sscma_client_handle_ == nullptr) {
|
||
ESP_LOGE(TAG, "SSCMA client handle is not initialized");
|
||
return false;
|
||
}
|
||
|
||
ESP_LOGI(TAG, "Capturing image...");
|
||
|
||
// himax 有缓存数据,需要拍两张照片, 只获取最新的照片即可.
|
||
if (sscma_client_sample(sscma_client_handle_, 2) ) {
|
||
ESP_LOGE(TAG, "Failed to capture image from SSCMA client");
|
||
return false;
|
||
}
|
||
vTaskDelay(pdMS_TO_TICKS(500)); // 等待SSCMA客户端处理数据
|
||
if (xQueueReceive(sscma_data_queue_, &data, pdMS_TO_TICKS(1000)) != pdPASS) {
|
||
ESP_LOGE(TAG, "Failed to receive JPEG data from SSCMA client");
|
||
return false;
|
||
}
|
||
|
||
if (jpeg_data_.buf == nullptr) {
|
||
heap_caps_free(data.img);
|
||
return false;
|
||
}
|
||
|
||
ret = mbedtls_base64_decode(jpeg_data_.buf, IMG_JPEG_BUF_SIZE, &jpeg_data_.len, data.img, data.len);
|
||
if (ret != 0 || jpeg_data_.len == 0) {
|
||
ESP_LOGE(TAG, "Failed to decode base64 image data, ret: %d, output_len: %zu", ret, jpeg_data_.len);
|
||
heap_caps_free(data.img);
|
||
return false;
|
||
}
|
||
heap_caps_free(data.img);
|
||
|
||
//DECODE JPEG
|
||
if (!jpeg_dec_ || !jpeg_io_ || !jpeg_out_ || !preview_image_.data) {
|
||
return true;
|
||
}
|
||
jpeg_io_->inbuf = jpeg_data_.buf;
|
||
jpeg_io_->inbuf_len = jpeg_data_.len;
|
||
ret = jpeg_dec_parse_header(jpeg_dec_, jpeg_io_, jpeg_out_);
|
||
if (ret < 0) {
|
||
ESP_LOGE(TAG, "Failed to parse JPEG header, ret: %d", ret);
|
||
return true;
|
||
}
|
||
jpeg_io_->outbuf = (unsigned char*)preview_image_.data;
|
||
int inbuf_consumed = jpeg_io_->inbuf_len - jpeg_io_->inbuf_remain;
|
||
jpeg_io_->inbuf = jpeg_data_.buf + inbuf_consumed;
|
||
jpeg_io_->inbuf_len = jpeg_io_->inbuf_remain;
|
||
|
||
ret = jpeg_dec_process(jpeg_dec_, jpeg_io_);
|
||
if (ret != ESP_OK) {
|
||
ESP_LOGE(TAG, "Failed to decode JPEG image, ret: %d", ret);
|
||
return true;
|
||
}
|
||
|
||
// 显示预览图片
|
||
auto display = Board::GetInstance().GetDisplay();
|
||
if (display != nullptr) {
|
||
display->SetPreviewImage(&preview_image_);
|
||
}
|
||
return true;
|
||
}
|
||
bool SscmaCamera::SetHMirror(bool enabled) {
|
||
return false;
|
||
}
|
||
|
||
bool SscmaCamera::SetVFlip(bool enabled) {
|
||
return false;
|
||
}
|
||
|
||
/**
|
||
* @brief 将摄像头捕获的图像发送到远程服务器进行AI分析和解释
|
||
*
|
||
* 该函数将当前摄像头缓冲区中的图像编码为JPEG格式，并通过HTTP POST请求
|
||
* 以multipart/form-data的形式发送到指定的解释服务器。服务器将根据提供的
|
||
* 问题对图像进行AI分析并返回结果。
|
||
*
|
||
* @param question 要向AI提出的关于图像的问题，将作为表单字段发送
|
||
* @return std::string 服务器返回的JSON格式响应字符串
|
||
* 成功时包含AI分析结果，失败时包含错误信息
|
||
* 格式示例：{"success": true, "result": "分析结果"}
|
||
* {"success": false, "message": "错误信息"}
|
||
*
|
||
* @note 调用此函数前必须先调用SetExplainUrl()设置服务器URL
|
||
* @note 函数会等待之前的编码线程完成后再开始新的处理
|
||
* @warning 如果摄像头缓冲区为空或网络连接失败，将返回错误信息
|
||
*/
|
||
std::string SscmaCamera::Explain(const std::string& question) {
|
||
if (explain_url_.empty()) {
|
||
return "{\"success\": false, \"message\": \"Image explain URL or token is not set\"}";
|
||
}
|
||
|
||
auto network = Board::GetInstance().GetNetwork();
|
||
auto http = network->CreateHttp(3);
|
||
// 构造multipart/form-data请求体
|
||
std::string boundary = "----ESP32_CAMERA_BOUNDARY";
|
||
|
||
// 构造question字段
|
||
std::string question_field;
|
||
question_field += "--" + boundary + "\r\n";
|
||
question_field += "Content-Disposition: form-data; name=\"question\"\r\n";
|
||
question_field += "\r\n";
|
||
question_field += question + "\r\n";
|
||
|
||
// 构造文件字段头部
|
||
std::string file_header;
|
||
file_header += "--" + boundary + "\r\n";
|
||
file_header += "Content-Disposition: form-data; name=\"file\"; filename=\"camera.jpg\"\r\n";
|
||
file_header += "Content-Type: image/jpeg\r\n";
|
||
file_header += "\r\n";
|
||
|
||
// 构造尾部
|
||
std::string multipart_footer;
|
||
multipart_footer += "\r\n--" + boundary + "--\r\n";
|
||
|
||
// 配置HTTP客户端，使用分块传输编码
|
||
http->SetHeader("Device-Id", SystemInfo::GetMacAddress().c_str());
|
||
http->SetHeader("Client-Id", Board::GetInstance().GetUuid().c_str());
|
||
if (!explain_token_.empty()) {
|
||
http->SetHeader("Authorization", "Bearer " + explain_token_);
|
||
}
|
||
http->SetHeader("Content-Type", "multipart/form-data; boundary=" + boundary);
|
||
http->SetHeader("Transfer-Encoding", "chunked");
|
||
if (!http->Open("POST", explain_url_)) {
|
||
ESP_LOGE(TAG, "Failed to connect to explain URL");
|
||
return "{\"success\": false, \"message\": \"Failed to connect to explain URL\"}";
|
||
}
|
||
|
||
// 第一块：question字段
|
||
http->Write(question_field.c_str(), question_field.size());
|
||
|
||
// 第二块：文件字段头部
|
||
http->Write(file_header.c_str(), file_header.size());
|
||
|
||
// 第三块：JPEG数据
|
||
http->Write((const char*)jpeg_data_.buf, jpeg_data_.len);
|
||
|
||
// 第四块：multipart尾部
|
||
http->Write(multipart_footer.c_str(), multipart_footer.size());
|
||
|
||
// 结束块
|
||
http->Write("", 0);
|
||
|
||
if (http->GetStatusCode() != 200) {
|
||
ESP_LOGE(TAG, "Failed to upload photo, status code: %d", http->GetStatusCode());
|
||
return "{\"success\": false, \"message\": \"Failed to upload photo\"}";
|
||
}
|
||
|
||
std::string result = http->ReadAll();
|
||
http->Close();
|
||
|
||
ESP_LOGI(TAG, "Explain image size=%d, question=%s\n%s", jpeg_data_.len, question.c_str(), result.c_str());
|
||
return result;
|
||
}
|