UVC driver not working for OV2640 sensor on Xiao Seeed Studio ESP32s3 board

[reecewayt]

Hi all, I'm curious if anyone in the community or developers has had any luck working with the UVC Device API. I've followed the exact example found in the IoT directory for the USB WebCam. My application I've written from the examples builds and flashes without error or warnings. Still, when I try to connect the USB WebCam to my computer, it recognizes the device as UVC but I can't get video out of it. It's just a black image. Below is my source code.

/** 
 * @file main.c
 * @brief USB Web Camera Application using ESP32-S3 and OV2640 Camera Module
 * 
 * Sources: 
 *   https://github.com/espressif/esp-iot-solution/blob/master/examples/usb/device/usb_webcam/main/usb_webcam_main.c
 */
#include <stdlib.h>
#include <string.h>
#include <inttypes.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_timer.h"
#include "esp_log.h"
#include "camera_pin.h"
#include "esp_camera.h"
#include "usb_device_uvc.h"
#include "uvc_frame_config.h"

static const char *TAG = "usb_webcam: ";

#define CAMERA_XCLK_FREQ           16000000     // Set to 16MHz for OV2640 camera module
#define CAMERA_FB_COUNT            2
#if CONFIG_IDF_TARGET_ESP32S3
    #define UVC_MAX_FRAMESIZE_SIZE     (75*1024) //Maximum frame size for ESP32-S3 is 75KB
#else
    #error "Please define UVC_MAX_FRAMESIZE_SIZE for your chip"
#endif

typedef struct {
    camera_fb_t *cam_fb_p;  // Pointer to camera frame buffer
    uvc_fb_t uvc_fb;        // UVC frame buffer
} fb_t;

static fb_t s_fb;           // Static frame buffer for both uvc and camera sensor

static esp_err_t camera_init()
{
    static bool inited = false;
    if (inited) {
        ESP_LOGW(TAG, "Camera already initialized");
        return ESP_OK;
    }

    camera_config_t camera_config = {
        .pin_pwdn = PWDN_GPIO_NUM,
        .pin_reset = RESET_GPIO_NUM,
        .pin_xclk = CAM_PIN_XCLK,
        .pin_sscb_sda = CAM_PIN_SIOD,
        .pin_sscb_scl = CAM_PIN_SIOC,

        .pin_d0 = CAM_PIN_D0,
        .pin_d1 = CAM_PIN_D1,
        .pin_d2 = CAM_PIN_D2,
        .pin_d3 = CAM_PIN_D3,
        .pin_d4 = CAM_PIN_D4,
        .pin_d5 = CAM_PIN_D5,
        .pin_d6 = CAM_PIN_D6,
        .pin_d7 = CAM_PIN_D7,
        
        .xclk_freq_hz = CAMERA_XCLK_FREQ,

        
        .frame_size = FRAMESIZE_SVGA,
        .pixel_format = PIXFORMAT_JPEG,         // for streaming
        .jpeg_quality = 12,  
        .fb_count = 2,                          // Needs to be 2 for uvc driver
        .grab_mode = CAMERA_GRAB_WHEN_EMPTY,     // quality of JPEG output. 0-63 lower means higher quality 
        .fb_location = CAMERA_FB_IN_PSRAM                     
    };

    // initialize the camera sensor
    esp_err_t ret = esp_camera_init(&camera_config);
    if (ret != ESP_OK) {
        return ret;
    }
    inited = true; 

    ESP_LOGI(TAG, "Camera initialized");
    return ret;
} 


// De-initialize the camera driver
static void camera_stop_cb(void *cb_ctx){
    (void)cb_ctx;
    ESP_LOGI(TAG, "Camera stopped");
}

static esp_err_t camera_start_cb(uvc_format_t format, int width, int height, int rate, void *cb_ctx){
    (void)cb_ctx; 
    ESP_LOGI(TAG, "Initializing Camera...");

    esp_err_t ret = camera_init();
    if (ret != ESP_OK) {
        ESP_LOGE(TAG, "Failed to initialize camera");
        return ret;
    }

    return ESP_OK;

}

