src/camera/bin/usb_device/uvc_hack.cc

// Copyright 2020 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 "src/camera/bin/usb_device/uvc_hack.h"

namespace camera {

// Client buffers are supporting NV12
void UvcHackGetClientBufferImageFormatConstraints(
    fuchsia::sysmem2::ImageFormatConstraints* image_format_constraints) {
  auto& ifc = *image_format_constraints;
  ifc.set_pixel_format(kUvcHackClientPixelFormat);
  ifc.mutable_color_spaces()->emplace_back(kUvcHackClientColorSpace);
  ifc.set_min_size(
      fuchsia::math::SizeU{.width = kUvcHackClientCodedWidth, .height = kUvcHackClientCodedHeight});
  ifc.set_max_size(
      fuchsia::math::SizeU{.width = kUvcHackClientCodedWidth, .height = kUvcHackClientCodedHeight});
  ifc.set_min_bytes_per_row(kUvcHackClientBytesPerRow);
  ifc.set_max_bytes_per_row(kUvcHackClientBytesPerRow);
  ifc.set_max_width_times_height(kUvcHackClientCodedWidth * kUvcHackClientCodedHeight);
  ifc.set_size_alignment(fuchsia::math::SizeU{.width = kUvcHackClientCodedWidthDivisor,
                                              .height = kUvcHackClientCodedHeightDivisor});
  ifc.set_bytes_per_row_divisor(kUvcHackClientBytesPerRowDivisor);
  ifc.set_start_offset_divisor(kUvcHackClientStartOffsetDivisor);
  ifc.set_display_rect_alignment(fuchsia::math::SizeU{
      .width = kUvcHackClientDisplayWidthDivisor, .height = kUvcHackClientDisplayHeightDivisor});
  ifc.set_required_min_size(
      fuchsia::math::SizeU{.width = kUvcHackClientCodedWidth, .height = kUvcHackClientCodedHeight});
  ifc.set_required_max_size(
      fuchsia::math::SizeU{.width = kUvcHackClientCodedWidth, .height = kUvcHackClientCodedHeight});
}

// Client buffers are supporting NV12
void UvcHackGetClientBufferCollectionConstraints(
    fuchsia::sysmem2::BufferCollectionConstraints* buffer_collection_constraints) {
  auto& constraints = *buffer_collection_constraints;
  constraints.mutable_usage()->set_cpu(fuchsia::sysmem2::CPU_USAGE_READ |
                                       fuchsia::sysmem2::CPU_USAGE_WRITE);
  constraints.set_min_buffer_count_for_camping(kUvcHackClientMinBufferCountForCamping);
  constraints.set_min_buffer_count_for_dedicated_slack(
      kUvcHackClientMinBufferCountForDedicatedSlack);
  constraints.set_min_buffer_count_for_shared_slack(kUvcHackClientMinBufferCountForSharedSlack);
  constraints.set_min_buffer_count(kUvcHackClientMinBufferCount);
  constraints.set_max_buffer_count(kUvcHackClientMaxBufferCount);
  auto& bmc = *constraints.mutable_buffer_memory_constraints();
  bmc.set_ram_domain_supported(true);
  bmc.set_cpu_domain_supported(true);
  auto& ifc = constraints.mutable_image_format_constraints()->emplace_back();
  UvcHackGetClientBufferImageFormatConstraints(&ifc);
}

// Client buffers are supporting NV12
void UvcHackGetClientStreamProperties(fuchsia::camera3::StreamProperties* stream_properties) {
  stream_properties->image_format.pixel_format.type = kUvcHackClientPixelFormatType;
  stream_properties->image_format.coded_width = kUvcHackClientCodedWidth;
  stream_properties->image_format.coded_height = kUvcHackClientCodedHeight;
  stream_properties->image_format.bytes_per_row = kUvcHackClientBytesPerRow;
  stream_properties->image_format.display_width = kUvcHackClientDisplayWidth;
  stream_properties->image_format.display_height = kUvcHackClientDisplayHeight;
  stream_properties->image_format.layers = kUvcHackClientLayers;
  stream_properties->image_format.color_space.type = kUvcHackClientColorSpaceType;
  stream_properties->frame_rate.numerator = kUvcHackFrameRateNumerator;
  stream_properties->frame_rate.denominator = kUvcHackFrameRateDenominator;
  stream_properties->supports_crop_region = false;
}

// Client buffers are supporting NV12
void UvcHackGetClientStreamProperties2(fuchsia::camera3::StreamProperties2* stream_properties) {
  stream_properties->mutable_image_format()->pixel_format.type = kUvcHackClientPixelFormatType;
  stream_properties->mutable_image_format()->coded_width = kUvcHackClientCodedWidth;
  stream_properties->mutable_image_format()->coded_height = kUvcHackClientCodedHeight;
  stream_properties->mutable_image_format()->bytes_per_row = kUvcHackClientBytesPerRow;
  stream_properties->mutable_image_format()->display_width = kUvcHackClientDisplayWidth;
  stream_properties->mutable_image_format()->display_height = kUvcHackClientDisplayHeight;
  stream_properties->mutable_image_format()->layers = kUvcHackClientLayers;
  stream_properties->mutable_image_format()->color_space.type = kUvcHackClientColorSpaceType;
  stream_properties->mutable_frame_rate()->numerator = kUvcHackFrameRateNumerator;
  stream_properties->mutable_frame_rate()->denominator = kUvcHackFrameRateDenominator;
  *(stream_properties->mutable_supports_crop_region()) = false;
  {
    fuchsia::math::Size resolution;
    resolution.width = kUvcHackClientCodedWidth;
    resolution.height = kUvcHackClientCodedHeight;
    stream_properties->mutable_supported_resolutions()->push_back(std::move(resolution));
  }
}

// Server buffers are supporting YUY2 (a.k.a. YUYV).
void UvcHackGetServerFrameRate(fuchsia::camera::FrameRate* frame_rate) {
  frame_rate->frames_per_sec_numerator = kUvcHackFrameRateNumerator;
  frame_rate->frames_per_sec_denominator = kUvcHackFrameRateDenominator;
}

// Server buffers are supporting YUY2 (a.k.a. YUYV).
void UvcHackGetServerBufferVideoFormat(fuchsia::camera::VideoFormat* video_format) {
  video_format->format.width = kUvcHackDriverWidth;
  video_format->format.height = kUvcHackDriverHeight;
  video_format->format.layers = kUvcHackDriverLayers;
  video_format->format.pixel_format.type = kUvcHackDriverPixelFormatType;
  video_format->format.pixel_format.has_format_modifier = false;
  video_format->format.color_space.type = kUvcHackDriverColorSpaceType;
  video_format->format.planes[0].byte_offset = 0;
  video_format->format.planes[0].bytes_per_row = kUvcHackDriverBytesPerRow;
  UvcHackGetServerFrameRate(&video_format->rate);
}

// Warning! Grotesquely hard coded for YUY2 server side & NV12 client side.
//
// TODO(ernesthua) - Replace this with libyuv!
void UvcHackConvertYUY2ToNV12(uint8_t* client_frame, const uint8_t* driver_frame) {
  ZX_ASSERT(kUvcHackClientPixelFormatType == fuchsia::sysmem::PixelFormatType::NV12);
  ZX_ASSERT(kUvcHackDriverPixelFormat == fuchsia::images2::PixelFormat::YUY2);

  ZX_ASSERT(kUvcHackClientCodedWidth == kUvcHackWidth);
  ZX_ASSERT(kUvcHackClientCodedHeight == kUvcHackHeight);
  ZX_ASSERT(kUvcHackDriverWidth == kUvcHackWidth);
  ZX_ASSERT(kUvcHackDriverHeight == kUvcHackHeight);

  ZX_ASSERT((kUvcHackClientBytesPerRow * 2) == kUvcHackDriverBytesPerRow);

  constexpr uint32_t kClientBufferLimit =
      kUvcHackClientBytesPerRow * kUvcHackClientCodedHeight * 3 / 2;
  constexpr uint32_t kClientUVPlaneOffset = kUvcHackClientBytesPerRow * kUvcHackClientCodedHeight;

  constexpr uint32_t kDriverBufferLimit = kUvcHackDriverBytesPerRow * kUvcHackDriverHeight;

  for (uint32_t y = 0; y < kUvcHackHeight; y++) {
    for (uint32_t x = 0; x < kUvcHackWidth; x += 2) {
      uint32_t driver_offset = (y * kUvcHackDriverBytesPerRow) + (x * 2);
      uint32_t client_offset = (y * kUvcHackClientBytesPerRow) + x;
      ZX_ASSERT(driver_offset < kDriverBufferLimit);
      ZX_ASSERT(client_offset < kClientBufferLimit);
      client_frame[client_offset + 0] = driver_frame[driver_offset + 0];
      client_frame[client_offset + 1] = driver_frame[driver_offset + 2];
    }
  }

  for (uint32_t y = 0; y < kUvcHackHeight; y += 2) {
    for (uint32_t x = 0; x < kUvcHackWidth; x += 2) {
      uint32_t driver_offset = (y * kUvcHackDriverBytesPerRow) + (x * 2);
      uint32_t client_offset = kClientUVPlaneOffset + ((y / 2) * kUvcHackClientBytesPerRow) + x;
      ZX_ASSERT(driver_offset < kDriverBufferLimit);
      ZX_ASSERT(client_offset < kClientBufferLimit);
      client_frame[client_offset + 0] = driver_frame[driver_offset + 1];
    }
  }

  for (uint32_t y = 0; y < kUvcHackHeight; y += 2) {
    for (uint32_t x = 0; x < kUvcHackWidth; x += 2) {
      uint32_t driver_offset = (y * kUvcHackDriverBytesPerRow) + (x * 2);
      uint32_t client_offset = kClientUVPlaneOffset + ((y / 2) * kUvcHackClientBytesPerRow) + x;
      ZX_ASSERT(driver_offset < kDriverBufferLimit);
      ZX_ASSERT(client_offset < kClientBufferLimit);
      client_frame[client_offset + 1] = driver_frame[driver_offset + 3];
    }
  }
}

}  // namespace camera