zouhaitao/TAIXIN
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
main
TAIXIN/sdk/lib/bus/rttusb/usbdevice/class/usbd_video.c

2272 lines
110 KiB
C
Raw Permalink Normal View History

Initial commit: TXW82x FPV v2.7.0.7-42229 SDK + project sources
2026-07-06 11:30:13 +08:00
/*
* Copyright (c) 2022, sakumisu
*
* SPDX-License-Identifier: Apache-2.0
*/
#include <rtthread.h>
#ifdef RT_USB_DEVICE_VIDEO
#include "include/rttusb_device.h"
#include "usbd_video.h"
#include "stream_define.h"
#include "video_app_h264_msi.h"
#include "jpg_concat_msi.h"
#define CONFIG_USB_HS //默认设置为USB HS模式
#ifdef CONFIG_USB_HS
#define MAX_PAYLOAD_SIZE 1024 // for high speed with one transcations every one micro frame
#define VIDEO_PACKET_SIZE (unsigned int)(((MAX_PAYLOAD_SIZE / 1)) | (0x00 << 11))
// #define MAX_PAYLOAD_SIZE 2048 // for high speed with two transcations every one micro frame
// #define VIDEO_PACKET_SIZE (unsigned int)(((MAX_PAYLOAD_SIZE / 2)) | (0x01 << 11))
// #define MAX_PAYLOAD_SIZE 3072 // for high speed with three transcations every one micro frame
// #define VIDEO_PACKET_SIZE (unsigned int)(((MAX_PAYLOAD_SIZE / 3)) | (0x02 << 11))
#else
#define MAX_PAYLOAD_SIZE 1020
#define VIDEO_PACKET_SIZE (unsigned int)(((MAX_PAYLOAD_SIZE / 1)) | (0x00 << 11))
#endif
#define VIDEO_IN_EP 0x81
/* --------- Video MJPEG Format --------- */
#define VIDEO_MJPEG_bNumFrameDescriptors (2)
#if VIDEO_MJPEG_bNumFrameDescriptors >= 1
#define VIDEO_MJPEG_Frame1_WIDTH (unsigned int)(640)
#define VIDEO_MJPEG_Frame1_HEIGHT (unsigned int)(360)
#endif
#if VIDEO_MJPEG_bNumFrameDescriptors >= 2
#define VIDEO_MJPEG_Frame2_WIDTH (unsigned int)(1280)
#define VIDEO_MJPEG_Frame2_HEIGHT (unsigned int)(720)
#endif
/* --------- Video H26x Format --------- */
#define VIDEO_H26x__bNumFrameDescriptors (2)
#if VIDEO_H26x__bNumFrameDescriptors >= 1
#define VIDEO_H26x_Frame1_WIDTH (unsigned int)(1280)
#define VIDEO_H26x_Frame1_HEIGHT (unsigned int)(720)
#endif
#if VIDEO_H26x__bNumFrameDescriptors >= 2
#define VIDEO_H26x_Frame2_WIDTH (unsigned int)(1920)
#define VIDEO_H26x_Frame2_HEIGHT (unsigned int)(1080)
#endif
#define CAM_FPS (30)
#define INTERVAL (unsigned long)(10000000 / CAM_FPS)
#define MIN_BIT_RATE(width, height) (unsigned long)(width * height * 16 * CAM_FPS) //16 bit
#define MAX_BIT_RATE(width, height) (unsigned long)(width * height * 16 * CAM_FPS)
#define MAX_FRAME_SIZE(width, height) (unsigned long)(width * height * 2)
#define UVC_MAX_PACKET_SIZE 64
#define UVC_INTF_STR_INDEX 0x02
#define VIDEO_BUFFER_SZ MAX_PAYLOAD_SIZE //USB发送缓存大小
#define EVENT_VIDEO_START (1 << 0)
#define EVENT_VIDEO_STOP (1 << 1)
#define EVENT_VIDEO_DATA (1 << 2)
#define EVENT_VIDEO_COMPLITE (1 << 3)
#define CONFIG_USBDEV_MAX_BUS 1
static struct usbd_video_priv g_usbd_video[CONFIG_USBDEV_MAX_BUS];
static struct uvc_class_device usbd_uvc;
struct uvc_vc_noep_descriptor
{
#ifdef RT_USB_DEVICE_COMPOSITE
struct uiad_descriptor iad_desc;
#endif
struct uinterface_descriptor intf_desc;
struct video_cs_if_vc_header_descriptor hdr_desc;
struct video_cs_if_vc_input_terminal_descriptor it_desc;
struct video_cs_if_vc_processing_unit_descriptor pu_desc;
struct video_cs_if_vc_output_terminal_descriptor ot_desc;
};
struct uvc_vs_noep_descriptor
{
struct uinterface_descriptor intf_desc;
struct video_cs_if_vs_input_header_descriptor it_desc;
#if VIDEO_MJPEG_bNumFrameDescriptors >= 1
struct video_cs_if_vs_format_mjpeg_descriptor fmt_desc;
struct video_cs_if_vs_frame_mjpeg_descriptor frame_desc;
#endif
#if VIDEO_MJPEG_bNumFrameDescriptors >= 2
struct video_cs_if_vs_frame_mjpeg_descriptor frame2_desc;
#endif
#if VIDEO_H26x__bNumFrameDescriptors >= 1
struct video_cs_if_vs_format_h26x_descriptor h264_desc;
struct video_cs_if_vs_frame_h26x_descriptor h264_frame_desc;
#endif
#if VIDEO_H26x__bNumFrameDescriptors >= 2
struct video_cs_if_vs_frame_h26x_descriptor h264_frame2_desc;
#endif
};
struct uvc_vs_ep_descriptor
{
struct uinterface_descriptor intf_desc;
struct uendpoint_descriptor ep_desc;
};
rt_align(4)
static struct udevice_descriptor dev_desc =
{
USB_DESC_LENGTH_DEVICE, //bLength;
USB_DESC_TYPE_DEVICE, //type;
USB_BCD_VERSION, //bcdUSB;
USB_CLASS_MISC, //bDeviceClass;
0x02, //bDeviceSubClass;
0x01, //bDeviceProtocol;
UVC_MAX_PACKET_SIZE, //bMaxPacketSize0;
_VENDOR_ID, //idVendor;
_PRODUCT_ID, //idProduct;
USB_BCD_DEVICE, //bcdDevice;
USB_STRING_MANU_INDEX, //iManufacturer;
USB_STRING_PRODUCT_INDEX, //iProduct;
USB_STRING_SERIAL_INDEX, //iSerialNumber;Unused.
0x00, //bNumConfigurations;
};
//FS and HS needed
rt_align(4)
static struct usb_qualifier_descriptor dev_qualifier =
{
sizeof(dev_qualifier), //bLength
USB_DESC_TYPE_DEVICEQUALIFIER, //bDescriptorType
0x0200, //bcdUSB
USB_CLASS_VIDEO, //bDeviceClass
0x00, //bDeviceSubClass
0x00, //bDeviceProtocol
64, //bMaxPacketSize0
0x01, //bNumConfigurations
0,
};
rt_align(4)
const static char *_ustring[] =
{
"Language",
"USBZH", //"Cherry USB",
"USB2.0 Camera", //"USB Composite Device",
"20240411",
};
rt_align(4)
static struct uvc_vc_noep_descriptor vc_desc =
{
#ifdef RT_USB_DEVICE_COMPOSITE
{
USB_DESC_LENGTH_IAD,
USB_DESC_TYPE_IAD,
USB_DYNAMIC,
0x02,
USB_CLASS_VIDEO,
VIDEO_SC_VIDEO_INTERFACE_COLLECTION,
0x00,
0x00,
},
#endif
/* Interface Descriptor */
{
USB_DESC_LENGTH_INTERFACE,
USB_DESC_TYPE_INTERFACE,
USB_DYNAMIC,
0x00,
0x00,
USB_CLASS_VIDEO,
VIDEO_SC_VIDEOCONTROL,
VIDEO_PC_PROTOCOL_UNDEFINED,
#ifdef RT_USB_DEVICE_COMPOSITE
UVC_INTF_STR_INDEX,
#else
0x00,
#endif
},
/* Header Descriptor */
{
sizeof(struct video_cs_if_vc_header_descriptor), //0x0d,
VIDEO_CS_INTERFACE_DESCRIPTOR_TYPE,
VIDEO_VC_HEADER_DESCRIPTOR_SUBTYPE,
0x0100,
VIDEO_VC_TERMINAL_LEN,
48000000,
0x01,
{0x01},
},
/* Input Terminal Descriptor */
{
sizeof(struct video_cs_if_vc_input_terminal_descriptor), //0x12,
VIDEO_CS_INTERFACE_DESCRIPTOR_TYPE,
VIDEO_VC_INPUT_TERMINAL_DESCRIPTOR_SUBTYPE,
0x01,
VIDEO_ITT_CAMERA,
0x00,
0x00,
0x0000,
0x0000,
0x0000,
0x03,
{0x00, 0x00, 0x00},
},
/* Processing Unit Descriptor */
{
sizeof(struct video_cs_if_vc_processing_unit_descriptor), //0x0c,
VIDEO_CS_INTERFACE_DESCRIPTOR_TYPE,
VIDEO_VC_PROCESSING_UNIT_DESCRIPTOR_SUBTYPE,
0x02,
0x01,
0x0000,
0x02,
{0xFF,0xFF},
0x00,
0x00,
},
/* Output Terminal Descriptor */
{
sizeof(struct video_cs_if_vc_output_terminal_descriptor), //0x09,
VIDEO_CS_INTERFACE_DESCRIPTOR_TYPE,
VIDEO_VC_OUTPUT_TERMINAL_DESCRIPTOR_SUBTYPE,
0x03,
VIDEO_TT_STREAMING,
0x00,
0x02,
0x00,
},
};
#define VIDEO_VS_INPUT_HEADER_DESC_LEN (sizeof(struct video_cs_if_vs_input_header_descriptor))
#if (VIDEO_MJPEG_bNumFrameDescriptors >= 1)
#define VIDEO_MJPEG_HEADER_LEN (sizeof(struct video_cs_if_vs_format_mjpeg_descriptor) + \
sizeof(struct video_cs_if_vs_frame_mjpeg_descriptor) * VIDEO_MJPEG_bNumFrameDescriptors)
#else
#define VIDEO_MJPEG_HEADER_LEN 0
#endif
#if (VIDEO_H26x__bNumFrameDescriptors >= 1)
#define VIDEO_H26X_HEADER_LEN (sizeof(struct video_cs_if_vs_format_h26x_descriptor) + \
sizeof(struct video_cs_if_vs_frame_h26x_descriptor) * VIDEO_H26x__bNumFrameDescriptors)
#else
#define VIDEO_H26X_HEADER_LEN 0
#endif
#define VIDEO_VS_INPUT_HEADER_wTotalLength (VIDEO_VS_INPUT_HEADER_DESC_LEN + VIDEO_MJPEG_HEADER_LEN + VIDEO_H26X_HEADER_LEN)
#define VIDEO_VS_INPUT_HEADER_bNumFormats ( ((VIDEO_MJPEG_bNumFrameDescriptors) ? 1 : 0) + \
((VIDEO_H26x__bNumFrameDescriptors) ? 1 : 0) )
#define VIDEO_VS_INPUT_HEADER_bControlSize ((VIDEO_VS_INPUT_HEADER_bNumFormats >= 2) ? 1 : 2)
rt_align(4)
static struct uvc_vs_noep_descriptor vs_noep_desc =
{
/* Interface Descriptor */
{
USB_DESC_LENGTH_INTERFACE,
USB_DESC_TYPE_INTERFACE,
0x01,
0x00,
0x00,
USB_CLASS_VIDEO,
VIDEO_SC_VIDEOSTREAMING,
0x00,
0x00,
},
/* Header Descriptor */
{
sizeof(struct video_cs_if_vs_input_header_descriptor), //0x0d,
VIDEO_CS_INTERFACE_DESCRIPTOR_TYPE,
VIDEO_VS_INPUT_HEADER_DESCRIPTOR_SUBTYPE,
VIDEO_VS_INPUT_HEADER_bNumFormats,
VIDEO_VS_INPUT_HEADER_wTotalLength,
VIDEO_IN_EP,
0x00,
0x03,
0x00,
0x00,
0x00,
VIDEO_VS_INPUT_HEADER_bControlSize,
{0x00,0x00},/* bmaControls : No VideoStreaming specific controls are supported.*/
},
#if VIDEO_MJPEG_bNumFrameDescriptors >= 1
/* VS Format Descriptor */
{
sizeof(struct video_cs_if_vs_format_mjpeg_descriptor), //0x0b,
VIDEO_CS_INTERFACE_DESCRIPTOR_TYPE,
VIDEO_VS_FORMAT_MJPEG_DESCRIPTOR_SUBTYPE,
0x01,
VIDEO_MJPEG_bNumFrameDescriptors,
0x00,
0x01,
0x00,
0x00,
0x00,
0x00,
},
/* VS Frame 640x360 Descriptor */
{
sizeof(struct video_cs_if_vs_frame_mjpeg_descriptor), //0x1a,
VIDEO_CS_INTERFACE_DESCRIPTOR_TYPE,
VIDEO_VS_FRAME_MJPEG_DESCRIPTOR_SUBTYPE,
0x01,
0x00,
VIDEO_MJPEG_Frame1_WIDTH,
VIDEO_MJPEG_Frame1_HEIGHT,
MIN_BIT_RATE(VIDEO_MJPEG_Frame1_WIDTH,VIDEO_MJPEG_Frame1_HEIGHT),
MAX_BIT_RATE(VIDEO_MJPEG_Frame1_WIDTH,VIDEO_MJPEG_Frame1_HEIGHT),
MAX_FRAME_SIZE(VIDEO_MJPEG_Frame1_WIDTH,VIDEO_MJPEG_Frame1_HEIGHT),
INTERVAL,
0x01,
{INTERVAL},
},
#endif
#if VIDEO_MJPEG_bNumFrameDescriptors >= 2
/* VS Frame 1280x720 Descriptor */
{
sizeof(struct video_cs_if_vs_frame_mjpeg_descriptor), //0x1a,
VIDEO_CS_INTERFACE_DESCRIPTOR_TYPE,
VIDEO_VS_FRAME_MJPEG_DESCRIPTOR_SUBTYPE,
0x02,
0x00,
VIDEO_MJPEG_Frame2_WIDTH,
VIDEO_MJPEG_Frame2_HEIGHT,
MIN_BIT_RATE(VIDEO_MJPEG_Frame2_WIDTH,VIDEO_MJPEG_Frame2_HEIGHT),
MAX_BIT_RATE(VIDEO_MJPEG_Frame2_WIDTH,VIDEO_MJPEG_Frame2_HEIGHT),
MAX_FRAME_SIZE(VIDEO_MJPEG_Frame2_WIDTH,VIDEO_MJPEG_Frame2_HEIGHT),
INTERVAL,
0x01,
{INTERVAL},
},
#endif
#if VIDEO_H26x__bNumFrameDescriptors >= 1
/* VS H264 Format Descriptor */
{
sizeof(struct video_cs_if_vs_format_h26x_descriptor), //bLength
VIDEO_CS_INTERFACE_DESCRIPTOR_TYPE, //bDescriptorType
VIDEO_VS_FORMAT_FRAME_BASED_DESCRIPTOR_SUBTYPE, //bDescriptorSubType
0x02, //bFormatIndex
VIDEO_H26x__bNumFrameDescriptors, //bNumFrameDescriptors
{VIDEO_GUID_H264}, //guidFormat[16]
0x00, //bBitsPerPixel
0x01, //bDefaultFrameIndex
0x00, //bAspectRatioX
0x00, //bAspectRatioY
0x00, //bmInterfaceFlags
0x00, //bCopyProtect
0x01, //bVariableSize
},
/* VS Frame 1280x720 Descriptor */
{
sizeof(struct video_cs_if_vs_frame_h26x_descriptor), //bLength
VIDEO_CS_INTERFACE_DESCRIPTOR_TYPE, //bDescriptorType
VIDEO_VS_FRAME_FRAME_BASED_DESCRIPTOR_SUBTYPE, //bDescriptorSubType
0x01, //bFrameIndex
0x00, //bmCapabilities
VIDEO_H26x_Frame1_WIDTH, //wWidth
VIDEO_H26x_Frame1_HEIGHT, //wHeight
MIN_BIT_RATE(VIDEO_H26x_Frame1_WIDTH, VIDEO_H26x_Frame1_HEIGHT), //dwMinBitRate
MAX_BIT_RATE(VIDEO_H26x_Frame1_WIDTH, VIDEO_H26x_Frame1_HEIGHT), //dwMaxBitRate
INTERVAL, //dwDefaultFrameInterval
0x01, //bFrameIntervalType
0x00, //dwBytesPerLine
{INTERVAL}, //dwFrameInterval
},
#endif
#if VIDEO_H26x__bNumFrameDescriptors >= 2
/* VS Frame 1920x1080 Descriptor */
{
sizeof(struct video_cs_if_vs_frame_h26x_descriptor), //bLength
VIDEO_CS_INTERFACE_DESCRIPTOR_TYPE, //bDescriptorType
VIDEO_VS_FRAME_FRAME_BASED_DESCRIPTOR_SUBTYPE, //bDescriptorSubType
0x02, //bFrameIndex
0x00, //bmCapabilities
VIDEO_H26x_Frame2_WIDTH, //wWidth
VIDEO_H26x_Frame2_HEIGHT, //wHeight
MIN_BIT_RATE(VIDEO_H26x_Frame2_WIDTH, VIDEO_H26x_Frame2_HEIGHT), //dwMinBitRate
MAX_BIT_RATE(VIDEO_H26x_Frame2_WIDTH, VIDEO_H26x_Frame2_HEIGHT), //dwMaxBitRate
INTERVAL, //dwDefaultFrameInterval
0x01, //bFrameIntervalType
0x00, //dwBytesPerLine
{INTERVAL}, //dwFrameInterval
},
#endif
};
rt_align(4)
static struct uvc_vs_ep_descriptor vs_ep_desc =
{
/* Interface Descriptor */
{
USB_DESC_LENGTH_INTERFACE,
USB_DESC_TYPE_INTERFACE,
0x01,
0x01,
0x01,
USB_CLASS_VIDEO,
VIDEO_SC_VIDEOSTREAMING,
0x00,
0x00,
},
/* Endpoint Descriptor */
{
USB_DESC_LENGTH_ENDPOINT,
USB_DESC_TYPE_ENDPOINT,
USB_DYNAMIC | USB_DIR_IN,
0x05,
VIDEO_PACKET_SIZE,
0x01,
},
};
static rt_err_t rt_usbd_video_send_msg(struct usbd_video_msg *msg)
{
return rt_mq_send(&g_usbd_video[0].video_mq, (void*)msg, sizeof(struct usbd_video_msg));
}
static rt_err_t rt_usbd_video_recv_msg(struct usbd_video_msg *msg)
{
return rt_mq_recv(&g_usbd_video[0].video_mq, msg, sizeof(struct usbd_video_msg), 100);
}
static rt_err_t _ep0_cmd_handler(udevice_t device, rt_size_t size)
{
struct usbd_video_msg msg;
LOG_D("_ep0_cmd_handler");
if(rt_usbd_video_recv_msg(&msg) < 0)
{
os_printf("%s %d: Not recv msg!\n");
}
else
{
if((msg.flush_info_addr != RT_NULL) && (msg.dma_buff != RT_NULL) && (msg.copy_len != 0))
{
memcpy(msg.flush_info_addr, msg.dma_buff, msg.copy_len);
}
}
dcd_ep0_send_status(device->dcd);
return RT_EOK;
}
static rt_bool_t usbd_video_control_request_handler(rt_uint8_t busid, ufunction_t func, ureq_t setup)
{
rt_uint8_t control_selector = (rt_uint8_t)(setup->wValue >> 8);
static rt_uint8_t buf[26] __attribute__((aligned(4)));
os_printf("%s %d\n",__FUNCTION__,__LINE__);
switch (control_selector) {
case VIDEO_VC_VIDEO_POWER_MODE_CONTROL:
switch (setup->bRequest) {
case VIDEO_REQUEST_SET_CUR:
break;
case VIDEO_REQUEST_GET_CUR:
break;
case VIDEO_REQUEST_GET_INFO:
break;
default:
LOG_D("Unhandled Video Class bRequest 0x%02x\r\n", setup->bRequest);
return -1;
}
break;
case VIDEO_VC_REQUEST_ERROR_CODE_CONTROL:
switch (setup->bRequest) {
case VIDEO_REQUEST_GET_CUR:
buf[0] = 0x06;
rt_usbd_ep0_write(func->device, (rt_uint8_t *)buf, 1);
break;
case VIDEO_REQUEST_GET_INFO:
break;
default:
LOG_D("Unhandled Video Class bRequest 0x%02x\r\n", setup->bRequest);
return -1;
}
break;
default:
break;
}
return 0;
}
static rt_bool_t usbd_video_control_unit_terminal_request_handler(rt_uint8_t busid, ufunction_t func, ureq_t setup)
{
rt_uint8_t entity_id = (rt_uint8_t)(setup->wIndex >> 8);
rt_uint8_t control_selector = (rt_uint8_t)(setup->wValue >> 8);
struct usbd_video_msg msg;
static rt_uint8_t data[26] __attribute__((aligned(4)));
for (rt_uint8_t i = 0; i < 3; i++) {
struct video_entity_info *entity_info = &g_usbd_video[busid].info[i];
if (entity_info->bEntityId == entity_id) {
switch (entity_info->bDescriptorSubtype) {
case VIDEO_VC_HEADER_DESCRIPTOR_SUBTYPE:
break;
case VIDEO_VC_INPUT_TERMINAL_DESCRIPTOR_SUBTYPE:
if (entity_info->wTerminalType == VIDEO_ITT_CAMERA) {
switch (control_selector) {
case VIDEO_CT_AE_MODE_CONTROL:
switch (setup->bRequest) {
case VIDEO_REQUEST_GET_CUR:
data[0] = 0x08;
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 1);
break;
default:
LOG_D("Unhandled Video Class bRequest 0x%02x\r\n", setup->bRequest);
return -1;
}
break;
case VIDEO_CT_EXPOSURE_TIME_ABSOLUTE_CONTROL:
switch (setup->bRequest) {
case VIDEO_REQUEST_GET_CUR: {
rt_uint32_t dwExposureTimeAbsolute = 2500;
memcpy(data, (rt_uint8_t *)&dwExposureTimeAbsolute, 4);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 4);
} break;
case VIDEO_REQUEST_GET_MIN: {
rt_uint32_t dwExposureTimeAbsolute = 5; //0.0005sec
memcpy(data, (rt_uint8_t *)&dwExposureTimeAbsolute, 4);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 4);
} break;
case VIDEO_REQUEST_GET_MAX: {
rt_uint32_t dwExposureTimeAbsolute = 2500; //0.2500sec
memcpy(data, (rt_uint8_t *)&dwExposureTimeAbsolute, 4);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 4);
} break;
case VIDEO_REQUEST_GET_RES: {
rt_uint32_t dwExposureTimeAbsolute = 5; //0.0005sec
memcpy(data, (rt_uint8_t *)&dwExposureTimeAbsolute, 4);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 4);
} break;
case VIDEO_REQUEST_GET_INFO:
data[0] = 0x03; //struct video_camera_capabilities
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 1);
break;
case VIDEO_REQUEST_GET_DEF: {
rt_uint32_t dwExposureTimeAbsolute = 2500; //0.2500sec
memcpy(data, (rt_uint8_t *)&dwExposureTimeAbsolute, 4);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 4);
} break;
default:
LOG_D("Unhandled Video Class bRequest 0x%02x\r\n", setup->bRequest);
return -1;
}
break;
case VIDEO_CT_FOCUS_ABSOLUTE_CONTROL:
switch (setup->bRequest) {
case VIDEO_REQUEST_GET_CUR: {
rt_uint16_t wFocusAbsolute = 0x0080;
memcpy(data, (rt_uint8_t *)&wFocusAbsolute, 2);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 2);
} break;
case VIDEO_REQUEST_GET_MIN: {
rt_uint16_t wFocusAbsolute = 0;
memcpy(data, (rt_uint8_t *)&wFocusAbsolute, 2);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 2);
} break;
case VIDEO_REQUEST_GET_MAX: {
rt_uint16_t wFocusAbsolute = 0x00ff;
memcpy(data, (rt_uint8_t *)&wFocusAbsolute, 2);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 2);
} break;
case VIDEO_REQUEST_GET_RES: {
rt_uint16_t wFocusAbsolute = 0x0001;
memcpy(data, (rt_uint8_t *)&wFocusAbsolute, 2);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 2);
} break;
case VIDEO_REQUEST_GET_INFO:
data[0] = 0x03; //struct video_camera_capabilities
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 1);
break;
case VIDEO_REQUEST_GET_DEF: {
rt_uint16_t wFocusAbsolute = 0x0080;
memcpy(data, (rt_uint8_t *)&wFocusAbsolute, 2);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 2);
} break;
default:
LOG_D("Unhandled Video Class bRequest 0x%02x\r\n", setup->bRequest);
return -1;
}
break;
case VIDEO_CT_ZOOM_ABSOLUTE_CONTROL:
switch (setup->bRequest) {
case VIDEO_REQUEST_GET_CUR: {
rt_uint16_t wObjectiveFocalLength = 0x0064;
memcpy(data, (rt_uint8_t *)&wObjectiveFocalLength, 2);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 2);
} break;
case VIDEO_REQUEST_GET_MIN: {
rt_uint16_t wObjectiveFocalLength = 0x0064;
memcpy(data, (rt_uint8_t *)&wObjectiveFocalLength, 2);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 2);
} break;
case VIDEO_REQUEST_GET_MAX: {
rt_uint16_t wObjectiveFocalLength = 0x00c8;
memcpy(data, (rt_uint8_t *)&wObjectiveFocalLength, 2);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 2);
} break;
case VIDEO_REQUEST_GET_RES: {
rt_uint16_t wObjectiveFocalLength = 0x0001;
memcpy(data, (rt_uint8_t *)&wObjectiveFocalLength, 2);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 2);
} break;
case VIDEO_REQUEST_GET_INFO:
data[0] = 0x03; //struct video_camera_capabilities
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 1);
break;
case VIDEO_REQUEST_GET_DEF: {
rt_uint16_t wObjectiveFocalLength = 0x0064;
memcpy(data, (rt_uint8_t *)&wObjectiveFocalLength, 2);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 2);
} break;
default:
LOG_D("Unhandled Video Class bRequest 0x%02x\r\n", setup->bRequest);
return -1;
}
break;
case VIDEO_CT_ROLL_ABSOLUTE_CONTROL:
switch (setup->bRequest) {
case VIDEO_REQUEST_GET_CUR: {
rt_uint16_t wRollAbsolute = 0x0000;
memcpy(data, (rt_uint8_t *)&wRollAbsolute, 2);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 2);
} break;
case VIDEO_REQUEST_GET_MIN: {
rt_uint16_t wRollAbsolute = 0x0000;
memcpy(data, (rt_uint8_t *)&wRollAbsolute, 2);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 2);
} break;
case VIDEO_REQUEST_GET_MAX: {
rt_uint16_t wRollAbsolute = 0x00ff;
memcpy(data, (rt_uint8_t *)&wRollAbsolute, 2);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 2);
} break;
case VIDEO_REQUEST_GET_RES: {
rt_uint16_t wRollAbsolute = 0x0001;
memcpy(data, (rt_uint8_t *)&wRollAbsolute, 2);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 2);
} break;
case VIDEO_REQUEST_GET_INFO:
data[0] = 0x03; //struct video_camera_capabilities
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 1);
break;
case VIDEO_REQUEST_GET_DEF: {
rt_uint16_t wRollAbsolute = 0x0000;
memcpy(data, (rt_uint8_t *)&wRollAbsolute, 2);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 2);
} break;
default:
LOG_D("Unhandled Video Class bRequest 0x%02x\r\n", setup->bRequest);
return -1;
}
break;
case VIDEO_CT_FOCUS_AUTO_CONTROL:
switch (setup->bRequest) {
case VIDEO_REQUEST_GET_CUR: {
rt_uint16_t wFocusAuto = 0x0000;
memcpy(data, (rt_uint8_t *)&wFocusAuto, 2);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 2);
} break;
default:
LOG_D("Unhandled Video Class bRequest 0x%02x\r\n", setup->bRequest);
return -1;
}
break;
default:
LOG_D("Unhandled Video Class control selector 0x%02x\r\n", control_selector);
return -1;
}
} else {
LOG_D("Unhandled Video Class wTerminalType 0x%02x\r\n", entity_info->wTerminalType);
return -2;
}
break;
case VIDEO_VC_OUTPUT_TERMINAL_DESCRIPTOR_SUBTYPE:
break;
case VIDEO_VC_SELECTOR_UNIT_DESCRIPTOR_SUBTYPE:
break;
case VIDEO_VC_PROCESSING_UNIT_DESCRIPTOR_SUBTYPE:
switch (control_selector) {
case VIDEO_PU_BACKLIGHT_COMPENSATION_CONTROL:
switch (setup->bRequest) {
case VIDEO_REQUEST_SET_CUR: {
rt_usbd_ep0_read(func->device, (rt_uint8_t *)&data, setup->wLength, _ep0_cmd_handler);
msg.flush_info_addr = (rt_uint8_t *)&g_usbd_video[busid].process_unit_info.wBacklightCompensation;
msg.dma_buff = (rt_uint8_t *)&data;
msg.copy_len = 2;
msg.control_selector = control_selector;
rt_usbd_video_send_msg(&msg);
} break;
case VIDEO_REQUEST_GET_CUR: {
rt_uint16_t wBacklightCompensation = g_usbd_video[busid].process_unit_info.wBacklightCompensation;
memcpy(data, (rt_uint8_t *)&wBacklightCompensation, 2);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 2);
} break;
case VIDEO_REQUEST_GET_MIN: {
rt_uint16_t wBacklightCompensation = 0;
memcpy(data, (rt_uint8_t *)&wBacklightCompensation, 2);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 2);
} break;
case VIDEO_REQUEST_GET_MAX: {
rt_uint16_t wBacklightCompensation = 8;
memcpy(data, (rt_uint8_t *)&wBacklightCompensation, 2);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 2);
} break;
case VIDEO_REQUEST_GET_RES: {
rt_uint16_t wBacklightCompensation = 1;
memcpy(data, (rt_uint8_t *)&wBacklightCompensation, 2);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 2);
} break;
case VIDEO_REQUEST_GET_INFO:
data[0] = 0x03; //struct video_camera_capabilities
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 1);
break;
case VIDEO_REQUEST_GET_DEF: {
rt_uint16_t wBacklightCompensation = 4;
memcpy(data, (rt_uint8_t *)&wBacklightCompensation, 2);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 2);
} break;
default:
LOG_D("Unhandled Video Class bRequest 0x%02x\r\n", setup->bRequest);
return -1;
}
break;
case VIDEO_PU_BRIGHTNESS_CONTROL:
switch (setup->bRequest) {
case VIDEO_REQUEST_SET_CUR: {
//rt_uint16_t wBrightness = (rt_uint16_t)(*data)[1] << 8 | (rt_uint16_t)(*data)[0];
rt_usbd_ep0_read(func->device, (rt_uint8_t *)&data, setup->wLength, _ep0_cmd_handler);
msg.flush_info_addr = (rt_uint8_t *)&g_usbd_video[busid].process_unit_info.wBrightness;
msg.dma_buff = (rt_uint8_t *)&data;
msg.copy_len = 2;
msg.control_selector = control_selector;
rt_usbd_video_send_msg(&msg);
} break;
case VIDEO_REQUEST_GET_CUR: {
rt_uint16_t wBrightness = g_usbd_video[busid].process_unit_info.wBrightness;
memcpy(data, (rt_uint8_t *)&wBrightness, 2);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 2);
} break;
case VIDEO_REQUEST_GET_MIN: {
rt_uint16_t wBrightness = 0x0001;
memcpy(data, (rt_uint8_t *)&wBrightness, 2);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 2);
} break;
case VIDEO_REQUEST_GET_MAX: {
rt_uint16_t wBrightness = 0x00ff;
memcpy(data, (rt_uint8_t *)&wBrightness, 2);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 2);
} break;
case VIDEO_REQUEST_GET_RES: {
rt_uint16_t wBrightness = 0x0001;
memcpy(data, (rt_uint8_t *)&wBrightness, 2);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 2);
} break;
case VIDEO_REQUEST_GET_INFO:
data[0] = 0x03; //struct video_camera_capabilities
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 1);
break;
case VIDEO_REQUEST_GET_DEF: {
rt_uint16_t wBrightness = 0x0080;
memcpy(data, (rt_uint8_t *)&wBrightness, 2);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 2);
} break;
default:
LOG_D("Unhandled Video Class bRequest 0x%02x\r\n", setup->bRequest);
return -1;
}
break;
case VIDEO_PU_CONTRAST_CONTROL:
switch (setup->bRequest) {
case VIDEO_REQUEST_SET_CUR: {
rt_usbd_ep0_read(func->device, (rt_uint8_t *)&data, setup->wLength, _ep0_cmd_handler);
msg.flush_info_addr = (rt_uint8_t *)&g_usbd_video[busid].process_unit_info.wContrast;
msg.dma_buff = (rt_uint8_t *)&data;
msg.copy_len = 2;
msg.control_selector = control_selector;
rt_usbd_video_send_msg(&msg);
} break;
case VIDEO_REQUEST_GET_CUR: {
rt_uint16_t wContrast = g_usbd_video[busid].process_unit_info.wContrast;
memcpy(data, (rt_uint8_t *)&wContrast, 2);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 2);
} break;
case VIDEO_REQUEST_GET_MIN: {
rt_uint16_t wContrast = 0x0001;
memcpy(data, (rt_uint8_t *)&wContrast, 2);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 2);
} break;
case VIDEO_REQUEST_GET_MAX: {
rt_uint16_t wContrast = 0x00ff;
memcpy(data, (rt_uint8_t *)&wContrast, 2);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 2);
} break;
case VIDEO_REQUEST_GET_RES: {
rt_uint16_t wContrast = 0x0001;
memcpy(data, (rt_uint8_t *)&wContrast, 2);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 2);
} break;
case VIDEO_REQUEST_GET_INFO:
data[0] = 0x03; //struct video_camera_capabilities
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 1);
break;
case VIDEO_REQUEST_GET_DEF: {
rt_uint16_t wContrast = 0x0080;
memcpy(data, (rt_uint8_t *)&wContrast, 2);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 2);
} break;
default:
LOG_D("Unhandled Video Class bRequest 0x%02x\r\n", setup->bRequest);
return -1;
}
break;
case VIDEO_PU_HUE_CONTROL:
switch (setup->bRequest) {
case VIDEO_REQUEST_SET_CUR: {
rt_usbd_ep0_read(func->device, (rt_uint8_t *)&data, setup->wLength, _ep0_cmd_handler);
msg.flush_info_addr = (rt_uint8_t *)&g_usbd_video[busid].process_unit_info.wHue;
msg.dma_buff = (rt_uint8_t *)&data;
msg.copy_len = 2;
msg.control_selector = control_selector;
rt_usbd_video_send_msg(&msg);
} break;
case VIDEO_REQUEST_GET_CUR: {
rt_uint16_t wHue = g_usbd_video[busid].process_unit_info.wHue;
memcpy(data, (rt_uint8_t *)&wHue, 2);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 2);
} break;
case VIDEO_REQUEST_GET_MIN: {
rt_uint16_t wHue = 0x0001;
memcpy(data, (rt_uint8_t *)&wHue, 2);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 2);
} break;
case VIDEO_REQUEST_GET_MAX: {
rt_uint16_t wHue = 0x00ff;
memcpy(data, (rt_uint8_t *)&wHue, 2);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 2);
} break;
case VIDEO_REQUEST_GET_RES: {
rt_uint16_t wHue = 0x0001;
memcpy(data, (rt_uint8_t *)&wHue, 2);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 2);
} break;
case VIDEO_REQUEST_GET_INFO:
data[0] = 0x03; //struct video_camera_capabilities
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 1);
break;
case VIDEO_REQUEST_GET_DEF: {
rt_uint16_t wHue = 0x0080;
memcpy(data, (rt_uint8_t *)&wHue, 2);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 2);
} break;
default:
LOG_D("Unhandled Video Class bRequest 0x%02x\r\n", setup->bRequest);
return -1;
}
break;
case VIDEO_PU_HUE_AUTO_CONTROL:
switch (setup->bRequest) {
case VIDEO_REQUEST_SET_CUR: {
rt_usbd_ep0_read(func->device, (rt_uint8_t *)&data, setup->wLength, _ep0_cmd_handler);
msg.flush_info_addr = (rt_uint8_t *)&g_usbd_video[busid].process_unit_info.wHue_Auto;
msg.dma_buff = (rt_uint8_t *)&data;
msg.copy_len = 1;
msg.control_selector = control_selector;
rt_usbd_video_send_msg(&msg);
} break;
case VIDEO_REQUEST_GET_CUR: {
rt_uint16_t wHue_Auto = g_usbd_video[busid].process_unit_info.wHue_Auto;
memcpy(data, (rt_uint8_t *)&wHue_Auto, 1);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 1);
} break;
case VIDEO_REQUEST_GET_RES: {
rt_uint16_t wHue_Auto = 0x0001;
memcpy(data, (rt_uint8_t *)&wHue_Auto, 2);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 2);
} break;
case VIDEO_REQUEST_GET_INFO: {
data[0] = 0x0; //struct video_camera_capabilities
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 1);
} break;
case VIDEO_REQUEST_GET_DEF: {
rt_uint16_t wHue_Auto = 0x0;
memcpy(data, (rt_uint8_t *)&wHue_Auto, 1);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 1);
} break;
default:
LOG_D("Unhandled Video Class bRequest 0x%02x\r\n", setup->bRequest);
return -1;
}
break;
case VIDEO_PU_SATURATION_CONTROL:
switch (setup->bRequest) {
case VIDEO_REQUEST_SET_CUR: {
rt_usbd_ep0_read(func->device, (rt_uint8_t *)&data, setup->wLength, _ep0_cmd_handler);
msg.flush_info_addr = (rt_uint8_t *)&g_usbd_video[busid].process_unit_info.wSaturation;
msg.dma_buff = (rt_uint8_t *)&data;
msg.copy_len = 2;
msg.control_selector = control_selector;
rt_usbd_video_send_msg(&msg);
} break;
case VIDEO_REQUEST_GET_CUR: {
rt_uint16_t wSaturation = g_usbd_video[busid].process_unit_info.wSaturation;
memcpy(data, (rt_uint8_t *)&wSaturation, 2);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 2);
} break;
case VIDEO_REQUEST_GET_MIN: {
rt_uint16_t wSaturation = 0x0001;
memcpy(data, (rt_uint8_t *)&wSaturation, 2);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 2);
} break;
case VIDEO_REQUEST_GET_MAX: {
rt_uint16_t wSaturation = 0x00ff;
memcpy(data, (rt_uint8_t *)&wSaturation, 2);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 2);
} break;
case VIDEO_REQUEST_GET_RES: {
rt_uint16_t wSaturation = 0x0001;
memcpy(data, (rt_uint8_t *)&wSaturation, 2);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 2);
} break;
case VIDEO_REQUEST_GET_INFO:
data[0] = 0x03; //struct video_camera_capabilities
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 1);
break;
case VIDEO_REQUEST_GET_DEF: {
rt_uint16_t wSaturation = 0x0080;
memcpy(data, (rt_uint8_t *)&wSaturation, 2);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 2);
} break;
default:
LOG_D("Unhandled Video Class bRequest 0x%02x\r\n", setup->bRequest);
return -1;
}
break;
case VIDEO_PU_SHARPNESS_CONTROL:
switch (setup->bRequest) {
case VIDEO_REQUEST_SET_CUR: {
rt_usbd_ep0_read(func->device, (rt_uint8_t *)&data, setup->wLength, _ep0_cmd_handler);
msg.flush_info_addr = (rt_uint8_t *)&g_usbd_video[busid].process_unit_info.wSharpness;
msg.dma_buff = (rt_uint8_t *)&data;
msg.copy_len = 2;
msg.control_selector = control_selector;
rt_usbd_video_send_msg(&msg);
} break;
case VIDEO_REQUEST_GET_CUR: {
rt_uint16_t wSharpness = g_usbd_video[busid].process_unit_info.wSharpness;
memcpy(data, (rt_uint8_t *)&wSharpness, 2);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 2);
} break;
case VIDEO_REQUEST_GET_MIN: {
rt_uint16_t wSharpness = 0x0001;
memcpy(data, (rt_uint8_t *)&wSharpness, 2);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 2);
} break;
case VIDEO_REQUEST_GET_MAX: {
rt_uint16_t wSharpness = 0x00ff;
memcpy(data, (rt_uint8_t *)&wSharpness, 2);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 2);
} break;
case VIDEO_REQUEST_GET_RES: {
rt_uint16_t wSharpness = 0x0001;
memcpy(data, (rt_uint8_t *)&wSharpness, 2);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 2);
} break;
case VIDEO_REQUEST_GET_INFO:
data[0] = 0x03; //struct video_camera_capabilities
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 1);
break;
case VIDEO_REQUEST_GET_DEF: {
rt_uint16_t wSharpness = 0x0080;
memcpy(data, (rt_uint8_t *)&wSharpness, 2);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 2);
} break;
default:
LOG_D("Unhandled Video Class bRequest 0x%02x\r\n", setup->bRequest);
return -1;
}
break;
case VIDEO_PU_GAMMA_CONTROL:
switch (setup->bRequest) {
case VIDEO_REQUEST_SET_CUR: {
rt_usbd_ep0_read(func->device, (rt_uint8_t *)&data, setup->wLength, _ep0_cmd_handler);
msg.flush_info_addr = (rt_uint8_t *)&g_usbd_video[busid].process_unit_info.wGamma;
msg.dma_buff = (rt_uint8_t *)&data;
msg.copy_len = 2;
msg.control_selector = control_selector;
rt_usbd_video_send_msg(&msg);
} break;
case VIDEO_REQUEST_GET_CUR: {
rt_uint16_t wGamma = g_usbd_video[busid].process_unit_info.wGamma;
memcpy(data, (rt_uint8_t *)&wGamma, 2);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 2);
} break;
case VIDEO_REQUEST_GET_MIN: {
rt_uint16_t wGamma = 0x0001;
memcpy(data, (rt_uint8_t *)&wGamma, 2);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 2);
} break;
case VIDEO_REQUEST_GET_MAX: {
rt_uint16_t wGamma = 0x0064;
memcpy(data, (rt_uint8_t *)&wGamma, 2);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 2);
} break;
case VIDEO_REQUEST_GET_RES: {
rt_uint16_t wGamma = 0x0001;
memcpy(data, (rt_uint8_t *)&wGamma, 2);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 2);
} break;
case VIDEO_REQUEST_GET_INFO:
data[0] = 0x03; //struct video_camera_capabilities
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 1);
break;
case VIDEO_REQUEST_GET_DEF: {
rt_uint16_t wGamma = 0x0032;
memcpy(data, (rt_uint8_t *)&wGamma, 2);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 2);
} break;
default:
LOG_D("Unhandled Video Class bRequest 0x%02x\r\n", setup->bRequest);
return -1;
}
break;
case VIDEO_PU_GAIN_CONTROL:
switch (setup->bRequest) {
case VIDEO_REQUEST_SET_CUR: {
rt_usbd_ep0_read(func->device, (rt_uint8_t *)&data, setup->wLength, _ep0_cmd_handler);
msg.flush_info_addr = (rt_uint8_t *)&g_usbd_video[busid].process_unit_info.wGain;
msg.dma_buff = (rt_uint8_t *)&data;
msg.copy_len = 2;
msg.control_selector = control_selector;
rt_usbd_video_send_msg(&msg);
} break;
case VIDEO_REQUEST_GET_CUR: {
rt_uint16_t wGain = g_usbd_video[busid].process_unit_info.wGain;
memcpy(data, (rt_uint8_t *)&wGain, 2);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 2);
} break;
case VIDEO_REQUEST_GET_MIN: {
rt_uint16_t wGain = 0;
memcpy(data, (rt_uint8_t *)&wGain, 2);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 2);
} break;
case VIDEO_REQUEST_GET_MAX: {
rt_uint16_t wGain = 255;
memcpy(data, (rt_uint8_t *)&wGain, 2);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 2);
} break;
case VIDEO_REQUEST_GET_RES: {
rt_uint16_t wGain = 1;
memcpy(data, (rt_uint8_t *)&wGain, 2);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 2);
} break;
case VIDEO_REQUEST_GET_INFO:
data[0] = 0x03; //struct video_camera_capabilities
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 1);
break;
case VIDEO_REQUEST_GET_DEF: {
rt_uint16_t wGain = 255;
memcpy(data, (rt_uint8_t *)&wGain, 2);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 2);
} break;
default:
LOG_D("Unhandled Video Class bRequest 0x%02x\r\n", setup->bRequest);
return -1;
}
break;
case VIDEO_PU_POWER_LINE_FREQUENCY_CONTROL:
switch (setup->bRequest) {
case VIDEO_REQUEST_SET_CUR: {
rt_usbd_ep0_read(func->device, (rt_uint8_t *)&data, setup->wLength, _ep0_cmd_handler);
msg.flush_info_addr = (rt_uint8_t *)&g_usbd_video[busid].process_unit_info.bPowerLineFrequency;
msg.dma_buff = (rt_uint8_t *)&data;
msg.copy_len = 1;
msg.control_selector = control_selector;
rt_usbd_video_send_msg(&msg);
} break;
case VIDEO_REQUEST_GET_CUR: {
rt_uint8_t bPowerLineFrequency = g_usbd_video[busid].process_unit_info.bPowerLineFrequency;
memcpy(data, (rt_uint8_t *)&bPowerLineFrequency, 1);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 1);
} break;
case VIDEO_REQUEST_GET_MIN: {
rt_uint8_t bPowerLineFrequency = 1;
memcpy(data, (rt_uint8_t *)&bPowerLineFrequency, 1);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 1);
} break;
case VIDEO_REQUEST_GET_MAX: {
rt_uint8_t bPowerLineFrequency = 2;
memcpy(data, (rt_uint8_t *)&bPowerLineFrequency, 1);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 1);
} break;
case VIDEO_REQUEST_GET_RES: {
rt_uint8_t bPowerLineFrequency = 1;
memcpy(data, (rt_uint8_t *)&bPowerLineFrequency, 1);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 1);
} break;
case VIDEO_REQUEST_GET_INFO:
data[0] = 0x03; //struct video_camera_capabilities
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 1);
break;
case VIDEO_REQUEST_GET_DEF: {
rt_uint8_t bPowerLineFrequency = 1;
memcpy(data, (rt_uint8_t *)&bPowerLineFrequency, 1);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 1);
} break;
default:
LOG_D("Unhandled Video Class bRequest 0x%02x\r\n", setup->bRequest);
return -1;
}
break;
case VIDEO_PU_WHITE_BALANCE_TEMPERATURE_CONTROL:
switch (setup->bRequest) {
case VIDEO_REQUEST_SET_CUR: {
rt_usbd_ep0_read(func->device, (rt_uint8_t *)&data, setup->wLength, _ep0_cmd_handler);
msg.flush_info_addr = (rt_uint8_t *)&g_usbd_video[busid].process_unit_info.wWhiteBalance_Temprature;
msg.dma_buff = (rt_uint8_t *)&data;
msg.copy_len = 2;
msg.control_selector = control_selector;
rt_usbd_video_send_msg(&msg);
} break;
case VIDEO_REQUEST_GET_CUR: {
rt_uint16_t wWhiteBalance_Temprature = g_usbd_video[busid].process_unit_info.wWhiteBalance_Temprature;
memcpy(data, (rt_uint8_t *)&wWhiteBalance_Temprature, 2);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 2);
} break;
case VIDEO_REQUEST_GET_MIN: {
rt_uint16_t wWhiteBalance_Temprature = 300;
memcpy(data, (rt_uint8_t *)&wWhiteBalance_Temprature, 2);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 2);
} break;
case VIDEO_REQUEST_GET_MAX: {
rt_uint16_t wWhiteBalance_Temprature = 600;
memcpy(data, (rt_uint8_t *)&wWhiteBalance_Temprature, 2);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 2);
} break;
case VIDEO_REQUEST_GET_RES: {
rt_uint16_t wWhiteBalance_Temprature = 1;
memcpy(data, (rt_uint8_t *)&wWhiteBalance_Temprature, 2);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 2);
} break;
case VIDEO_REQUEST_GET_INFO: {
data[0] = 0x03; //struct video_camera_capabilities
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 1);
} break;
case VIDEO_REQUEST_GET_DEF: {
rt_uint16_t wWhiteBalance_Temprature = 417;
memcpy(data, (rt_uint8_t *)&wWhiteBalance_Temprature, 2);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 2);
} break;
default:
LOG_D("Unhandled Video Class bRequest 0x%02x\r\n", setup->bRequest);
return -1;
}
break;
case VIDEO_PU_WHITE_BALANCE_TEMPERATURE_AUTO_CONTROL:
switch (setup->bRequest) {
case VIDEO_REQUEST_SET_CUR: {
rt_usbd_ep0_read(func->device, (rt_uint8_t *)&data, setup->wLength, _ep0_cmd_handler);
msg.flush_info_addr = (rt_uint8_t *)&g_usbd_video[busid].process_unit_info.wWhiteBalance_Temprature_Auto;
msg.dma_buff = (rt_uint8_t *)&data;
msg.copy_len = 1;
msg.control_selector = control_selector;
rt_usbd_video_send_msg(&msg);
} break;
case VIDEO_REQUEST_GET_CUR: {
rt_uint16_t wWhiteBalance_Temprature_Auto = g_usbd_video[busid].process_unit_info.wWhiteBalance_Temprature_Auto;
memcpy(data, (rt_uint8_t *)&wWhiteBalance_Temprature_Auto, 1);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 1);
} break;
case VIDEO_REQUEST_GET_INFO: {
data[0] = 0x0; //struct video_camera_capabilities
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 1);
} break;
case VIDEO_REQUEST_GET_DEF: {
rt_uint16_t wWhiteBalance_Temprature_Auto = 0;
memcpy(data, (rt_uint8_t *)&wWhiteBalance_Temprature_Auto, 1);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 1);
} break;
default:
LOG_D("Unhandled Video Class bRequest 0x%02x\r\n", setup->bRequest);
return -1;
}
break;
case VIDEO_PU_WHITE_BALANCE_COMPONENT_CONTROL:
switch (setup->bRequest) {
case VIDEO_REQUEST_SET_CUR: {
rt_usbd_ep0_read(func->device, (rt_uint8_t *)&data, setup->wLength, _ep0_cmd_handler);
msg.flush_info_addr = (rt_uint8_t *)&g_usbd_video[busid].process_unit_info.wWhiteBalance_Component;
msg.dma_buff = (rt_uint8_t *)&data;
msg.copy_len = 4;
msg.control_selector = control_selector;
rt_usbd_video_send_msg(&msg);
} break;
case VIDEO_REQUEST_GET_CUR: {
rt_uint32_t wWhiteBalance_Component = g_usbd_video[busid].process_unit_info.wWhiteBalance_Component;
memcpy(data, (rt_uint8_t *)&wWhiteBalance_Component, 4);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 4);
} break;
case VIDEO_REQUEST_GET_MIN: {
rt_uint32_t wWhiteBalance_Component = 5;
memcpy(data, (rt_uint8_t *)&wWhiteBalance_Component, 4);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 4);
} break;
case VIDEO_REQUEST_GET_MAX: {
rt_uint32_t wWhiteBalance_Component = 5;
memcpy(data, (rt_uint8_t *)&wWhiteBalance_Component, 4);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 4);
} break;
case VIDEO_REQUEST_GET_RES: {
rt_uint32_t wWhiteBalance_Component = 5;
memcpy(data, (rt_uint8_t *)&wWhiteBalance_Component, 4);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 4);
} break;
case VIDEO_REQUEST_GET_INFO:
data[0] = 0x05; //struct video_camera_capabilities
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 1);
break;
case VIDEO_REQUEST_GET_DEF: {
rt_uint32_t wWhiteBalance_Component = 5;
memcpy(data, (rt_uint8_t *)&wWhiteBalance_Component, 4);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 4);
} break;
default:
LOG_D("Unhandled Video Class bRequest 0x%02x\r\n", setup->bRequest);
return -1;
}
break;
case VIDEO_PU_WHITE_BALANCE_COMPONENT_AUTO_CONTROL:
switch (setup->bRequest) {
case VIDEO_REQUEST_SET_CUR: {
rt_usbd_ep0_read(func->device, (rt_uint8_t *)&data, setup->wLength, _ep0_cmd_handler);
msg.flush_info_addr = (rt_uint8_t *)&g_usbd_video[busid].process_unit_info.wWhiteBalance_Component_Auto;
msg.dma_buff = (rt_uint8_t *)&data;
msg.copy_len = 1;
msg.control_selector = control_selector;
rt_usbd_video_send_msg(&msg);
} break;
case VIDEO_REQUEST_GET_CUR: {
rt_uint16_t wWhiteBalance_Component_Auto = g_usbd_video[busid].process_unit_info.wWhiteBalance_Component_Auto;
memcpy(data, (rt_uint8_t *)&wWhiteBalance_Component_Auto, 1);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 1);
} break;
case VIDEO_REQUEST_GET_INFO: {
data[0] = 0x0; //struct video_camera_capabilities
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 1);
} break;
case VIDEO_REQUEST_GET_DEF: {
rt_uint16_t wWhiteBalance_Component_Auto = 0;
memcpy(data, (rt_uint8_t *)&wWhiteBalance_Component_Auto, 1);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 1);
} break;
default:
LOG_D("Unhandled Video Class bRequest 0x%02x\r\n", setup->bRequest);
return -1;
}
break;
case VIDEO_PU_DIGITAL_MULTIPLIER_CONTROL:
switch (setup->bRequest) {
case VIDEO_REQUEST_SET_CUR: {
rt_usbd_ep0_read(func->device, (rt_uint8_t *)&data, setup->wLength, _ep0_cmd_handler);
msg.flush_info_addr = (rt_uint8_t *)&g_usbd_video[busid].process_unit_info.wDigital_Multiplier;
msg.dma_buff = (rt_uint8_t *)&data;
msg.copy_len = 2;
msg.control_selector = control_selector;
rt_usbd_video_send_msg(&msg);
} break;
case VIDEO_REQUEST_GET_CUR: {
rt_uint16_t wDigital_Multiplier = g_usbd_video[busid].process_unit_info.wDigital_Multiplier;
memcpy(data, (rt_uint8_t *)&wDigital_Multiplier, 2);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 2);
} break;
case VIDEO_REQUEST_GET_MIN: {
rt_uint16_t wDigital_Multiplier = 5;
memcpy(data, (rt_uint8_t *)&wDigital_Multiplier, 2);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 2);
} break;
case VIDEO_REQUEST_GET_MAX: {
rt_uint16_t wDigital_Multiplier = 5;
memcpy(data, (rt_uint8_t *)&wDigital_Multiplier, 2);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 2);
} break;
case VIDEO_REQUEST_GET_RES: {
rt_uint16_t wDigital_Multiplier = 5;
memcpy(data, (rt_uint8_t *)&wDigital_Multiplier, 2);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 2);
} break;
case VIDEO_REQUEST_GET_INFO:
data[0] = 0x05; //struct video_camera_capabilities
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 1);
break;
case VIDEO_REQUEST_GET_DEF: {
rt_uint16_t wDigital_Multiplier = 5;
memcpy(data, (rt_uint8_t *)&wDigital_Multiplier, 2);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 2);
} break;
default:
LOG_D("Unhandled Video Class bRequest 0x%02x\r\n", setup->bRequest);
return -1;
}
break;
case VIDEO_PU_DIGITAL_MULTIPLIER_LIMIT_CONTROL:
switch (setup->bRequest) {
case VIDEO_REQUEST_SET_CUR: {
rt_usbd_ep0_read(func->device, (rt_uint8_t *)&data, setup->wLength, _ep0_cmd_handler);
msg.flush_info_addr = (rt_uint8_t *)&g_usbd_video[busid].process_unit_info.wDigital_Multiplier_Limit;
msg.dma_buff = (rt_uint8_t *)&data;
msg.copy_len = 1;
msg.control_selector = control_selector;
rt_usbd_video_send_msg(&msg);
} break;
case VIDEO_REQUEST_GET_CUR: {
rt_uint8_t wDigital_Multiplier_Limit = g_usbd_video[busid].process_unit_info.wDigital_Multiplier_Limit;
memcpy(data, (rt_uint8_t *)&wDigital_Multiplier_Limit, 1);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 1);
} break;
case VIDEO_REQUEST_GET_MIN: {
rt_uint16_t wDigital_Multiplier_Limit = 0;
memcpy(data, (rt_uint8_t *)&wDigital_Multiplier_Limit, 2);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 2);
} break;
case VIDEO_REQUEST_GET_MAX: {
rt_uint16_t wDigital_Multiplier_Limit = 5;
memcpy(data, (rt_uint8_t *)&wDigital_Multiplier_Limit, 2);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 2);
} break;
case VIDEO_REQUEST_GET_INFO: {
data[0] = 0x0; //struct video_camera_capabilities
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 1);
} break;
case VIDEO_REQUEST_GET_RES: {
rt_uint16_t wDigital_Multiplier_Limit = 0;
memcpy(data, (rt_uint8_t *)&wDigital_Multiplier_Limit, 2);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 2);
} break;
case VIDEO_REQUEST_GET_DEF: {
rt_uint16_t wDigital_Multiplier_Limit = 0;
memcpy(data, (rt_uint8_t *)&wDigital_Multiplier_Limit, 2);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)data, 2);
} break;
default:
LOG_D("Unhandled Video Class bRequest 0x%02x\r\n", setup->bRequest);
return -1;
}
break;
default:
g_usbd_video[busid].error_code = 0x06;
LOG_D("Unhandled Video Class control selector 0x%02x\r\n", control_selector);
return -1;
}
break;
case VIDEO_VC_EXTENSION_UNIT_DESCRIPTOR_SUBTYPE:
break;
case VIDEO_VC_ENCODING_UNIT_DESCRIPTOR_SUBTYPE:
break;
default:
break;
}
}
}
return 0;
}
static rt_uint32_t usbd_video_mjpeg_payload_fill(rt_uint8_t busid, rt_uint8_t *input, rt_uint32_t input_len, rt_uint8_t *output, rt_uint32_t *out_len)
{
rt_uint32_t packets;
rt_uint32_t last_packet_size;
rt_uint32_t picture_pos = 0;
static rt_uint8_t uvc_header[2] = { 0x02, 0x80 };
packets = (input_len + (g_usbd_video[busid].probe.dwMaxPayloadTransferSize - 2) ) / (g_usbd_video[busid].probe.dwMaxPayloadTransferSize - 2);
//os_printf("packets:%d input len:%d dwMaxPayloadSize:%d \n",packets,input_len,g_usbd_video[busid].probe.dwMaxPayloadTransferSize);
last_packet_size = input_len - ((packets - 1) * (g_usbd_video[busid].probe.dwMaxPayloadTransferSize - 2));
for (rt_size_t i = 0; i < packets; i++) {
output[g_usbd_video[busid].probe.dwMaxPayloadTransferSize * i] = uvc_header[0];
output[g_usbd_video[busid].probe.dwMaxPayloadTransferSize * i + 1] = uvc_header[1];
if (i == (packets - 1)) {
hw_memcpy(&output[2 + g_usbd_video[busid].probe.dwMaxPayloadTransferSize * i], &input[picture_pos], last_packet_size);
output[g_usbd_video[busid].probe.dwMaxPayloadTransferSize * i + 1] |= (1 << 1);
} else {
hw_memcpy(&output[2 + g_usbd_video[busid].probe.dwMaxPayloadTransferSize * i], &input[picture_pos], g_usbd_video[busid].probe.dwMaxPayloadTransferSize - 2);
picture_pos += g_usbd_video[busid].probe.dwMaxPayloadTransferSize - 2;
}
}
uvc_header[1] ^= 1;
*out_len = (input_len + 2 * packets);
return packets;
}
static rt_uint32_t usbd_video_mjpeg_payload_header_fill(rt_uint8_t *input, rt_uint32_t input_len, rt_uint8_t *output, rt_uint8_t *uvc_header, rt_uint8_t uvc_header_len)
{
//os_printf("uvc header len:%d\n",uvc_header_len);
if(input_len < VIDEO_PACKET_SIZE - uvc_header_len) //2为header的长度
{
output[0] = uvc_header[0];
output[1] = uvc_header[1];
output[1] |= (1 << 1);
os_memcpy(&output[2], input, input_len);
uvc_header[1] ^= 1;
}
else
{
output[0] = uvc_header[0];
output[1] = uvc_header[1];
os_memcpy(&output[2], input, input_len);
}
return input_len + uvc_header_len;
}
static rt_err_t usbd_video_open(rt_uint8_t busid, ufunction_t func)
{
os_printf("usbd video open\r\n");
os_printf("g_usbd_video[busid].probe.bFormatIndex:%d\n",g_usbd_video[busid].probe.bFormatIndex);
switch((g_usbd_video[busid].probe.bFormatIndex))
{
case 1:
{
switch(g_usbd_video[busid].probe.bFrameIndex){
#if VIDEO_MJPEG_bNumFrameDescriptors >= 1
case 1:
os_printf("MJPEG set interface 360p\r\n");
if (g_usbd_video[busid].ops.mjpeg_set_resolution) {
g_usbd_video[busid].ops.mjpeg_set_resolution(1280, 720, VIDEO_MJPEG_Frame1_WIDTH, VIDEO_MJPEG_Frame1_HEIGHT, USBD_VIDEO_OPEN);
}
break;
#endif
#if VIDEO_MJPEG_bNumFrameDescriptors >= 2
case 2:
os_printf("MJPEG set interface 720p\r\n");
if (g_usbd_video[busid].ops.mjpeg_set_resolution) {
g_usbd_video[busid].ops.mjpeg_set_resolution(1280, 720, VIDEO_MJPEG_Frame2_WIDTH, VIDEO_MJPEG_Frame2_HEIGHT, USBD_VIDEO_OPEN);
}
break;
#endif
default:
break;
}
}
break;
case 2:
{
switch(g_usbd_video[busid].probe.bFrameIndex){
#if VIDEO_H26x__bNumFrameDescriptors >= 1
case 1:
os_printf("H264 set interface 720p\r\n");
if (g_usbd_video[busid].ops.h264_set_resolution) {
g_usbd_video[busid].ops.h264_set_resolution((uint32_t)RT_NULL, (uint32_t)RT_NULL, VIDEO_H26x_Frame1_WIDTH, VIDEO_H26x_Frame1_HEIGHT, USBD_VIDEO_OPEN);
}
break;
#endif
#if VIDEO_H26x__bNumFrameDescriptors >= 2
case 2:
os_printf("H264 set interface 1080p\r\n");
if (g_usbd_video[busid].ops.h264_set_resolution) {
g_usbd_video[busid].ops.h264_set_resolution((uint32_t)RT_NULL, (uint32_t)RT_NULL, VIDEO_H26x_Frame2_WIDTH, VIDEO_H26x_Frame2_HEIGHT, USBD_VIDEO_OPEN);
}
break;
#endif
default:
break;
}
}
break;
}
usbd_uvc.open_count = 0;
usbd_uvc.open_count++;
rt_event_send(usbd_uvc.event, EVENT_VIDEO_START | EVENT_VIDEO_DATA);
return 0;
}
static rt_err_t usbd_video_close(rt_uint8_t busid, ufunction_t func)
{
os_printf("usbd video close\r\n");
switch((g_usbd_video[busid].probe.bFormatIndex))
{
case 1:
{
switch(g_usbd_video[busid].probe.bFrameIndex){
#if VIDEO_MJPEG_bNumFrameDescriptors >= 1
case 1:
os_printf("MJPEG set interface 360p\r\n");
if (g_usbd_video[busid].ops.mjpeg_set_resolution) {
g_usbd_video[busid].ops.mjpeg_set_resolution((uint32_t)RT_NULL, (uint32_t)RT_NULL, (uint32_t)RT_NULL, (uint32_t)RT_NULL, USBD_VIDEO_CLOSE);
}
break;
#endif
#if VIDEO_MJPEG_bNumFrameDescriptors >= 2
case 2:
os_printf("MJPEG set interface 720p\r\n");
if (g_usbd_video[busid].ops.mjpeg_set_resolution) {
g_usbd_video[busid].ops.mjpeg_set_resolution((uint32_t)RT_NULL, (uint32_t)RT_NULL, (uint32_t)RT_NULL, (uint32_t)RT_NULL, USBD_VIDEO_CLOSE);
}
break;
#endif
default:
break;
}
}
break;
case 2:
{
switch(g_usbd_video[busid].probe.bFrameIndex){
#if VIDEO_H26x__bNumFrameDescriptors >= 1
case 1:
os_printf("H264 set interface 720p\r\n");
if (g_usbd_video[busid].ops.h264_set_resolution) {
g_usbd_video[busid].ops.h264_set_resolution((uint32_t)RT_NULL, (uint32_t)RT_NULL, (uint32_t)RT_NULL, (uint32_t)RT_NULL, USBD_VIDEO_CLOSE);
}
break;
#endif
#if VIDEO_H26x__bNumFrameDescriptors >= 2
case 2:
os_printf("H264 set interface 1080p\r\n");
if (g_usbd_video[busid].ops.h264_set_resolution) {
g_usbd_video[busid].ops.h264_set_resolution((uint32_t)RT_NULL, (uint32_t)RT_NULL, (uint32_t)RT_NULL, (uint32_t)RT_NULL, USBD_VIDEO_CLOSE);
}
break;
#endif
default:
break;
}
}
break;
}
usbd_uvc.open_count--;
rt_event_send(usbd_uvc.event, EVENT_VIDEO_STOP);
return 0;
}
static void usbd_video_process_unit_info_init(rt_uint8_t busid)
{
g_usbd_video[busid].process_unit_info.wWhiteBalance_Component = 5;
g_usbd_video[busid].process_unit_info.wBacklightCompensation = 0x0004;
g_usbd_video[busid].process_unit_info.wBrightness = 0x0080;
g_usbd_video[busid].process_unit_info.wContrast = 0x0080;
g_usbd_video[busid].process_unit_info.wHue = 0x0080;
g_usbd_video[busid].process_unit_info.wHue_Auto = 0;
g_usbd_video[busid].process_unit_info.wSaturation = 0x0001;
g_usbd_video[busid].process_unit_info.wSharpness = 0x0001;
g_usbd_video[busid].process_unit_info.wGamma = 0x0032;
g_usbd_video[busid].process_unit_info.wGain = 255;
g_usbd_video[busid].process_unit_info.wWhiteBalance_Temprature = 417;
g_usbd_video[busid].process_unit_info.wWhiteBalance_Temprature_Auto = 0;
g_usbd_video[busid].process_unit_info.wWhiteBalance_Component_Auto = 0;
g_usbd_video[busid].process_unit_info.wDigital_Multiplier = 5;
g_usbd_video[busid].process_unit_info.bPowerLineFrequency = 1;
g_usbd_video[busid].process_unit_info.wDigital_Multiplier_Limit = 1;
}
static void usbd_video_probe_and_commit_controls_init(rt_uint8_t busid, rt_uint32_t dwFrameInterval, rt_uint32_t dwMaxVideoFrameSize, rt_uint32_t dwMaxPayloadTransferSize)
{
g_usbd_video[busid].probe.hintUnion.bmHint = 0x01;
g_usbd_video[busid].probe.hintUnion1.bmHint = 0;
g_usbd_video[busid].probe.bFormatIndex = 1;
g_usbd_video[busid].probe.bFrameIndex = 1;
g_usbd_video[busid].probe.dwFrameInterval = dwFrameInterval;
g_usbd_video[busid].probe.wKeyFrameRate = 0;
g_usbd_video[busid].probe.wPFrameRate = 0;
g_usbd_video[busid].probe.wCompQuality = 0;
g_usbd_video[busid].probe.wCompWindowSize = 0;
g_usbd_video[busid].probe.wDelay = 0;
g_usbd_video[busid].probe.dwMaxVideoFrameSize = dwMaxVideoFrameSize;
g_usbd_video[busid].probe.dwMaxPayloadTransferSize = dwMaxPayloadTransferSize;
g_usbd_video[busid].probe.dwClockFrequency = 0;
g_usbd_video[busid].probe.bmFramingInfo = 0;
g_usbd_video[busid].probe.bPreferedVersion = 0;
g_usbd_video[busid].probe.bMinVersion = 0;
g_usbd_video[busid].probe.bMaxVersion = 0;
g_usbd_video[busid].commit.hintUnion.bmHint = 0x01;
g_usbd_video[busid].commit.hintUnion1.bmHint = 0;
g_usbd_video[busid].commit.bFormatIndex = 1;
g_usbd_video[busid].commit.bFrameIndex = 1;
g_usbd_video[busid].commit.dwFrameInterval = dwFrameInterval;
g_usbd_video[busid].commit.wKeyFrameRate = 0;
g_usbd_video[busid].commit.wPFrameRate = 0;
g_usbd_video[busid].commit.wCompQuality = 0;
g_usbd_video[busid].commit.wCompWindowSize = 0;
g_usbd_video[busid].commit.wDelay = 0;
g_usbd_video[busid].commit.dwMaxVideoFrameSize = dwMaxVideoFrameSize;
g_usbd_video[busid].commit.dwMaxPayloadTransferSize = dwMaxPayloadTransferSize;
g_usbd_video[busid].commit.dwClockFrequency = 0;
g_usbd_video[busid].commit.bmFramingInfo = 0;
g_usbd_video[busid].commit.bPreferedVersion = 0;
g_usbd_video[busid].commit.bMinVersion = 0;
g_usbd_video[busid].commit.bMaxVersion = 0;
}
static void usbd_video_init_intf(rt_uint8_t busid, rt_uint32_t dwFrameInterval, rt_uint32_t dwMaxVideoFrameSize, rt_uint32_t dwMaxPayloadTransferSize)
{
g_usbd_video[busid].info[0].bDescriptorSubtype = VIDEO_VC_INPUT_TERMINAL_DESCRIPTOR_SUBTYPE;
g_usbd_video[busid].info[0].bEntityId = 0x01;
g_usbd_video[busid].info[0].wTerminalType = VIDEO_ITT_CAMERA;
g_usbd_video[busid].info[1].bDescriptorSubtype = VIDEO_VC_OUTPUT_TERMINAL_DESCRIPTOR_SUBTYPE;
g_usbd_video[busid].info[1].bEntityId = 0x03;
g_usbd_video[busid].info[1].wTerminalType = 0x00;
g_usbd_video[busid].info[2].bDescriptorSubtype = VIDEO_VC_PROCESSING_UNIT_DESCRIPTOR_SUBTYPE;
g_usbd_video[busid].info[2].bEntityId = 0x02;
g_usbd_video[busid].info[2].wTerminalType = 0x00;
usbd_video_probe_and_commit_controls_init(busid, dwFrameInterval, dwMaxVideoFrameSize, dwMaxPayloadTransferSize);
usbd_video_process_unit_info_init(busid);
}
static rt_err_t _vc_interface_as_handler(ufunction_t func, ureq_t setup)
{
RT_ASSERT(func != RT_NULL);
RT_ASSERT(func->device != RT_NULL);
RT_ASSERT(setup != RT_NULL);
os_printf("_vc_interface_as_handler\n");
rt_uint8_t entity_id = (rt_uint8_t)(setup->wIndex >> 8);
rt_uint8_t busid = 0;
if (entity_id == 0) {
return usbd_video_control_request_handler(busid, func, setup); /* Interface Control Requests */
} else {
return usbd_video_control_unit_terminal_request_handler(busid, func, setup); /* Unit and Terminal Requests */
}
return RT_EOK;
}
static rt_err_t _vs_interface_as_handler(ufunction_t func, ureq_t setup)
{
RT_ASSERT(func != RT_NULL);
RT_ASSERT(func->device != RT_NULL);
RT_ASSERT(setup != RT_NULL);
struct usbd_video_msg msg;
rt_uint8_t control_selector = (rt_uint8_t)(setup->wValue >> 8);
rt_uint8_t busid = 0;
static rt_uint8_t buf[26] __attribute__((aligned(4)));
memset(buf, 0, 26);
os_printf("_vs_interface_as_handler\n");
os_printf("request_type:%x bRequest:%d control_selector:%d\n",(setup->request_type & USB_REQ_TYPE_MASK), setup->bRequest,control_selector);
#if 1
if ((setup->request_type & USB_REQ_TYPE_MASK) == USB_REQ_TYPE_STANDARD)
{
switch (setup->bRequest)
{
case USB_REQ_GET_INTERFACE:
break;
case USB_REQ_SET_INTERFACE:
LOG_D("set interface handler");
if (setup->wValue == 1)
{
usbd_video_open(busid, func);
}
else if (setup->wValue == 0)
{
usbd_video_close(busid, func);
}
break;
default:
LOG_D("unknown uac request 0x%x", setup->bRequest);
return -RT_ERROR;
}
}else{
switch (control_selector) {
case VIDEO_VS_PROBE_CONTROL:
switch (setup->bRequest) {
case VIDEO_REQUEST_SET_CUR:
rt_usbd_ep0_read(func->device, (rt_uint8_t *)&buf, setup->wLength, _ep0_cmd_handler);
msg.flush_info_addr = (rt_uint8_t *)&g_usbd_video[busid].probe;
msg.dma_buff = (rt_uint8_t *)&buf;
msg.copy_len = 18;
msg.control_selector = control_selector;
rt_usbd_video_send_msg(&msg);
os_printf("SET CUR FormatIndex:%x FrameIndex:%x buf[2]:%x %x\n",g_usbd_video[busid].probe.bFormatIndex,g_usbd_video[busid].probe.bFrameIndex,buf[2],buf[3]);
break;
case VIDEO_REQUEST_GET_CUR:
rt_usbd_ep0_write(func->device, (rt_uint8_t *)&g_usbd_video[busid].probe, setup->wLength);
//os_printf("GET CUR payloadsize:%d\n",g_usbd_video[busid].probe.dwMaxPayloadTransferSize);
break;
case VIDEO_REQUEST_GET_MIN:
case VIDEO_REQUEST_GET_MAX:
case VIDEO_REQUEST_GET_RES:
case VIDEO_REQUEST_GET_DEF:
rt_usbd_ep0_write(func->device, (rt_uint8_t *)&g_usbd_video[busid].probe, setup->wLength);
//os_printf("GET = payloadsize:%d\n",g_usbd_video[busid].probe.dwMaxPayloadTransferSize);
break;
case VIDEO_REQUEST_GET_LEN:
buf[0] = sizeof(struct video_probe_and_commit_controls);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)buf, 1);
break;
case VIDEO_REQUEST_GET_INFO:;
buf[0] = 0x03;
rt_usbd_ep0_write(func->device, (rt_uint8_t *)buf, 1);
break;
default:
LOG_D("Unhandled Video Class bRequest 0x%02x\r\n", setup->bRequest);
return -1;
}
break;
case VIDEO_VS_COMMIT_CONTROL:
switch (setup->bRequest) {
case VIDEO_REQUEST_SET_CUR:
rt_usbd_ep0_read(func->device, (rt_uint8_t *)&g_usbd_video[busid].commit, setup->wLength, _ep0_cmd_handler);
msg.flush_info_addr = (rt_uint8_t *)RT_NULL;
msg.dma_buff = (rt_uint8_t *)RT_NULL;
msg.copy_len = 0;
msg.control_selector = control_selector;
rt_usbd_video_send_msg(&msg);
break;
case VIDEO_REQUEST_GET_CUR:
rt_usbd_ep0_write(func->device, (rt_uint8_t *)&g_usbd_video[busid].commit, setup->wLength);
break;
case VIDEO_REQUEST_GET_MIN:
case VIDEO_REQUEST_GET_MAX:
case VIDEO_REQUEST_GET_RES:
case VIDEO_REQUEST_GET_DEF:
rt_usbd_ep0_write(func->device, (rt_uint8_t *)&g_usbd_video[busid].commit, setup->wLength);
break;
case VIDEO_REQUEST_GET_LEN:
buf[0] = sizeof(struct video_probe_and_commit_controls);
rt_usbd_ep0_write(func->device, (rt_uint8_t *)buf, 1);
break;
case VIDEO_REQUEST_GET_INFO:;
buf[0] = 0x03;
rt_usbd_ep0_write(func->device, (rt_uint8_t *)buf, 1);
break;
default:
LOG_D("Unhandled Video Class bRequest 0x%02x\r\n", setup->bRequest);
return -1;
}
break;
case VIDEO_VS_STREAM_ERROR_CODE_CONTROL:
switch (setup->bRequest) {
case VIDEO_REQUEST_GET_CUR:
buf[0] = g_usbd_video[busid].error_code;
rt_usbd_ep0_write(func->device, (rt_uint8_t *)buf, 1);
break;
case VIDEO_REQUEST_GET_INFO:
buf[0] = 0x01;
rt_usbd_ep0_write(func->device, (rt_uint8_t *)buf, 1);
break;
default:
LOG_D("Unhandled Video Class bRequest 0x%02x\r\n", setup->bRequest);
return -1;
}
break;
default:
break;
}
}
#endif
return RT_EOK;
}
static rt_err_t _ep_data_handler(ufunction_t func, rt_size_t size)
{
RT_ASSERT(func != RT_NULL);
rt_event_send(usbd_uvc.event, EVENT_VIDEO_DATA);
return RT_EOK;
}
static rt_err_t _function_enable(ufunction_t func)
{
RT_ASSERT(func != RT_NULL);
rt_mq_init(&g_usbd_video[0].video_mq, "video_message", RT_NULL, 32, 16, RT_IPC_FLAG_FIFO);
os_printf("uvc function enable");
return RT_EOK;
}
static rt_err_t _function_disable(ufunction_t func)
{
RT_ASSERT(func != RT_NULL);
rt_mq_detach(&g_usbd_video[0].video_mq);
os_printf("uvc function disable");
return RT_EOK;
}
static struct ufunction_ops ops =
{
_function_enable,
_function_disable,
RT_NULL,
};
/**
* This function will configure uvc descriptor.
*
* @param comm the communication interface number.
* @param data the data interface number.
*
* @return RT_EOK on successful.
*/
static rt_err_t _uvc_descriptor_config(struct uvc_vc_noep_descriptor *vc,
rt_uint8_t cintf_nr, struct uvc_vs_noep_descriptor *vs, rt_uint8_t sintf_nr)
{
vc->hdr_desc.baInterfaceNr[0] = sintf_nr;
#ifdef RT_USB_DEVICE_COMPOSITE
vc->iad_desc.bFirstInterface = cintf_nr;
#endif
return RT_EOK;
}
static void usbd_uvc_entry(void *parameter)
{
rt_uint32_t e;
rt_uint32_t flen = 0;
rt_uint32_t node_len = 0;
rt_uint32_t out_len;
rt_uint32_t packets;
rt_uint32_t timeout = 0;
rt_uint32_t index = 0;
rt_uint8_t *frame_buf_addr = NULL;
struct framebuff *get_f = NULL;
struct ufunction *func = (struct ufunction *)parameter;
static rt_uint8_t uvc_header[2] = { 0x02, 0x80 };
usbd_uvc.buffer = os_malloc(VIDEO_BUFFER_SZ);
if (usbd_uvc.buffer == RT_NULL)
{
LOG_E("malloc failed\r\n");
goto __exit;
}
struct msi *s = msi_new(R_USBD_VIDEO, 2, NULL);
if(s == RT_NULL)
{
LOG_D("open stream failed\n");
goto __exit;
}
usbd_uvc.recv_msi = s;
while(1)
{
if (rt_event_recv(usbd_uvc.event, EVENT_VIDEO_START | EVENT_VIDEO_STOP,
RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR,
1000, &e) != RT_EOK)
{
printf("usbd video wait evevnt\r\n");
continue;
}
if (e & EVENT_VIDEO_START)
{
}else
{
continue;
}
LOG_D("video display start\r\n");
while(1){
if (get_f == NULL)
{
get_f = msi_get_fb(s, 0);
}
flen = 0;
if(get_f)
{
// printf("U len : %d type:%d", get_f->len, get_f->stype);
flen = get_f->len;
node_len = get_f->len;
frame_buf_addr = get_f->data;
packets = 0;
out_len = 0;
while(flen)
{
if (rt_event_recv(usbd_uvc.event, EVENT_VIDEO_DATA | EVENT_VIDEO_STOP,
RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR,
1000, &e) != RT_EOK)
{
//一般为上位机软件视频处于暂停状态（主机未发出IN请求，从机等待DMA中断）
os_printf(KERN_DEBUG"uvc_video_thread: recv event timeout\n");
}
if (e & EVENT_VIDEO_STOP)
{
_os_printf("P");
flen = 0;
index = 0;
timeout = 0;
break;
}
if (e & EVENT_VIDEO_DATA)
{
//printf("D");
if(flen > (VIDEO_PACKET_SIZE-sizeof(uvc_header)))
{
out_len = usbd_video_mjpeg_payload_header_fill((rt_uint8_t *)(frame_buf_addr + index), (VIDEO_PACKET_SIZE-sizeof(uvc_header)), usbd_uvc.buffer, (rt_uint8_t*)&uvc_header,sizeof(uvc_header));
//os_printf("1 out len:%d buffer:%x [0]:%x [1]:%x [2]:%x [3]:%x\n",out_len,frame_buf_addr + index, usbd_uvc.buffer[0], usbd_uvc.buffer[1],usbd_uvc.buffer[2],usbd_uvc.buffer[3]);
usbd_uvc.ep->request.buffer = usbd_uvc.buffer;
usbd_uvc.ep->request.size = VIDEO_PACKET_SIZE;
usbd_uvc.ep->request.req_type = UIO_REQUEST_WRITE;
rt_usbd_io_request(func->device, usbd_uvc.ep, &usbd_uvc.ep->request);
flen -= (VIDEO_PACKET_SIZE-sizeof(uvc_header));
index += (VIDEO_PACKET_SIZE-sizeof(uvc_header));
}else{
out_len = usbd_video_mjpeg_payload_header_fill((rt_uint8_t *)(frame_buf_addr + index), flen, usbd_uvc.buffer, (rt_uint8_t*)&uvc_header,sizeof(uvc_header));
// os_printf("2 out len:%d buffer:%x [0]:%x [1]:%x [2]:%x [3]:%x\n",out_len,frame_buf_addr + index, usbd_uvc.buffer[0], usbd_uvc.buffer[1],usbd_uvc.buffer[2],usbd_uvc.buffer[3]);
usbd_uvc.ep->request.buffer = usbd_uvc.buffer;
usbd_uvc.ep->request.size = out_len;
usbd_uvc.ep->request.req_type = UIO_REQUEST_WRITE;
rt_usbd_io_request(func->device, usbd_uvc.ep, &usbd_uvc.ep->request);
flen = 0;
index = 0;
break;
}
}
}
if(get_f)
{
msi_delete_fb(NULL, get_f);
get_f = NULL;
}
timeout = 0;
}
else
{
timeout++;
_os_printf("n");
os_sleep_ms(5);
if(timeout > 100)
{
//通知设置分辨率的线程，可重新打开硬件msi
s->enable = 0;
rt_event_send(usbd_uvc.event, EVENT_VIDEO_COMPLITE);
timeout = 0;
break;
}
}
}
}
__exit:
if (usbd_uvc.buffer)
{
os_free(usbd_uvc.buffer);
}
if (s)
{
usbd_uvc.recv_msi = RT_NULL;
msi_destroy(s);
}
}
/**
* This function will create a uvc function instance.
*
* @param device the usb device object.
*
* @return RT_EOK on successful.
*/
static ufunction_t rt_usbd_function_uvc_device_create(udevice_t device)
{
ufunction_t func;
uintf_t intf_vc, intf_vs;
ualtsetting_t setting_vs_noep;
ualtsetting_t setting_vc, setting_vs_ep;
struct uvc_vs_ep_descriptor *vs_ep_desc_t;
/* parameter check */
RT_ASSERT(device != RT_NULL);
#ifdef RT_USB_DEVICE_COMPOSITE
rt_usbd_device_set_interface_string(device, UVC_INTF_STR_INDEX, _ustring[2]);
#else
/* set usb device string description */
rt_usbd_device_set_string(device, _ustring);
#endif
/* create a uac function */
func = rt_usbd_function_new(device, &dev_desc, &ops);
//not support HS
//rt_usbd_device_set_qualifier(device, &dev_qualifier);
usbd_uvc_init(func);
/* create interface */
intf_vc = rt_usbd_interface_new(device, _vc_interface_as_handler); //配置接口handler
intf_vs = rt_usbd_interface_new(device, _vs_interface_as_handler); //配置接口handler
// os_printf("===sizeof:%d %d %d\n",sizeof(struct uvc_vc_noep_descriptor),sizeof(struct uvc_vs_noep_descriptor),sizeof(struct uvc_vs_ep_descriptor));
/* create alternate setting */
setting_vc = rt_usbd_altsetting_new(sizeof(struct uvc_vc_noep_descriptor));
setting_vs_noep = rt_usbd_altsetting_new(sizeof(struct uvc_vs_noep_descriptor));
setting_vs_ep = rt_usbd_altsetting_new(sizeof(struct uvc_vs_ep_descriptor));
/* config desc in alternate setting */
rt_usbd_altsetting_config_descriptor(setting_vc, &vc_desc,
(rt_off_t) & ((struct uvc_vc_noep_descriptor *)0)->intf_desc);
// os_printf("intf_desc[0]:%x\n",&(vc_desc.intf_desc));
rt_usbd_altsetting_config_descriptor(setting_vs_noep, &vs_noep_desc,
(rt_off_t) & ((struct uvc_vs_noep_descriptor *)0)->intf_desc);
rt_usbd_altsetting_config_descriptor(setting_vs_ep, &vs_ep_desc,
(rt_off_t) & ((struct uvc_vs_ep_descriptor *)0)->intf_desc);
/* configure the uac interface descriptor */
_uvc_descriptor_config(setting_vc->desc, intf_vc->intf_num, setting_vs_noep->desc, intf_vs->intf_num);
//_uac_samplerate_config(setting_vs_ep->desc, AUDIO_SAMPLERATE);
/* create endpoint */
vs_ep_desc_t = (struct uvc_vs_ep_descriptor *)setting_vs_ep->desc;
usbd_uvc.ep = rt_usbd_endpoint_new(&vs_ep_desc_t->ep_desc, _ep_data_handler); //配置端点handler
/* add the endpoint to the alternate setting */
rt_usbd_altsetting_add_endpoint(setting_vs_ep, usbd_uvc.ep);
/* add the alternate setting to the interface, then set default setting of the interface */
rt_usbd_interface_add_altsetting(intf_vc, setting_vc);
rt_usbd_set_altsetting(intf_vc, 0);
rt_usbd_interface_add_altsetting(intf_vs, setting_vs_noep);
rt_usbd_interface_add_altsetting(intf_vs, setting_vs_ep);
rt_usbd_set_altsetting(intf_vs, 0);
/* add the interface to the uac function */
rt_usbd_function_add_interface(func, intf_vc);
rt_usbd_function_add_interface(func, intf_vs);
return func;
}
static void usbd_video_mjpeg_set_resolution(uint32_t in_weight, uint32_t in_height, uint32_t out_weight, uint32_t out_height, uint32_t en)
{
rt_uint32_t e;
if(en)
{
if (usbd_uvc.cur_msi) {
usbd_uvc.recv_msi->enable = 0;
msi_put(usbd_uvc.cur_msi);
//确保所有fb都被释放
struct framebuff *fb = NULL;
do{
fb = msi_get_fb(usbd_uvc.cur_msi, 0);
if(fb)
msi_delete_fb(NULL, fb);
}while(fb != NULL);
msi_del_output(usbd_uvc.cur_msi, NULL, R_USBD_VIDEO);
usbd_uvc.cur_msi = RT_NULL;
os_sleep_ms(100); //等待 auto_h264 / auto_jpg work 完全停止
}
//等待UVC接收msi完全释放fb
if(rt_event_recv(usbd_uvc.event, EVENT_VIDEO_COMPLITE, RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR, 5000, &e) != RT_EOK) {
//此处有可能触发超时，上位机重新打开摄像头可以恢复
os_printf("%s %d timeout\n",__FUNCTION__,__LINE__);
return;
}
if((in_weight != out_weight) || (in_height != out_height))
{
usbd_uvc.cur_msi = msi_find(AUTO_JPG,1); //VPP DATA1 按比例裁剪后的分辨率（默认1/2）
msi_do_cmd(usbd_uvc.cur_msi, MSI_CMD_AUTO_JPG, MSI_AUTO_JPG_SWITCH_ENCODE_SRC, VPP_DATA1);
}
else
{
usbd_uvc.cur_msi = msi_find(AUTO_JPG,1); //VPP DATA0 摄像头原分辨率
msi_do_cmd(usbd_uvc.cur_msi, MSI_CMD_AUTO_JPG, MSI_AUTO_JPG_SWITCH_ENCODE_SRC, VPP_DATA0);
}
usbd_uvc.recv_msi->enable = 1;
msi_add_output(usbd_uvc.cur_msi, NULL, R_USBD_VIDEO);
}
else
{
usbd_uvc.recv_msi->enable = 0;
if (usbd_uvc.cur_msi) {
msi_put(usbd_uvc.cur_msi);
//确保所有fb都被释放
struct framebuff *fb = NULL;
do{
fb = msi_get_fb(usbd_uvc.cur_msi, 0);
if(fb)
msi_delete_fb(NULL, fb);
}while(fb != NULL);
msi_del_output(usbd_uvc.cur_msi, NULL, R_USBD_VIDEO);
}
usbd_uvc.cur_msi = RT_NULL;
}
}
static void usbd_video_h264_set_resolution(uint32_t in_weight, uint32_t in_height, uint32_t out_weight, uint32_t out_height, uint32_t en)
{
rt_uint32_t e;
if(en)
{
if (usbd_uvc.cur_msi) {
usbd_uvc.recv_msi->enable = 0;
msi_put(usbd_uvc.cur_msi);
//确保所有fb都被释放
struct framebuff *fb = NULL;
do{
fb = msi_get_fb(usbd_uvc.cur_msi, 0);
if(fb)
msi_delete_fb(NULL, fb);
}while(fb != NULL);
msi_del_output(usbd_uvc.cur_msi, NULL, R_USBD_VIDEO);
usbd_uvc.cur_msi = RT_NULL;
os_sleep_ms(100); //等待 auto_h264 / auto_jpg work 完全停止
}
//等待UVC接收msi完全释放fb
if(rt_event_recv(usbd_uvc.event, EVENT_VIDEO_COMPLITE, RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR, 5000, &e) != RT_EOK) {
//此处有可能触发超时，上位机重新打开摄像头可以恢复
os_printf("%s %d timeout\n",__FUNCTION__,__LINE__);
return;
}
/* 此处可添加 H264 分辨率切换代码
...
*/
usbd_uvc.cur_msi = msi_find(AUTO_H264, 1); //VPP DATA0 摄像头原分辨率
usbd_uvc.recv_msi->enable = 1;
msi_add_output(usbd_uvc.cur_msi, NULL, R_USBD_VIDEO);
}
else
{
usbd_uvc.recv_msi->enable = 0;
if (usbd_uvc.cur_msi) {
msi_put(usbd_uvc.cur_msi);
//确保所有fb都被释放
struct framebuff *fb = NULL;
do{
fb = msi_get_fb(usbd_uvc.cur_msi, 0);
if(fb)
msi_delete_fb(NULL, fb);
}while(fb != NULL);
msi_del_output(usbd_uvc.cur_msi, NULL, R_USBD_VIDEO);
}
usbd_uvc.cur_msi = RT_NULL;
}
}
static rt_bool_t usbd_uvc_init(struct ufunction *func)
{
rt_uint8_t busid = 0;
rt_thread_t usbd_uvc_thread;
g_usbd_video[busid].ops.mjpeg_set_resolution = usbd_video_mjpeg_set_resolution;
g_usbd_video[busid].ops.h264_set_resolution = usbd_video_h264_set_resolution;
usbd_uvc.cur_msi = RT_NULL;
usbd_uvc.event = rt_event_create("usbd_uvc_event", RT_IPC_FLAG_FIFO);
//保证第一次能够成功打开硬件
rt_event_send(usbd_uvc.event, EVENT_VIDEO_COMPLITE);
usbd_uvc_thread = rt_thread_create("usbd_uvc_thread",
usbd_uvc_entry, func,
1024,
OS_TASK_PRIORITY_NORMAL, 10);
if(usbd_uvc_thread != RT_NULL)
rt_thread_startup(usbd_uvc_thread);
usbd_uvc.thread = usbd_uvc_thread;
return RT_EOK;
}
static void rt_usbd_function_uvc_device_delete()
{
}
/*
* register uvc class
*/
static struct udclass uvc_device_class =
{
.rt_usbd_function_create = rt_usbd_function_uvc_device_create,
.rt_usbd_function_delete = rt_usbd_function_uvc_device_delete,
};
int rt_usbd_uvc_device_class_register(rt_uint32_t dev_id)
{
rt_usbd_class_register(&uvc_device_class, dev_id);
usbd_video_init_intf(0, INTERVAL, MAX_FRAME_SIZE(1920, 1080), MAX_PAYLOAD_SIZE);
return 0;
}
#endif
Reference in New Issue Copy Permalink