改写ESP32CAM官方例程，创建httpserver任务实现网页视频播放

改写ESP32CAM官方例程，将官方例程中的startCameraServer()，替换为自己写的http_test_task。在浏览器中输入esp32地址就可以播放视频。

废话不多说，直接上程序。

#include “esp_camera.h”
#include <WiFi.h>

#include “esp_http_client.h” //m add
#include “esp_http_server.h” //m add
#include “http_server.h” //m add
//
// WARNING!!! PSRAM IC required for UXGA resolution and high JPEG quality
// Ensure ESP32 Wrover Module or other board with PSRAM is selected
// Partial images will be transmitted if image exceeds buffer size
//

// Select camera model
//#define CAMERA_MODEL_WROVER_KIT // Has PSRAM
//#define CAMERA_MODEL_ESP_EYE // Has PSRAM
//#define CAMERA_MODEL_M5STACK_PSRAM // Has PSRAM
//#define CAMERA_MODEL_M5STACK_V2_PSRAM // M5Camera version B Has PSRAM
//#define CAMERA_MODEL_M5STACK_WIDE // Has PSRAM
//#define CAMERA_MODEL_M5STACK_ESP32CAM // No PSRAM
#define CAMERA_MODEL_AI_THINKER // Has PSRAM
//#define CAMERA_MODEL_TTGO_T_JOURNAL // No PSRAM

#include “camera_pins.h”

const char* ssid = “michael”;
const char* password = “123456789”;

String transEncryptionType(wifi_auth_mode_t encryptionType){ //对比出该wifi网络加密类型并返回相应的String值
switch(encryptionType){
case (WIFI_AUTH_OPEN):
return “Open”;
case (WIFI_AUTH_WEP):
return “WEP”;
case (WIFI_AUTH_WPA_PSK):
return “WPA_PSK”;
case (WIFI_AUTH_WPA2_PSK):
return “WPA2_PSK”;
case (WIFI_AUTH_WPA_WPA2_PSK):
return “WPA_WPA2_PSK”;
case (WIFI_AUTH_WPA2_ENTERPRISE):
return “WPA2_ENTERPRISE”;
default:
return(“Unkonwn EncryptionType”);
}
}

void scanNetworks(){ //扫描周边wifi网络，并显示wifi数量，打印它们的属性（ssid，信号强度，加密方式，mac地址）
int numberOfNetworks= WiFi.scanNetworks();
Serial.print(“The number of networks found is:”);
Serial.println(numberOfNetworks);
for(int i=0;i<numberOfNetworks;i++){
Serial.print("Networkname: ");
Serial.println(WiFi.SSID(i));
Serial.print("Signalstrength: ");
Serial.println(WiFi.RSSI(i));
Serial.print("MACaddress: ");
Serial.println(WiFi.BSSIDstr(i));
Serial.print(“Encryptiontype: “);
String encryptionTypeDescription = transEncryptionType(WiFi.encryptionType(i));
Serial.println(encryptionTypeDescription);
Serial.println(”-----------------------”);
}
}

#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\n\r\n”;

esp_err_t http_get_handler(httpd_req_t *req)
{

//获取芯片可用内存
printf("esp_get_free_heap_size : %d  \n", esp_get_free_heap_size());

camera_fb_t *fb = NULL;
esp_err_t res = ESP_OK;
size_t _jpg_buf_len;
uint8_t *_jpg_buf;
char *part_buf[64];
static int64_t last_frame = 0;
if (!last_frame)
{
    last_frame = esp_timer_get_time();
}

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

while (true)
{
    fb = esp_camera_fb_get();
    if (!fb)
    {
        ESP_LOGE(TAG, "Camera capture failed");
        res = ESP_FAIL;
        break;
    }
    if (fb->format != PIXFORMAT_JPEG)
    {
        bool jpeg_converted = frame2jpg(fb, 80, &_jpg_buf, &_jpg_buf_len);
        if (!jpeg_converted)
        {
            ESP_LOGE(TAG, "JPEG compression failed");
            esp_camera_fb_return(fb);
            res = ESP_FAIL;
        }
    }
    else
    {
        _jpg_buf_len = fb->len;
        _jpg_buf = fb->buf;
    }

    if (res == ESP_OK)
    {
        res = httpd_resp_send_chunk(req, _STREAM_BOUNDARY, strlen(_STREAM_BOUNDARY));
    }
    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 (fb->format != PIXFORMAT_JPEG)
    {
        free(_jpg_buf);
    }
    esp_camera_fb_return(fb);
    if (res != ESP_OK)
    {
        break;
    }
    int64_t fr_end = esp_timer_get_time();
    int64_t frame_time = fr_end - last_frame;
    last_frame = fr_end;
    frame_time /= 1000;
    ESP_LOGI(TAG, "MJPG: %uKB %ums (%.1ffps)",
             (uint32_t)(_jpg_buf_len / 1024),
             (uint32_t)frame_time, 1000.0 / (uint32_t)frame_time);
}

last_frame = 0;
return res;

}

