| // Copyright 2018 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include <ddk/debug.h> |
| #include <ddk/protocol/usb.h> |
| #include <fbl/vector.h> |
| #include <stdlib.h> |
| #include <usb/usb.h> |
| #include <zircon/hw/usb/video.h> |
| |
| #include "garnet/drivers/usb_video/usb-video-stream.h" |
| #include "garnet/drivers/usb_video/uvc_format.h" |
| |
| namespace video { |
| namespace usb { |
| |
| // 8 bits for each RGB. |
| static constexpr uint32_t MJPEG_BITS_PER_PIXEL = 24; |
| static constexpr uint32_t NANOSECS_IN_SEC = 1e9; |
| |
| UvcPixelFormat guid_to_pixel_format(uint8_t guid[GUID_LENGTH]) { |
| struct { |
| uint8_t guid[GUID_LENGTH]; |
| UvcPixelFormat pixel_format; |
| } GUID_LUT[] = { |
| {USB_VIDEO_GUID_YUY2_VALUE, UvcPixelFormat::YUY2}, |
| {USB_VIDEO_GUID_NV12_VALUE, UvcPixelFormat::NV12}, |
| {USB_VIDEO_GUID_M420_VALUE, UvcPixelFormat::M420}, |
| {USB_VIDEO_GUID_I420_VALUE, UvcPixelFormat::I420}, |
| }; |
| |
| for (const auto& g : GUID_LUT) { |
| if (memcmp(g.guid, guid, GUID_LENGTH) == 0) { |
| return g.pixel_format; |
| } |
| } |
| return UvcPixelFormat::INVALID; |
| } |
| |
| fuchsia::camera::VideoFormat ToFidl(const UvcFormat& format_in) { |
| fuchsia::camera::VideoFormat ret = { |
| .format.width = format_in.width, |
| .format.height = format_in.height, |
| .format.layers = 1, |
| // The frame descriptor frame interval is expressed in 100ns units. |
| // e.g. a frame interval of 333333 is equivalent to 30fps (1e7 / 333333). |
| .rate.frames_per_sec_numerator = |
| NANOSECS_IN_SEC / 100, // static_cast<uint32_t>(1e7), |
| .rate.frames_per_sec_denominator = format_in.default_frame_interval}; |
| ret.format.planes[0].bytes_per_row = format_in.stride; |
| // Convert Pixel Format: |
| switch (format_in.pixel_format) { |
| case UvcPixelFormat::BGRA32: |
| ret.format.pixel_format.type = fuchsia::sysmem::PixelFormatType::BGRA32; |
| break; |
| case UvcPixelFormat::I420: |
| ret.format.pixel_format.type = fuchsia::sysmem::PixelFormatType::I420; |
| break; |
| case UvcPixelFormat::M420: |
| ret.format.pixel_format.type = fuchsia::sysmem::PixelFormatType::M420; |
| break; |
| case UvcPixelFormat::NV12: |
| ret.format.pixel_format.type = fuchsia::sysmem::PixelFormatType::NV12; |
| break; |
| case UvcPixelFormat::YUY2: |
| ret.format.pixel_format.type = fuchsia::sysmem::PixelFormatType::YUY2; |
| break; |
| case UvcPixelFormat::MJPEG: |
| ret.format.pixel_format.type = fuchsia::sysmem::PixelFormatType::MJPEG; |
| break; |
| default: |
| ret.format.pixel_format.type = fuchsia::sysmem::PixelFormatType::INVALID; |
| } |
| return ret; |
| } |
| |
| bool Compare(const fuchsia::camera::VideoFormat& vf, const UvcFormat& uf) { |
| fuchsia::camera::VideoFormat uvf = ToFidl(uf); |
| |
| bool has_equal_frame_rate = |
| (static_cast<uint64_t>(vf.rate.frames_per_sec_numerator) * |
| uvf.rate.frames_per_sec_denominator) == |
| (static_cast<uint64_t>(vf.rate.frames_per_sec_numerator) * |
| uvf.rate.frames_per_sec_denominator); |
| |
| for (uint32_t i = 0; i < uvf.format.planes.size(); i++) { |
| if (vf.format.planes[i].byte_offset != uvf.format.planes[i].byte_offset || |
| vf.format.planes[i].bytes_per_row != |
| uvf.format.planes[i].bytes_per_row) { |
| return false; |
| } |
| } |
| |
| if (fidl::Equals(vf.format.pixel_format, uvf.format.pixel_format) && |
| vf.format.width == uvf.format.width && |
| vf.format.height == uvf.format.height && has_equal_frame_rate) { |
| return true; |
| } |
| return false; |
| } |
| |
| // Parses the payload format descriptor and any corresponding frame descriptors. |
| // The result is stored in out_format. |
| zx_status_t UvcFormatList::ParseUsbDescriptor( |
| usb_video_vc_desc_header* format_desc, usb_desc_iter_t* iter) { |
| uint8_t want_frame_type = 0; |
| int want_num_frame_descs = 0; |
| |
| // These fields are shared between all frame descriptions: |
| uint8_t format_index, default_frame_index; |
| UvcPixelFormat pixel_format; |
| uint8_t bits_per_pixel; |
| |
| switch (format_desc->bDescriptorSubtype) { |
| case USB_VIDEO_VS_FORMAT_UNCOMPRESSED: { |
| usb_video_vs_uncompressed_format_desc* uncompressed_desc = |
| (usb_video_vs_uncompressed_format_desc*)format_desc; |
| zxlogf(TRACE, |
| "USB_VIDEO_VS_FORMAT_UNCOMPRESSED bNumFrameDescriptors %u " |
| "bBitsPerPixel %u\n", |
| uncompressed_desc->bNumFrameDescriptors, |
| uncompressed_desc->bBitsPerPixel); |
| |
| want_frame_type = USB_VIDEO_VS_FRAME_UNCOMPRESSED; |
| format_index = uncompressed_desc->bFormatIndex; |
| pixel_format = guid_to_pixel_format(uncompressed_desc->guidFormat); |
| bits_per_pixel = uncompressed_desc->bBitsPerPixel; |
| want_num_frame_descs = uncompressed_desc->bNumFrameDescriptors; |
| default_frame_index = uncompressed_desc->bDefaultFrameIndex; |
| break; |
| } |
| case USB_VIDEO_VS_FORMAT_MJPEG: { |
| usb_video_vs_mjpeg_format_desc* mjpeg_desc = |
| (usb_video_vs_mjpeg_format_desc*)format_desc; |
| zxlogf(TRACE, |
| "USB_VIDEO_VS_FORMAT_MJPEG bNumFrameDescriptors %u bmFlags %d\n", |
| mjpeg_desc->bNumFrameDescriptors, mjpeg_desc->bmFlags); |
| |
| want_frame_type = USB_VIDEO_VS_FRAME_MJPEG; |
| format_index = mjpeg_desc->bFormatIndex; |
| pixel_format = UvcPixelFormat::MJPEG; |
| bits_per_pixel = MJPEG_BITS_PER_PIXEL; |
| want_num_frame_descs = mjpeg_desc->bNumFrameDescriptors; |
| default_frame_index = mjpeg_desc->bDefaultFrameIndex; |
| break; |
| } |
| // TODO(jocelyndang): handle other formats. |
| default: |
| zxlogf(ERROR, "unsupported format bDescriptorSubtype %u\n", |
| format_desc->bDescriptorSubtype); |
| return ZX_ERR_NOT_SUPPORTED; |
| } |
| |
| fbl::AllocChecker ac; |
| // TODO(garratt): add case for format with no frame_desc |
| formats_.reserve(formats_.size() + want_num_frame_descs, &ac); |
| if (!ac.check()) { |
| return ZX_ERR_NO_MEMORY; |
| } |
| |
| // The format descriptor mut be immediately followed by its frame descriptors, |
| // if any. |
| int num_frame_descs_found = 0; |
| |
| usb_descriptor_header_t* header; |
| while ((header = usb_desc_iter_peek(iter)) != NULL && |
| header->bDescriptorType == USB_VIDEO_CS_INTERFACE && |
| num_frame_descs_found < want_num_frame_descs) { |
| usb_video_vc_desc_header* format_desc = (usb_video_vc_desc_header*)header; |
| if (format_desc->bDescriptorSubtype != want_frame_type) { |
| break; |
| } |
| |
| switch (format_desc->bDescriptorSubtype) { |
| case USB_VIDEO_VS_FRAME_UNCOMPRESSED: |
| case USB_VIDEO_VS_FRAME_MJPEG: { |
| usb_video_vs_frame_desc* desc = (usb_video_vs_frame_desc*)header; |
| |
| // Intervals are specified in 100 ns units. |
| double framesPerSec = 1 / (desc->dwDefaultFrameInterval * 100 / 1e9); |
| zxlogf( |
| TRACE, "%s (%u x %u) %.2f frames / sec\n", |
| format_desc->bDescriptorSubtype == USB_VIDEO_VS_FRAME_UNCOMPRESSED |
| ? "USB_VIDEO_VS_FRAME_UNCOMPRESSED" |
| : "USB_VIDEO_VS_FRAME_MJPEG", |
| desc->wWidth, desc->wHeight, framesPerSec); |
| |
| video::usb::UvcFormat frame_desc = { |
| .format_index = format_index, |
| .pixel_format = pixel_format, |
| .bits_per_pixel = bits_per_pixel, |
| .default_frame_index = default_frame_index, |
| .frame_index = desc->bFrameIndex, |
| .default_frame_interval = desc->dwDefaultFrameInterval, |
| .width = desc->wWidth, |
| .height = desc->wHeight, |
| .stride = desc->dwMaxVideoFrameBufferSize / desc->wHeight}; |
| formats_.push_back(frame_desc); |
| } break; |
| default: |
| zxlogf(ERROR, "unhandled frame type: %u\n", |
| format_desc->bDescriptorSubtype); |
| return ZX_ERR_NOT_SUPPORTED; |
| } |
| header = usb_desc_iter_next(iter); |
| num_frame_descs_found++; |
| } |
| if (num_frame_descs_found != want_num_frame_descs) { |
| zxlogf(ERROR, "missing %u frame descriptors\n", |
| want_num_frame_descs - num_frame_descs_found); |
| return ZX_ERR_INTERNAL; |
| } |
| // TODO(jocelyndang); parse still image frame and color matching descriptors. |
| return ZX_OK; |
| } |
| |
| } // namespace usb |
| } // namespace video |
