1
    2
    3
    4
    5
    6
    7
    8
    9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33
   34
   35
   36
   37
   38
   39
   40
   41
   42
   43
   44
   45
   46
   47
   48
   49
   50
   51
   52
   53
   54
   55
   56
   57
   58
   59
   60
   61
   62
   63
   64
   65
   66
   67
   68
   69
   70
   71
   72
   73
   74
   75
   76
   77
   78
   79
   80
   81
   82
   83
   84
   85
   86
   87
   88
   89
   90
   91
   92
   93
   94
   95
   96
   97
   98
   99
  100
  101
  102
  103
  104
  105
  106
  107
  108
  109
  110
  111
  112


content / browser / media / capture / io_surface_capture_device_base_mac.cc [blame]

// Copyright 2022 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "content/browser/media/capture/io_surface_capture_device_base_mac.h"

#include "media/base/video_util.h"
#include "media/capture/content/capture_resolution_chooser.h"

namespace content {

IOSurfaceCaptureDeviceBase::IOSurfaceCaptureDeviceBase() = default;
IOSurfaceCaptureDeviceBase::~IOSurfaceCaptureDeviceBase() = default;

void IOSurfaceCaptureDeviceBase::AllocateAndStart(
    const media::VideoCaptureParams& params,
    std::unique_ptr<Client> client) {
  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
  DCHECK(client && !client_);
  client_ = std::move(client);
  capture_params_ = params;

  OnStart();
}

void IOSurfaceCaptureDeviceBase::StopAndDeAllocate() {
  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
  weak_factory_base_.InvalidateWeakPtrs();

  OnStop();
}

void IOSurfaceCaptureDeviceBase::RequestRefreshFrame() {
  // Simply send the last received surface, if we ever received one.
  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
  if (last_received_io_surface_)
    SendLastReceivedIOSurfaceToClient();
}

void IOSurfaceCaptureDeviceBase::OnReceivedIOSurfaceFromStream(
    gfx::ScopedInUseIOSurface io_surface,
    const media::VideoCaptureFormat& capture_format,
    const gfx::Rect& visible_rect) {
  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
  last_received_io_surface_ = std::move(io_surface);
  last_received_capture_format_ = capture_format;
  last_visible_rect_ = visible_rect;

  // Immediately send the new frame to the client.
  SendLastReceivedIOSurfaceToClient();
}

void IOSurfaceCaptureDeviceBase::SendLastReceivedIOSurfaceToClient() {
  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);

  // Package `last_received_io_surface_` as a GpuMemoryBuffer.
  gfx::GpuMemoryBufferHandle handle;
  handle.id = gfx::GpuMemoryBufferHandle::kInvalidId;
  handle.type = gfx::GpuMemoryBufferType::IO_SURFACE_BUFFER;
  handle.io_surface = last_received_io_surface_;

  const auto now = base::TimeTicks::Now();
  if (first_frame_time_.is_null())
    first_frame_time_ = now;

  client_->OnIncomingCapturedExternalBuffer(
      media::CapturedExternalVideoBuffer(std::move(handle),
                                         last_received_capture_format_,
                                         gfx::ColorSpace::CreateREC709()),
      now, now - first_frame_time_, std::nullopt, last_visible_rect_);
}

void IOSurfaceCaptureDeviceBase::ComputeFrameSizeAndDestRect(
    const gfx::Size& source_size,
    gfx::Size& frame_size,
    gfx::RectF& dest_rect_in_frame) const {
  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);

  // Compute the destination frame size using CaptureResolutionChooser.
  const auto constraints = capture_params_.SuggestConstraints();
  {
    media::CaptureResolutionChooser resolution_chooser;
    resolution_chooser.SetConstraints(constraints.min_frame_size,
                                      constraints.max_frame_size,
                                      constraints.fixed_aspect_ratio);
    resolution_chooser.SetSourceSize(source_size);
    // Ensure that the resulting frame size has an even width and height. This
    // matches the behavior of DesktopCaptureDevice.
    frame_size = gfx::Size(resolution_chooser.capture_size().width() & ~1,
                           resolution_chooser.capture_size().height() & ~1);
    if (frame_size.IsEmpty())
      frame_size = gfx::Size(2, 2);
  }

  // Compute the rectangle to blit into.
  if (constraints.fixed_aspect_ratio) {
    dest_rect_in_frame = gfx::RectF(media::ComputeLetterboxRegionForI420(
        gfx::Rect(frame_size), source_size));
    // If the target rectangle is not exactly the full frame, then out-set
    // the region by a tiny amount. This works around a bug wherein a green
    // line appears on the left side of the content.
    // https://crbug.com/1267655
    if (dest_rect_in_frame != gfx::RectF(gfx::SizeF(frame_size)))
      dest_rect_in_frame.Outset(1.f / 4096);
  } else {
    // If the aspect ratio is not fixed, then this is the full destination
    // frame.
    dest_rect_in_frame = gfx::RectF(gfx::SizeF(frame_size));
  }
}

}  // namespace content