media_perception/video_capture_service_client_impl.cc

// Copyright 2018 The Chromium OS 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 "media_perception/video_capture_service_client_impl.h"

#include <utility>
#include <base/single_thread_task_runner.h>

namespace mri {

void VideoCaptureServiceClientImpl::SetMojoConnector(
    MojoConnector* mojo_connector) {
  mojo_connector_ = mojo_connector;
}

bool VideoCaptureServiceClientImpl::Connect() {
  if (mojo_connector_ == nullptr) {
    LOG(ERROR) << "Mojo connector is nullptr.";
    return false;
  }
  mojo_connector_->ConnectToVideoCaptureService();
  return true;
}

void VideoCaptureServiceClientImpl::GetDevices(
    const GetDevicesCallback& callback) {
  mojo_connector_->GetDevices(callback);
}

void VideoCaptureServiceClientImpl::SetActiveDevice(
    const std::string& device_id, const SetActiveDeviceCallback& callback) {
  mojo_connector_->SetActiveDevice(device_id, callback);
}

void VideoCaptureServiceClientImpl::StartVideoCapture(
    const CaptureFormat& capture_format) {
  requested_frame_width_ = capture_format.frame_width;
  requested_frame_height_ = capture_format.frame_height;
  mojo_connector_->StartVideoCapture(
      capture_format, std::bind(&VideoCaptureServiceClientImpl::OnNewFrameData,
                                this, std::placeholders::_1,
                                std::placeholders::_2, std::placeholders::_3));
}

void VideoCaptureServiceClientImpl::StopVideoCapture() {
  mojo_connector_->StopVideoCapture();
}

void VideoCaptureServiceClientImpl::OnNewFrameData(
    uint64_t timestamp_in_microseconds, const uint8_t* data, int data_size) {
  if (frame_handler_ == nullptr) {
    LOG(ERROR) << "Frame handler is null but receiving frames.";
    return;
  }
  frame_handler_(timestamp_in_microseconds, data, data_size,
                 requested_frame_width_, requested_frame_height_);
}

void VideoCaptureServiceClientImpl::CreateVirtualDevice(
    const VideoDevice& video_device, const VirtualDeviceCallback& callback) {
  std::unique_ptr<ProducerImpl> producer_impl(new ProducerImpl());
  mojo_connector_->CreateVirtualDevice(
      video_device, producer_impl.get(), callback);

  std::lock_guard<std::mutex> lock(device_id_to_producer_map_lock_);
  device_id_to_producer_map_.insert(
      std::make_pair(video_device.id, std::move(producer_impl)));
}

void VideoCaptureServiceClientImpl::PushFrameToVirtualDevice(
    const std::string& device_id, uint64_t timestamp_in_microseconds,
    std::unique_ptr<const uint8_t[]> data, int data_size,
    PixelFormat pixel_format, int frame_width, int frame_height) {
  std::lock_guard<std::mutex> lock(device_id_to_producer_map_lock_);
  std::map<std::string, std::unique_ptr<ProducerImpl>>::iterator it =
      device_id_to_producer_map_.find(device_id);
  if (it == device_id_to_producer_map_.end()) {
    LOG(ERROR) << "Device id not found in producer map.";
    return;
  }
  mojo_connector_->PushFrameToVirtualDevice(
      (it->second).get(),
      base::TimeDelta::FromMicroseconds(timestamp_in_microseconds),
      std::move(data), data_size, pixel_format, frame_width, frame_height);
}

void VideoCaptureServiceClientImpl::CloseVirtualDevice(
    const std::string& device_id) {
  std::lock_guard<std::mutex> lock(device_id_to_producer_map_lock_);
  // Erasing the producer object will close the virtual device.
  device_id_to_producer_map_.erase(device_id);
}

}  // namespace mri