static uvc_fb_t* camera_fb_get_cb(void *cb_ctx){
    (void)cb_ctx;
    s_fb.cam_fb_p = esp_camera_fb_get();
    if (!s_fb.cam_fb_p) {
        ESP_LOGE(TAG, "Camera capture failed");
        return NULL;
    }
    //Captures frame buffer from camera and transfer to UVC frame buffer to send to host
    s_fb.uvc_fb.buf = s_fb.cam_fb_p->buf;
    s_fb.uvc_fb.len = s_fb.cam_fb_p->len;
    s_fb.uvc_fb.width = s_fb.cam_fb_p->width;
    s_fb.uvc_fb.height = s_fb.cam_fb_p->height;
    s_fb.uvc_fb.format = s_fb.cam_fb_p->format;
    s_fb.uvc_fb.timestamp = s_fb.cam_fb_p->timestamp;

    if(s_fb.uvc_fb.len > UVC_MAX_FRAMESIZE_SIZE){
        ESP_LOGE(TAG, "Frame size is too large");
        return NULL;
    }
    return &s_fb.uvc_fb; // returns buffer to application to send to host
}

static void camera_fb_return_cb(uvc_fb_t *fb, void *cb_ctx){
    (void)cb_ctx;
    assert(fb == &s_fb.uvc_fb);
    esp_camera_fb_return(s_fb.cam_fb_p); // return frame buffer to camera for next capture
}

void app_main(void)
{
    ESP_LOGI(TAG, "Starting camera application...");
    ESP_LOGI(TAG, "Selected Camera Board %s", CONFIG_CAMERA_MODULE_NAME);
    uint8_t *uvc_buffer = (uint8_t *)malloc(UVC_MAX_FRAMESIZE_SIZE);

    if (uvc_buffer == NULL) {
        ESP_LOGE(TAG, "Failed to malloc UVC buffer");
        return;
    }

    uvc_device_config_t config = {
        .uvc_buffer = uvc_buffer,
        .uvc_buffer_size = UVC_MAX_FRAMESIZE_SIZE,
        .start_cb = camera_start_cb,
        .fb_get_cb = camera_fb_get_cb,
        .fb_return_cb = camera_fb_return_cb,
        .stop_cb = camera_stop_cb,
    };

    ESP_LOGI(TAG, "Format List");
    ESP_LOGI(TAG, "\tFormat(1) = %s", "JPEG");
    ESP_LOGI(TAG, "Frame List");
    ESP_LOGI(TAG, "\tFrame(1) = %d * %d @%dfps", UVC_FRAMES_INFO[0][0].width, UVC_FRAMES_INFO[0][0].height, UVC_FRAMES_INFO[0][0].rate);

    ESP_ERROR_CHECK(uvc_device_config(0, &config));
    ESP_ERROR_CHECK(uvc_device_init());

    // main app loop
    while(1){
        vTaskDelay(pdMS_TO_TICKS(100));
        ESP_LOGI(TAG, "Main loop...");
    }
}

/*
 * @file camera_pin.h
*/


#pragma once
#include "sdkconfig.h"


#ifdef CONFIG_CAMERA_BOARD_XIAO_SENSE // This is the board we are using, add other targets if needed
    #define BOARD_XIAO_SENSE
    #define PWDN_GPIO_NUM       -1
    #define RESET_GPIO_NUM      -1
    #define CAM_PIN_XCLK         10
    #define CAM_PIN_SIOD        40
    #define CAM_PIN_SIOC        39
    #define CAM_PIN_D7          48     
    #define CAM_PIN_D6          11
    #define CAM_PIN_D5          12
    #define CAM_PIN_D4          14
    #define CAM_PIN_D3          16
    #define CAM_PIN_D2          18
    #define CAM_PIN_D1          17
    #define CAM_PIN_D0          15
    #define CAM_PIN_VSYNC       38
    #define CAM_PIN_HREF        47
    #define CAM_PIN_PCLK        13
    #define CAM_XCLK_FREQ       16000000        // 16MHz
    
#endif  // BOARD_XIAO_SENSE

#ifndef CONFIG_CAMERA_BOARD_XIAO_SENSE
    #error "Board is either not defined or not supported, see sdkconfig.h and Kconfig.projbuild files"
#endif

[lijunru-hub]

Please set the log level to debug and provide the relevant log output.