video_frame_handler_proxy_lacros.cc 6.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173
  1. // Copyright 2021 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "services/video_capture/lacros/video_frame_handler_proxy_lacros.h"
  5. #include <map>
  6. #include <memory>
  7. #include <utility>
  8. #include "base/notreached.h"
  9. #include "mojo/public/cpp/bindings/self_owned_receiver.h"
  10. #include "services/video_capture/lacros/video_buffer_adapters.h"
  11. #include "services/video_capture/public/cpp/video_frame_access_handler.h"
  12. namespace video_capture {
  13. namespace {
  14. mojom::ReadyFrameInBufferPtr ToVideoCaptureBuffer(
  15. crosapi::mojom::ReadyFrameInBufferPtr buffer) {
  16. auto video_capture_buffer = mojom::ReadyFrameInBuffer::New();
  17. video_capture_buffer->buffer_id = buffer->buffer_id;
  18. video_capture_buffer->frame_feedback_id = buffer->frame_feedback_id;
  19. video_capture_buffer->frame_info =
  20. ConvertToMediaVideoFrameInfo(std::move(buffer->frame_info));
  21. return video_capture_buffer;
  22. }
  23. } // namespace
  24. // A reference counted map keeping
  25. // mojo::Remote<crosapi::mojom::ScopedAccessPermission> pipes alive until
  26. // EraseAccessPermission() calls.
  27. class VideoFrameHandlerProxyLacros::AccessPermissionProxyMap
  28. : public base::RefCountedThreadSafe<
  29. VideoFrameHandlerProxyLacros::AccessPermissionProxyMap> {
  30. public:
  31. AccessPermissionProxyMap() = default;
  32. void InsertAccessPermission(
  33. int32_t buffer_id,
  34. mojo::PendingRemote<crosapi::mojom::ScopedAccessPermission>
  35. pending_remote_access_permission) {
  36. std::unique_ptr<mojo::Remote<crosapi::mojom::ScopedAccessPermission>>
  37. remote_access_permission = std::make_unique<
  38. mojo::Remote<crosapi::mojom::ScopedAccessPermission>>(
  39. std::move(pending_remote_access_permission));
  40. auto result = access_permissions_by_buffer_ids_.insert(
  41. std::make_pair(buffer_id, std::move(remote_access_permission)));
  42. DCHECK(result.second);
  43. }
  44. void EraseAccessPermission(int32_t buffer_id) {
  45. auto it = access_permissions_by_buffer_ids_.find(buffer_id);
  46. if (it == access_permissions_by_buffer_ids_.end()) {
  47. NOTREACHED();
  48. return;
  49. }
  50. access_permissions_by_buffer_ids_.erase(it);
  51. }
  52. private:
  53. friend class base::RefCountedThreadSafe<
  54. VideoFrameHandlerProxyLacros::AccessPermissionProxyMap>;
  55. ~AccessPermissionProxyMap() = default;
  56. std::map<
  57. int32_t,
  58. std::unique_ptr<mojo::Remote<crosapi::mojom::ScopedAccessPermission>>>
  59. access_permissions_by_buffer_ids_;
  60. };
  61. // mojom::VideoFrameAccessHandler implementation that takes care of erasing the
  62. // mapped scoped access permissions.
  63. class VideoFrameHandlerProxyLacros::VideoFrameAccessHandlerProxy
  64. : public mojom::VideoFrameAccessHandler {
  65. public:
  66. VideoFrameAccessHandlerProxy(
  67. scoped_refptr<AccessPermissionProxyMap> access_permission_proxy_map)
  68. : access_permission_proxy_map_(std::move(access_permission_proxy_map)) {}
  69. ~VideoFrameAccessHandlerProxy() override = default;
  70. void OnFinishedConsumingBuffer(int32_t buffer_id) override {
  71. access_permission_proxy_map_->EraseAccessPermission(buffer_id);
  72. }
  73. private:
  74. scoped_refptr<AccessPermissionProxyMap> access_permission_proxy_map_;
  75. };
  76. VideoFrameHandlerProxyLacros::VideoFrameHandlerProxyLacros(
  77. mojo::PendingReceiver<crosapi::mojom::VideoFrameHandler> proxy_receiver,
  78. mojo::PendingRemote<mojom::VideoFrameHandler> handler_remote)
  79. : handler_(std::move(handler_remote)) {
  80. receiver_.Bind(std::move(proxy_receiver));
  81. }
  82. VideoFrameHandlerProxyLacros::~VideoFrameHandlerProxyLacros() = default;
  83. void VideoFrameHandlerProxyLacros::OnNewBuffer(
  84. int buffer_id,
  85. crosapi::mojom::VideoBufferHandlePtr buffer_handle) {
  86. handler_->OnNewBuffer(buffer_id,
  87. ConvertToMediaVideoBuffer(std::move(buffer_handle)));
  88. }
  89. void VideoFrameHandlerProxyLacros::OnFrameReadyInBuffer(
  90. crosapi::mojom::ReadyFrameInBufferPtr buffer,
  91. std::vector<crosapi::mojom::ReadyFrameInBufferPtr> scaled_buffers) {
  92. if (!access_permission_proxy_map_) {
  93. access_permission_proxy_map_ = new AccessPermissionProxyMap();
  94. mojo::PendingRemote<mojom::VideoFrameAccessHandler> pending_remote;
  95. mojo::MakeSelfOwnedReceiver<mojom::VideoFrameAccessHandler>(
  96. std::make_unique<VideoFrameAccessHandlerProxy>(
  97. access_permission_proxy_map_),
  98. pending_remote.InitWithNewPipeAndPassReceiver());
  99. handler_->OnFrameAccessHandlerReady(std::move(pending_remote));
  100. }
  101. access_permission_proxy_map_->InsertAccessPermission(
  102. buffer->buffer_id, std::move(buffer->access_permission));
  103. mojom::ReadyFrameInBufferPtr video_capture_buffer =
  104. ToVideoCaptureBuffer(std::move(buffer));
  105. std::vector<mojom::ReadyFrameInBufferPtr> video_capture_scaled_buffers;
  106. for (auto& b : scaled_buffers) {
  107. access_permission_proxy_map_->InsertAccessPermission(
  108. b->buffer_id, std::move(b->access_permission));
  109. video_capture_scaled_buffers.push_back(ToVideoCaptureBuffer(std::move(b)));
  110. }
  111. handler_->OnFrameReadyInBuffer(std::move(video_capture_buffer),
  112. std::move(video_capture_scaled_buffers));
  113. }
  114. void VideoFrameHandlerProxyLacros::OnBufferRetired(int buffer_id) {
  115. handler_->OnBufferRetired(buffer_id);
  116. }
  117. void VideoFrameHandlerProxyLacros::OnError(media::VideoCaptureError error) {
  118. handler_->OnError(error);
  119. }
  120. void VideoFrameHandlerProxyLacros::OnFrameDropped(
  121. media::VideoCaptureFrameDropReason reason) {
  122. handler_->OnFrameDropped(reason);
  123. }
  124. void VideoFrameHandlerProxyLacros::OnNewCropVersion(uint32_t crop_version) {
  125. handler_->OnNewCropVersion(crop_version);
  126. }
  127. void VideoFrameHandlerProxyLacros::OnFrameWithEmptyRegionCapture() {
  128. handler_->OnFrameWithEmptyRegionCapture();
  129. }
  130. void VideoFrameHandlerProxyLacros::OnLog(const std::string& message) {
  131. handler_->OnLog(message);
  132. }
  133. void VideoFrameHandlerProxyLacros::OnStarted() {
  134. handler_->OnStarted();
  135. }
  136. void VideoFrameHandlerProxyLacros::OnStartedUsingGpuDecode() {
  137. handler_->OnStartedUsingGpuDecode();
  138. }
  139. void VideoFrameHandlerProxyLacros::OnStopped() {
  140. handler_->OnStopped();
  141. }
  142. } // namespace video_capture