httpd_uri_t stream = {
.uri = “/stream”,
.method = HTTP_GET,
.handler = http_get_handler,
/* Let’s pass response string in user
* context to demonstrate it’s usage */
.user_ctx = NULL}; //m change from “stream!” to NULL

static void http_test_task(void *pvParameters)
{

ESP_LOGI(TAG, "Http Start");

httpd_handle_t server = NULL;
httpd_config_t config = HTTPD_DEFAULT_CONFIG();

// Start the httpd server
ESP_LOGI(TAG, "Starting server on port: '%d'", config.server_port);
if (httpd_start(&server, &config) == ESP_OK)
{
    // Set URI handlers
    ESP_LOGI(TAG, "Registering URI handlers");
    httpd_register_uri_handler(server, &stream);
}
else
{
    ESP_LOGI(TAG, "Error starting server!");
}

ESP_LOGI(TAG, "Http End");

vTaskDelete(NULL);

}

void setup() {
// put your setup code here, to run once:
Serial.begin(115200);
Serial.setDebugOutput(true);
Serial.println();

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_sscb_sda = SIOD_GPIO_NUM;
config.pin_sscb_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_JPEG;

// if PSRAM IC present, init with UXGA resolution and higher JPEG quality
// for larger pre-allocated frame buffer.
if(psramFound()){
config.frame_size = FRAMESIZE_UXGA;
config.jpeg_quality = 10;
config.fb_count = 2;
} else {
config.frame_size = FRAMESIZE_SVGA;
config.jpeg_quality = 12;
config.fb_count = 1;
}

#if defined(CAMERA_MODEL_ESP_EYE)
pinMode(13, INPUT_PULLUP);
pinMode(14, INPUT_PULLUP);
#endif

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

sensor_t * s = esp_camera_sensor_get();
// initial sensors are flipped vertically and colors are a bit saturated
if (s->id.PID == OV3660_PID) {
s->set_vflip(s, 1); // flip it back
s->set_brightness(s, 1); // up the brightness just a bit
s->set_saturation(s, -2); // lower the saturation
}
// drop down frame size for higher initial frame rate
s->set_framesize(s, FRAMESIZE_QVGA);

#if defined(CAMERA_MODEL_M5STACK_WIDE) || defined(CAMERA_MODEL_M5STACK_ESP32CAM)
s->set_vflip(s, 1);
s->set_hmirror(s, 1);
#endif

scanNetworks(); //扫描wifi并打印信息

WiFi.begin(ssid, password);

while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(“.”);
}
Serial.println(“”);
Serial.println(“WiFi connected”);

Serial.println(WiFi.macAddress()); //打印esp32的mac地址
Serial.println(WiFi.localIP()); //esp32此刻的本地ip地址
// startCameraServer(); //m不使用例程的camera server，自己替换为http_test_task

// Serial.print(“Camera Ready! Use 'http://”);
Serial.print(WiFi.localIP());
Serial.println(“’ to connect”);
//开始拍照上传
xTaskCreate(&http_test_task, “http_test_task”, 8192, NULL, 5, NULL);
}

void loop() {
// put your main code here, to run repeatedly:

}