ESP32-S3搭建外网可访问的网络摄像头（内网穿透）

// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "esp_http_server.h" #include "esp_timer.h" #include "esp_camera.h" #include "img_converters.h" #include "fb_gfx.h" #include "esp32-hal-ledc.h" #include "sdkconfig.h" #include "camera_index.h" #if defined(ARDUINO_ARCH_ESP32) && defined(CONFIG_ARDUHAL_ESP_LOG) #include "esp32-hal-log.h" #endif // Face Detection will not work on boards without (or with disabled) PSRAM #ifdef BOARD_HAS_PSRAM #define CONFIG_ESP_FACE_DETECT_ENABLED 1 // Face Recognition takes upward from 15 seconds per frame on chips other than ESP32S3 // Makes no sense to have it enabled for them #if CONFIG_IDF_TARGET_ESP32S3 #define CONFIG_ESP_FACE_RECOGNITION_ENABLED 1 #else #define CONFIG_ESP_FACE_RECOGNITION_ENABLED 0 #endif #else #define CONFIG_ESP_FACE_DETECT_ENABLED 0 #define CONFIG_ESP_FACE_RECOGNITION_ENABLED 0 #endif #if CONFIG_ESP_FACE_DETECT_ENABLED #include <vector> #include "human_face_detect_msr01.hpp" #include "human_face_detect_mnp01.hpp" #define TWO_STAGE 1 /*<! 1: detect by two-stage which is more accurate but slower(with keypoints). */ /*<! 0: detect by one-stage which is less accurate but faster(without keypoints). */ #if CONFIG_ESP_FACE_RECOGNITION_ENABLED #include "face_recognition_tool.hpp" #include "face_recognition_112_v1_s16.hpp" #include "face_recognition_112_v1_s8.hpp" #define QUANT_TYPE 0 //if set to 1 => very large firmware, very slow, reboots when streaming... #define FACE_ID_SAVE_NUMBER 7 #endif #define FACE_COLOR_WHITE 0x00FFFFFF #define FACE_COLOR_BLACK 0x00000000 #define FACE_COLOR_RED 0x000000FF #define FACE_COLOR_GREEN 0x0000FF00 #define FACE_COLOR_BLUE 0x00FF0000 #define FACE_COLOR_YELLOW (FACE_COLOR_RED | FACE_COLOR_GREEN) #define FACE_COLOR_CYAN (FACE_COLOR_BLUE | FACE_COLOR_GREEN) #define FACE_COLOR_PURPLE (FACE_COLOR_BLUE | FACE_COLOR_RED) #endif // Enable LED FLASH setting #define CONFIG_LED_ILLUMINATOR_ENABLED 1 // LED FLASH setup #if CONFIG_LED_ILLUMINATOR_ENABLED #define LED_LEDC_CHANNEL 2 //Using different ledc channel/timer than camera #define CONFIG_LED_MAX_INTENSITY 255 int led_duty = 0; bool isStreaming = false; #endif typedef struct { httpd_req_t *req; size_t len; } jpg_chunking_t; #define PART_BOUNDARY "123456789000000000000987654321" 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\nX-Timestamp: %d.%06d\r\n\r\n"; httpd_handle_t stream_httpd = NULL; httpd_handle_t camera_httpd = NULL; #if CONFIG_ESP_FACE_DETECT_ENABLED static int8_t detection_enabled = 0; // #if TWO_STAGE // static HumanFaceDetectMSR01 s1(0.1F, 0.5F, 10, 0.2F); // static HumanFaceDetectMNP01 s2(0.5F, 0.3F, 5); // #else // static HumanFaceDetectMSR01 s1(0.3F, 0.5F, 10, 0.2F); // #endif #if CONFIG_ESP_FACE_RECOGNITION_ENABLED static int8_t recognition_enabled = 0; static int8_t is_enrolling = 0; #if QUANT_TYPE // S16 model FaceRecognition112V1S16 recognizer; #else // S8 model FaceRecognition112V1S8 recognizer; #endif #endif #endif typedef struct { size_t size; //number of values used for filtering size_t index; //current value index size_t count; //value count int sum; int *values; //array to be filled with values } ra_filter_t; static ra_filter_t ra_filter; static ra_filter_t *ra_filter_init(ra_filter_t *filter, size_t sample_size) { memset(filter, 0, sizeof(ra_filter_t)); filter->values = (int *)malloc(sample_size * sizeof(int)); if (!filter->values) { return NULL; } memset(filter->values, 0, sample_size * sizeof(int)); filter->size = sample_size; return filter; } #if ARDUHAL_LOG_LEVEL >= ARDUHAL_LOG_LEVEL_INFO static int ra_filter_run(ra_filter_t *filter, int value) { if (!filter->values) { return value; } filter->sum -= filter->values[filter->index]; filter->values[filter->index] = value; filter->sum += filter->values[filter->index]; filter->index++; filter->index = filter->index % filter->size; if (filter->count < filter->size) { filter->count++; } return filter->sum / filter->count; } #endif #if CONFIG_ESP_FACE_DETECT_ENABLED #if CONFIG_ESP_FACE_RECOGNITION_ENABLED static void rgb_print(fb_data_t *fb, uint32_t color, const char *str) { fb_gfx_print(fb, (fb->width - (strlen(str) * 14)) / 2, 10, color, str); } static int rgb_printf(fb_data_t *fb, uint32_t color, const char *format, ...) { char loc_buf[64]; char *temp = loc_buf; int len; va_list arg; va_list copy; va_start(arg, format); va_copy(copy, arg); len = vsnprintf(loc_buf, sizeof(loc_buf), format, arg); va_end(copy); if (len >= sizeof(loc_buf)) { temp = (char *)malloc(len + 1); if (temp == NULL) { return 0; } } vsnprintf(temp, len + 1, format, arg); va_end(arg); rgb_print(fb, color, temp); if (len > 64) { free(temp); } return len; } #endif static void draw_face_boxes(fb_data_t *fb, std::list<dl::detect::result_t> *results, int face_id) { int x, y, w, h; uint32_t color = FACE_COLOR_YELLOW; if (face_id < 0) { color = FACE_COLOR_RED; } else if (face_id > 0) { color = FACE_COLOR_GREEN; } if(fb->bytes_per_pixel == 2){ //color = ((color >> 8) & 0xF800) | ((color >> 3) & 0x07E0) | (color & 0x001F); color = ((color >> 16) & 0x001F) | ((color >> 3) & 0x07E0) | ((color << 8) & 0xF800); } int i = 0; for (std::list<dl::detect::result_t>::iterator prediction = results->begin(); prediction != results->end(); prediction++, i++) { // rectangle box x = (int)prediction->box[0]; y = (int)prediction->box[1]; w = (int)prediction->box[2] - x + 1; h = (int)prediction->box[3] - y + 1; if((x + w) > fb->width){ w = fb->width - x; } if((y + h) > fb->height){ h = fb->height - y; } fb_gfx_drawFastHLine(fb, x, y, w, color); fb_gfx_drawFastHLine(fb, x, y + h - 1, w, color); fb_gfx_drawFastVLine(fb, x, y, h, color); fb_gfx_drawFastVLine(fb, x + w - 1, y, h, color); #if TWO_STAGE // landmarks (left eye, mouth left, nose, right eye, mouth right) int x0, y0, j; for (j = 0; j < 10; j+=2) { x0 = (int)prediction->keypoint[j]; y0 = (int)prediction->keypoint[j+1]; fb_gfx_fillRect(fb, x0, y0, 3, 3, color); } #endif } } #if CONFIG_ESP_FACE_RECOGNITION_ENABLED static int run_face_recognition(fb_data_t *fb, std::list<dl::detect::result_t> *results) { std::vector<int> landmarks = results->front().keypoint; int id = -1; Tensor<uint8_t> tensor; tensor.set_element((uint8_t *)fb->data).set_shape({fb->height, fb->width, 3}).set_auto_free(false); int enrolled_count = recognizer.get_enrolled_id_num(); if (enrolled_count < FACE_ID_SAVE_NUMBER && is_enrolling){ id = recognizer.enroll_id(tensor, landmarks, "", true); log_i("Enrolled ID: %d", id); rgb_printf(fb, FACE_COLOR_CYAN, "ID[%u]", id); } face_info_t recognize = recognizer.recognize(tensor, landmarks); if(recognize.id >= 0){