141 lines
5.3 KiB
C++
141 lines
5.3 KiB
C++
/*
|
|
* Copyright (c) 2014 The WebRTC project authors. All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by a BSD-style license
|
|
* that can be found in the LICENSE file in the root of the source
|
|
* tree. An additional intellectual property rights grant can be found
|
|
* in the file PATENTS. All contributing project authors may
|
|
* be found in the AUTHORS file in the root of the source tree.
|
|
*/
|
|
|
|
#ifndef WEBRTC_MODULES_DESKTOP_CAPTURE_MAIN_SOURCE_DESKTOP_CAPTURE_IMPL_H_
|
|
#define WEBRTC_MODULES_DESKTOP_CAPTURE_MAIN_SOURCE_DESKTOP_CAPTURE_IMPL_H_
|
|
|
|
/*
|
|
* video_capture_impl.h
|
|
*/
|
|
|
|
#include <memory>
|
|
#include <set>
|
|
#include <string>
|
|
|
|
#include "MediaEventSource.h"
|
|
#include "PerformanceRecorder.h"
|
|
#include "api/sequence_checker.h"
|
|
#include "api/video/video_frame.h"
|
|
#include "api/video/video_sink_interface.h"
|
|
#include "modules/desktop_capture/desktop_capturer.h"
|
|
#include "modules/video_capture/video_capture.h"
|
|
#include "mozilla/DataMutex.h"
|
|
#include "mozilla/Maybe.h"
|
|
#include "mozilla/TimeStamp.h"
|
|
#include "nsCOMPtr.h"
|
|
|
|
class nsIThread;
|
|
class nsITimer;
|
|
|
|
namespace mozilla::camera {
|
|
enum class CaptureDeviceType;
|
|
}
|
|
|
|
namespace webrtc {
|
|
|
|
class VideoCaptureEncodeInterface;
|
|
|
|
// Reuses the video engine pipeline for screen sharing.
|
|
// As with video, DesktopCaptureImpl is a proxy for screen sharing
|
|
// and follows the video pipeline design
|
|
class DesktopCaptureImpl : public DesktopCapturer::Callback,
|
|
public VideoCaptureModule {
|
|
public:
|
|
/* Create a screen capture modules object
|
|
*/
|
|
static DesktopCaptureImpl* Create(
|
|
const int32_t aModuleId, const char* aUniqueId,
|
|
const mozilla::camera::CaptureDeviceType aType);
|
|
|
|
[[nodiscard]] static std::shared_ptr<VideoCaptureModule::DeviceInfo>
|
|
CreateDeviceInfo(const int32_t aId,
|
|
const mozilla::camera::CaptureDeviceType aType);
|
|
|
|
// mControlThread only.
|
|
void RegisterCaptureDataCallback(
|
|
rtc::VideoSinkInterface<VideoFrame>* aCallback) override;
|
|
void RegisterCaptureDataCallback(
|
|
RawVideoSinkInterface* dataCallback) override {}
|
|
void DeRegisterCaptureDataCallback(
|
|
rtc::VideoSinkInterface<VideoFrame>* aCallback) override;
|
|
int32_t StopCaptureIfAllClientsClose() override;
|
|
|
|
int32_t SetCaptureRotation(VideoRotation aRotation) override;
|
|
bool SetApplyRotation(bool aEnable) override;
|
|
bool GetApplyRotation() override { return true; }
|
|
|
|
const char* CurrentDeviceName() const override;
|
|
|
|
int32_t StartCapture(const VideoCaptureCapability& aCapability) override;
|
|
virtual bool FocusOnSelectedSource() override;
|
|
int32_t StopCapture() override;
|
|
bool CaptureStarted() override;
|
|
int32_t CaptureSettings(VideoCaptureCapability& aSettings) override;
|
|
|
|
void CaptureFrameOnThread();
|
|
mozilla::MediaEventSource<void>* CaptureEndedEvent();
|
|
|
|
const int32_t mModuleId;
|
|
const mozilla::TrackingId mTrackingId;
|
|
const std::string mDeviceUniqueId;
|
|
const mozilla::camera::CaptureDeviceType mDeviceType;
|
|
|
|
protected:
|
|
DesktopCaptureImpl(const int32_t aId, const char* aUniqueId,
|
|
const mozilla::camera::CaptureDeviceType aType);
|
|
virtual ~DesktopCaptureImpl();
|
|
|
|
private:
|
|
// Maximum CPU usage in %.
|
|
static constexpr uint32_t kMaxDesktopCaptureCpuUsage = 50;
|
|
void InitOnThread(std::unique_ptr<DesktopCapturer> aCapturer, int aFramerate);
|
|
void UpdateOnThread(int aFramerate);
|
|
void ShutdownOnThread();
|
|
// DesktopCapturer::Callback interface.
|
|
void OnCaptureResult(DesktopCapturer::Result aResult,
|
|
std::unique_ptr<DesktopFrame> aFrame) override;
|
|
|
|
// Notifies all mCallbacks of OnFrame(). mCaptureThread only.
|
|
void NotifyOnFrame(const VideoFrame& aFrame);
|
|
|
|
// Control thread on which the public API is called.
|
|
const nsCOMPtr<nsISerialEventTarget> mControlThread;
|
|
// Set in StartCapture.
|
|
mozilla::Maybe<VideoCaptureCapability> mRequestedCapability
|
|
RTC_GUARDED_BY(mControlThreadChecker);
|
|
// The DesktopCapturer is created on mControlThread but assigned and accessed
|
|
// only on mCaptureThread.
|
|
std::unique_ptr<DesktopCapturer> mCapturer
|
|
RTC_GUARDED_BY(mCaptureThreadChecker);
|
|
// Dedicated thread that does the capturing.
|
|
nsCOMPtr<nsIThread> mCaptureThread RTC_GUARDED_BY(mControlThreadChecker);
|
|
// Checks that API methods are called on mControlThread.
|
|
webrtc::SequenceChecker mControlThreadChecker;
|
|
// Checks that frame delivery only happens on mCaptureThread.
|
|
webrtc::SequenceChecker mCaptureThreadChecker;
|
|
// Timer that triggers frame captures. Only used on mCaptureThread.
|
|
// TODO(Bug 1806646): Drive capture with vsync instead.
|
|
nsCOMPtr<nsITimer> mCaptureTimer RTC_GUARDED_BY(mCaptureThreadChecker);
|
|
// Interval between captured frames, based on the framerate in
|
|
// mRequestedCapability. mCaptureThread only.
|
|
mozilla::Maybe<mozilla::TimeDuration> mRequestedCaptureInterval
|
|
RTC_GUARDED_BY(mCaptureThreadChecker);
|
|
// Used to make sure incoming timestamp is increasing for every frame.
|
|
webrtc::Timestamp mNextFrameMinimumTime RTC_GUARDED_BY(mCaptureThreadChecker);
|
|
// Callbacks for captured frames. Mutated on mControlThread, callbacks happen
|
|
// on mCaptureThread.
|
|
mozilla::DataMutex<std::set<rtc::VideoSinkInterface<VideoFrame>*>> mCallbacks;
|
|
// Subscribers to this event will be notified when the capture has ended.
|
|
mozilla::MediaEventProducer<void> mCaptureEndedEvent;
|
|
};
|
|
|
|
} // namespace webrtc
|
|
|
|
#endif // WEBRTC_MODULES_DESKTOP_CAPTURE_MAIN_SOURCE_DESKTOP_CAPTURE_IMPL_H_
|