single_client_video_capture_host.h 6.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144
  1. // Copyright 2018 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. #ifndef COMPONENTS_MIRRORING_BROWSER_SINGLE_CLIENT_VIDEO_CAPTURE_HOST_H_
  5. #define COMPONENTS_MIRRORING_BROWSER_SINGLE_CLIENT_VIDEO_CAPTURE_HOST_H_
  6. #include <memory>
  7. #include <string>
  8. #include <utility>
  9. #include "base/callback.h"
  10. #include "base/containers/flat_map.h"
  11. #include "base/containers/flat_set.h"
  12. #include "base/memory/scoped_refptr.h"
  13. #include "base/sequence_checker.h"
  14. #include "base/token.h"
  15. #include "base/unguessable_token.h"
  16. #include "content/public/browser/video_capture_device_launcher.h"
  17. #include "media/capture/mojom/video_capture.mojom.h"
  18. #include "media/capture/video/video_frame_receiver.h"
  19. #include "mojo/public/cpp/bindings/remote.h"
  20. using media::VideoCaptureParams;
  21. using media::VideoCaptureDevice;
  22. namespace mirroring {
  23. // Implements a subset of mojom::VideoCaptureHost to proxy between a
  24. // content::LaunchedVideoCaptureDevice and a single client. On Start(), uses the
  25. // provided DeviceLauncherCreateCallback to launch a video capture device that
  26. // outputs frames to |this|. The frames are received through the
  27. // VideoFrameReceiver interface and are forwarded to |observer| through the
  28. // mojom::VideoCaptureObserver interface.
  29. // Instances of this class must be operated from the same thread that is reqired
  30. // by the DeviceLauncherCreateCallback.
  31. class SingleClientVideoCaptureHost final
  32. : public media::mojom::VideoCaptureHost,
  33. public media::VideoFrameReceiver {
  34. public:
  35. using DeviceLauncherCreateCallback = base::RepeatingCallback<
  36. std::unique_ptr<content::VideoCaptureDeviceLauncher>()>;
  37. SingleClientVideoCaptureHost(const std::string& device_id,
  38. blink::mojom::MediaStreamType type,
  39. DeviceLauncherCreateCallback callback);
  40. SingleClientVideoCaptureHost(const SingleClientVideoCaptureHost&) = delete;
  41. SingleClientVideoCaptureHost& operator=(const SingleClientVideoCaptureHost&) =
  42. delete;
  43. ~SingleClientVideoCaptureHost() override;
  44. // media::mojom::VideoCaptureHost implementations
  45. // |device_id| and |session_id| are ignored since there will be only one
  46. // device and one client.
  47. void Start(const base::UnguessableToken& device_id,
  48. const base::UnguessableToken& session_id,
  49. const VideoCaptureParams& params,
  50. mojo::PendingRemote<media::mojom::VideoCaptureObserver> observer)
  51. override;
  52. void Stop(const base::UnguessableToken& device_id) override;
  53. void Pause(const base::UnguessableToken& device_id) override;
  54. void Resume(const base::UnguessableToken& device_id,
  55. const base::UnguessableToken& session_id,
  56. const VideoCaptureParams& params) override;
  57. void RequestRefreshFrame(const base::UnguessableToken& device_id) override;
  58. void ReleaseBuffer(const base::UnguessableToken& device_id,
  59. int32_t buffer_id,
  60. const media::VideoCaptureFeedback& feedback) override;
  61. void GetDeviceSupportedFormats(
  62. const base::UnguessableToken& device_id,
  63. const base::UnguessableToken& session_id,
  64. GetDeviceSupportedFormatsCallback callback) override;
  65. void GetDeviceFormatsInUse(const base::UnguessableToken& device_id,
  66. const base::UnguessableToken& session_id,
  67. GetDeviceFormatsInUseCallback callback) override;
  68. void OnFrameDropped(const base::UnguessableToken& device_id,
  69. media::VideoCaptureFrameDropReason reason) override;
  70. void OnLog(const base::UnguessableToken& device_id,
  71. const std::string& message) override;
  72. // media::VideoFrameReceiver implementations
  73. using Buffer = VideoCaptureDevice::Client::Buffer;
  74. void OnNewBuffer(int buffer_id,
  75. media::mojom::VideoBufferHandlePtr buffer_handle) override;
  76. void OnFrameReadyInBuffer(
  77. media::ReadyFrameInBuffer frame,
  78. std::vector<media::ReadyFrameInBuffer> scaled_frames) override;
  79. void OnBufferRetired(int buffer_id) override;
  80. void OnError(media::VideoCaptureError error) override;
  81. void OnFrameDropped(media::VideoCaptureFrameDropReason reason) override;
  82. void OnNewCropVersion(uint32_t crop_version) override;
  83. void OnFrameWithEmptyRegionCapture() override;
  84. void OnLog(const std::string& message) override;
  85. void OnStarted() override;
  86. void OnStartedUsingGpuDecode() override;
  87. void OnStopped() override;
  88. void OnDeviceLaunched(
  89. std::unique_ptr<content::LaunchedVideoCaptureDevice> device);
  90. void OnDeviceLaunchFailed(media::VideoCaptureError error);
  91. void OnDeviceLaunchAborted();
  92. private:
  93. // Reports the |consumer_resource_utilization| and removes the buffer context.
  94. void OnFinishedConsumingBuffer(int buffer_context_id,
  95. media::VideoCaptureFeedback feedback);
  96. const std::string device_id_;
  97. const blink::mojom::MediaStreamType type_;
  98. const DeviceLauncherCreateCallback device_launcher_callback_;
  99. mojo::Remote<media::mojom::VideoCaptureObserver> observer_;
  100. std::unique_ptr<content::LaunchedVideoCaptureDevice> launched_device_;
  101. // Unique ID assigned for the next buffer provided by OnNewBufferHandle().
  102. int next_buffer_context_id_ = 0;
  103. // Records the assigned buffer_context_id for buffers that are not retired.
  104. // The |buffer_id| provided by OnNewBufferHandle() is used as the key.
  105. base::flat_map<int, int> id_map_;
  106. // Tracks the the retired buffers that are still held by |observer_|.
  107. base::flat_set<int> retired_buffers_;
  108. // Records the |frame_feedback_id| and |buffer_read_permission| provided by
  109. // OnFrameReadyInBuffer(). The key is the assigned buffer context id. Each
  110. // entry is removed after the |observer_| finishes consuming the buffer by
  111. // calling ReleaseBuffer(). When Stop() is called, all the buffers are cleared
  112. // immediately.
  113. using BufferContext = std::pair<
  114. int,
  115. std::unique_ptr<
  116. VideoCaptureDevice::Client::Buffer::ScopedAccessPermission>>;
  117. base::flat_map<int, BufferContext> buffer_context_map_;
  118. SEQUENCE_CHECKER(sequence_checker_);
  119. base::WeakPtrFactory<SingleClientVideoCaptureHost> weak_factory_{this};
  120. };
  121. } // namespace mirroring
  122. #endif // COMPONENTS_MIRRORING_BROWSER_SINGLE_CLIENT_VIDEO_CAPTURE_HOST_H_