diff options
Diffstat (limited to '')
| -rw-r--r-- | dom/media/systemservices/CamerasParent.cpp | 1222 |
1 files changed, 1222 insertions, 0 deletions
diff --git a/dom/media/systemservices/CamerasParent.cpp b/dom/media/systemservices/CamerasParent.cpp new file mode 100644 index 0000000000..91185f44e1 --- /dev/null +++ b/dom/media/systemservices/CamerasParent.cpp @@ -0,0 +1,1222 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set sw=2 ts=8 et ft=cpp : */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this file, + * You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "CamerasParent.h" + +#include <atomic> +#include "MediaEngineSource.h" +#include "MediaUtils.h" +#include "PerformanceRecorder.h" +#include "VideoFrameUtils.h" + +#include "mozilla/AppShutdown.h" +#include "mozilla/Assertions.h" +#include "mozilla/BasePrincipal.h" +#include "mozilla/ProfilerMarkers.h" +#include "mozilla/Unused.h" +#include "mozilla/Services.h" +#include "mozilla/Logging.h" +#include "mozilla/ipc/BackgroundParent.h" +#include "mozilla/ipc/PBackgroundParent.h" +#include "mozilla/dom/CanonicalBrowsingContext.h" +#include "mozilla/dom/WindowGlobalParent.h" +#include "mozilla/Preferences.h" +#include "mozilla/StaticPrefs_permissions.h" +#include "nsIPermissionManager.h" +#include "nsThreadUtils.h" +#include "nsNetUtil.h" + +#include "api/video/video_frame_buffer.h" +#include "common_video/libyuv/include/webrtc_libyuv.h" + +#if defined(_WIN32) +# include <process.h> +# define getpid() _getpid() +#endif + +#undef LOG +#undef LOG_VERBOSE +#undef LOG_ENABLED +mozilla::LazyLogModule gCamerasParentLog("CamerasParent"); +#define LOG(...) \ + MOZ_LOG(gCamerasParentLog, mozilla::LogLevel::Debug, (__VA_ARGS__)) +#define LOG_VERBOSE(...) \ + MOZ_LOG(gCamerasParentLog, mozilla::LogLevel::Verbose, (__VA_ARGS__)) +#define LOG_ENABLED() MOZ_LOG_TEST(gCamerasParentLog, mozilla::LogLevel::Debug) + +namespace mozilla { +using media::MustGetShutdownBarrier; +using media::NewRunnableFrom; +namespace camera { + +std::map<uint32_t, const char*> sDeviceUniqueIDs; +std::map<uint32_t, webrtc::VideoCaptureCapability> sAllRequestedCapabilities; + +uint32_t ResolutionFeasibilityDistance(int32_t candidate, int32_t requested) { + // The purpose of this function is to find a smallest resolution + // which is larger than all requested capabilities. + // Then we can use down-scaling to fulfill each request. + + MOZ_DIAGNOSTIC_ASSERT(candidate >= 0, "Candidate unexpectedly negative"); + MOZ_DIAGNOSTIC_ASSERT(requested >= 0, "Requested unexpectedly negative"); + + if (candidate == 0) { + // Treat width|height capability of 0 as "can do any". + // This allows for orthogonal capabilities that are not in discrete steps. + return 0; + } + + uint32_t distance = + std::abs(candidate - requested) * 1000 / std::max(candidate, requested); + if (candidate >= requested) { + // This is a good case, the candidate covers the requested resolution. + return distance; + } + + // This is a bad case, the candidate is lower than the requested resolution. + // This is penalized with an added weight of 10000. + return 10000 + distance; +} + +uint32_t FeasibilityDistance(int32_t candidate, int32_t requested) { + MOZ_DIAGNOSTIC_ASSERT(candidate >= 0, "Candidate unexpectedly negative"); + MOZ_DIAGNOSTIC_ASSERT(requested >= 0, "Requested unexpectedly negative"); + + if (candidate == 0) { + // Treat maxFPS capability of 0 as "can do any". + // This allows for orthogonal capabilities that are not in discrete steps. + return 0; + } + + return std::abs(candidate - requested) * 1000 / + std::max(candidate, requested); +} + +StaticRefPtr<VideoEngine> CamerasParent::sEngines[CaptureEngine::MaxEngine]; +int32_t CamerasParent::sNumOfOpenCamerasParentEngines = 0; +int32_t CamerasParent::sNumOfCamerasParents = 0; +base::Thread* CamerasParent::sVideoCaptureThread = nullptr; +Monitor* CamerasParent::sThreadMonitor = nullptr; +StaticMutex CamerasParent::sMutex; + +// 3 threads are involved in this code: +// - the main thread for some setups, and occassionally for video capture setup +// calls that don't work correctly elsewhere. +// - the IPC thread on which PBackground is running and which receives and +// sends messages +// - a thread which will execute the actual (possibly slow) camera access +// called "VideoCapture". On Windows this is a thread with an event loop +// suitable for UI access. + +// InputObserver is owned by CamerasParent, and it has a ref to CamerasParent +void InputObserver::OnDeviceChange() { + LOG("%s", __PRETTY_FUNCTION__); + MOZ_ASSERT(mParent); + + RefPtr<InputObserver> self(this); + RefPtr<nsIRunnable> ipc_runnable = NewRunnableFrom([self]() { + if (self->mParent->IsShuttingDown()) { + LOG("OnDeviceChanged failure: parent shutting down."); + return NS_ERROR_FAILURE; + } + Unused << self->mParent->SendDeviceChange(); + return NS_OK; + }); + + nsIEventTarget* target = mParent->GetBackgroundEventTarget(); + MOZ_ASSERT(target != nullptr); + target->Dispatch(ipc_runnable, NS_DISPATCH_NORMAL); +}; + +class DeliverFrameRunnable : public mozilla::Runnable { + public: + DeliverFrameRunnable(CamerasParent* aParent, CaptureEngine aEngine, + uint32_t aStreamId, const TrackingId& aTrackingId, + const webrtc::VideoFrame& aFrame, + const VideoFrameProperties& aProperties) + : Runnable("camera::DeliverFrameRunnable"), + mParent(aParent), + mCapEngine(aEngine), + mStreamId(aStreamId), + mTrackingId(aTrackingId), + mProperties(aProperties), + mResult(0) { + // No ShmemBuffer (of the right size) was available, so make an + // extra buffer here. We have no idea when we are going to run and + // it will be potentially long after the webrtc frame callback has + // returned, so the copy needs to be no later than here. + // We will need to copy this back into a Shmem later on so we prefer + // using ShmemBuffers to avoid the extra copy. + PerformanceRecorder<CopyVideoStage> rec( + "CamerasParent::VideoFrameToAltBuffer"_ns, aTrackingId, aFrame.width(), + aFrame.height()); + mAlternateBuffer.reset(new unsigned char[aProperties.bufferSize()]); + VideoFrameUtils::CopyVideoFrameBuffers(mAlternateBuffer.get(), + aProperties.bufferSize(), aFrame); + rec.Record(); + } + + DeliverFrameRunnable(CamerasParent* aParent, CaptureEngine aEngine, + uint32_t aStreamId, const TrackingId& aTrackingId, + ShmemBuffer aBuffer, VideoFrameProperties& aProperties) + : Runnable("camera::DeliverFrameRunnable"), + mParent(aParent), + mCapEngine(aEngine), + mStreamId(aStreamId), + mTrackingId(aTrackingId), + mBuffer(std::move(aBuffer)), + mProperties(aProperties), + mResult(0){}; + + NS_IMETHOD Run() override { + // runs on BackgroundEventTarget + MOZ_ASSERT(GetCurrentSerialEventTarget() == + mParent->mPBackgroundEventTarget); + if (mParent->IsShuttingDown()) { + // Communication channel is being torn down + mResult = 0; + return NS_OK; + } + if (!mParent->DeliverFrameOverIPC(mCapEngine, mStreamId, mTrackingId, + std::move(mBuffer), + mAlternateBuffer.get(), mProperties)) { + mResult = -1; + } else { + mResult = 0; + } + return NS_OK; + } + + int GetResult() { return mResult; } + + private: + const RefPtr<CamerasParent> mParent; + const CaptureEngine mCapEngine; + const uint32_t mStreamId; + const TrackingId mTrackingId; + ShmemBuffer mBuffer; + UniquePtr<unsigned char[]> mAlternateBuffer; + const VideoFrameProperties mProperties; + int mResult; +}; + +NS_IMPL_ISUPPORTS(CamerasParent, nsIAsyncShutdownBlocker) + +nsresult CamerasParent::DispatchToVideoCaptureThread(RefPtr<Runnable> event) { + // Don't try to dispatch if we're already on the right thread. + // There's a potential deadlock because the sThreadMonitor is likely + // to be taken already. + MonitorAutoLock lock(*sThreadMonitor); + if (!sVideoCaptureThread) { + LOG("Can't dispatch to video capture thread: thread not present"); + return NS_ERROR_FAILURE; + } + MOZ_ASSERT(sVideoCaptureThread->thread_id() != PlatformThread::CurrentId()); + + sVideoCaptureThread->message_loop()->PostTask(event.forget()); + return NS_OK; +} + +void CamerasParent::StopVideoCapture() { + LOG("%s", __PRETTY_FUNCTION__); + // Called when the actor is destroyed. + ipc::AssertIsOnBackgroundThread(); + // Shut down the WebRTC stack (on the capture thread) + RefPtr<CamerasParent> self(this); + DebugOnly<nsresult> rv = + DispatchToVideoCaptureThread(NewRunnableFrom([self]() { + MonitorAutoLock lock(*(self->sThreadMonitor)); + self->CloseEngines(); + // After closing the WebRTC stack, clean up the + // VideoCapture thread. + base::Thread* thread = nullptr; + if (sNumOfOpenCamerasParentEngines == 0 && self->sVideoCaptureThread) { + thread = self->sVideoCaptureThread; + self->sVideoCaptureThread = nullptr; + } + nsresult rv = NS_DispatchToMainThread(NewRunnableFrom([self, thread]() { + if (thread) { + thread->Stop(); + delete thread; + } + // May fail if already removed after RecvPCamerasConstructor(). + (void)MustGetShutdownBarrier()->RemoveBlocker(self); + return NS_OK; + })); + MOZ_DIAGNOSTIC_ASSERT(NS_SUCCEEDED(rv), + "dispatch for video thread shutdown"); + return rv; + })); +#ifdef DEBUG + // It's ok for the dispatch to fail if the cleanup it has to do + // has been done already. + MOZ_ASSERT(NS_SUCCEEDED(rv) || !mWebRTCAlive); +#endif +} + +int CamerasParent::DeliverFrameOverIPC(CaptureEngine capEng, uint32_t aStreamId, + const TrackingId& aTrackingId, + ShmemBuffer buffer, + unsigned char* altbuffer, + const VideoFrameProperties& aProps) { + // No ShmemBuffers were available, so construct one now of the right size + // and copy into it. That is an extra copy, but we expect this to be + // the exceptional case, because we just assured the next call *will* have a + // buffer of the right size. + if (altbuffer != nullptr) { + // Get a shared memory buffer from the pool, at least size big + ShmemBuffer shMemBuff = mShmemPool.Get(this, aProps.bufferSize()); + + if (!shMemBuff.Valid()) { + LOG("No usable Video shmem in DeliverFrame (out of buffers?)"); + // We can skip this frame if we run out of buffers, it's not a real error. + return 0; + } + + PerformanceRecorder<CopyVideoStage> rec( + "CamerasParent::AltBufferToShmem"_ns, aTrackingId, aProps.width(), + aProps.height()); + // get() and Size() check for proper alignment of the segment + memcpy(shMemBuff.GetBytes(), altbuffer, aProps.bufferSize()); + rec.Record(); + + if (!SendDeliverFrame(capEng, aStreamId, std::move(shMemBuff.Get()), + aProps)) { + return -1; + } + } else { + MOZ_ASSERT(buffer.Valid()); + // ShmemBuffer was available, we're all good. A single copy happened + // in the original webrtc callback. + if (!SendDeliverFrame(capEng, aStreamId, std::move(buffer.Get()), aProps)) { + return -1; + } + } + + return 0; +} + +ShmemBuffer CamerasParent::GetBuffer(size_t aSize) { + return mShmemPool.GetIfAvailable(aSize); +} + +void CallbackHelper::OnFrame(const webrtc::VideoFrame& aVideoFrame) { + LOG_VERBOSE("%s", __PRETTY_FUNCTION__); + if (profiler_thread_is_being_profiled_for_markers()) { + PROFILER_MARKER_UNTYPED( + nsPrintfCString("CaptureVideoFrame %dx%d %s %s", aVideoFrame.width(), + aVideoFrame.height(), + webrtc::VideoFrameBufferTypeToString( + aVideoFrame.video_frame_buffer()->type()), + mTrackingId.ToString().get()), + MEDIA_RT); + } + RefPtr<DeliverFrameRunnable> runnable = nullptr; + // Get frame properties + camera::VideoFrameProperties properties; + VideoFrameUtils::InitFrameBufferProperties(aVideoFrame, properties); + // Get a shared memory buffer to copy the frame data into + ShmemBuffer shMemBuffer = mParent->GetBuffer(properties.bufferSize()); + if (!shMemBuffer.Valid()) { + // Either we ran out of buffers or they're not the right size yet + LOG("Correctly sized Video shmem not available in DeliverFrame"); + // We will do the copy into a(n extra) temporary buffer inside + // the DeliverFrameRunnable constructor. + } else { + // Shared memory buffers of the right size are available, do the copy here. + PerformanceRecorder<CopyVideoStage> rec( + "CamerasParent::VideoFrameToShmem"_ns, mTrackingId, aVideoFrame.width(), + aVideoFrame.height()); + VideoFrameUtils::CopyVideoFrameBuffers( + shMemBuffer.GetBytes(), properties.bufferSize(), aVideoFrame); + rec.Record(); + runnable = + new DeliverFrameRunnable(mParent, mCapEngine, mStreamId, mTrackingId, + std::move(shMemBuffer), properties); + } + if (!runnable) { + runnable = new DeliverFrameRunnable(mParent, mCapEngine, mStreamId, + mTrackingId, aVideoFrame, properties); + } + MOZ_ASSERT(mParent); + nsIEventTarget* target = mParent->GetBackgroundEventTarget(); + MOZ_ASSERT(target != nullptr); + target->Dispatch(runnable, NS_DISPATCH_NORMAL); +} + +mozilla::ipc::IPCResult CamerasParent::RecvReleaseFrame( + mozilla::ipc::Shmem&& s) { + mShmemPool.Put(ShmemBuffer(s)); + return IPC_OK(); +} + +bool CamerasParent::SetupEngine(CaptureEngine aCapEngine) { + LOG("%s", __PRETTY_FUNCTION__); + StaticRefPtr<VideoEngine>& engine = sEngines[aCapEngine]; + + if (!engine) { + CaptureDeviceType captureDeviceType = CaptureDeviceType::Camera; + switch (aCapEngine) { + case ScreenEngine: + captureDeviceType = CaptureDeviceType::Screen; + break; + case BrowserEngine: + captureDeviceType = CaptureDeviceType::Browser; + break; + case WinEngine: + captureDeviceType = CaptureDeviceType::Window; + break; + case CameraEngine: + captureDeviceType = CaptureDeviceType::Camera; + break; + default: + LOG("Invalid webrtc Video engine"); + return false; + } + + engine = VideoEngine::Create(captureDeviceType); + + if (!engine) { + LOG("VideoEngine::Create failed"); + return false; + } + } + + if (aCapEngine == CameraEngine && !mCameraObserver) { + mCameraObserver = new InputObserver(this); + auto device_info = engine->GetOrCreateVideoCaptureDeviceInfo(); + MOZ_ASSERT(device_info); + if (device_info) { + device_info->RegisterVideoInputFeedBack(mCameraObserver); + } + } + + return true; +} + +void CamerasParent::CloseEngines() { + sThreadMonitor->AssertCurrentThreadOwns(); + LOG("%s", __PRETTY_FUNCTION__); + if (!mWebRTCAlive) { + return; + } + MOZ_ASSERT(sVideoCaptureThread->thread_id() == PlatformThread::CurrentId()); + + // Stop the callers + while (mCallbacks.Length()) { + auto capEngine = mCallbacks[0]->mCapEngine; + auto streamNum = mCallbacks[0]->mStreamId; + LOG("Forcing shutdown of engine %d, capturer %d", capEngine, streamNum); + StopCapture(capEngine, streamNum); + Unused << ReleaseCapture(capEngine, streamNum); + } + + StaticRefPtr<VideoEngine>& engine = sEngines[CameraEngine]; + if (engine && mCameraObserver) { + auto device_info = engine->GetOrCreateVideoCaptureDeviceInfo(); + MOZ_ASSERT(device_info); + if (device_info) { + device_info->DeRegisterVideoInputFeedBack(mCameraObserver); + } + mCameraObserver = nullptr; + } + + // CloseEngines() is protected by sThreadMonitor + sNumOfOpenCamerasParentEngines--; + if (sNumOfOpenCamerasParentEngines == 0) { + for (StaticRefPtr<VideoEngine>& engine : sEngines) { + if (engine) { + VideoEngine::Delete(engine); + engine = nullptr; + } + } + } + + mWebRTCAlive = false; +} + +VideoEngine* CamerasParent::EnsureInitialized(int aEngine) { + LOG_VERBOSE("%s", __PRETTY_FUNCTION__); + // We're shutting down, don't try to do new WebRTC ops. + if (!mWebRTCAlive) { + return nullptr; + } + CaptureEngine capEngine = static_cast<CaptureEngine>(aEngine); + if (!SetupEngine(capEngine)) { + LOG("CamerasParent failed to initialize engine"); + return nullptr; + } + + return sEngines[aEngine]; +} + +// Dispatch the runnable to do the camera operation on the +// specific Cameras thread, preventing us from blocking, and +// chain a runnable to send back the result on the IPC thread. +// It would be nice to get rid of the code duplication here, +// perhaps via Promises. +mozilla::ipc::IPCResult CamerasParent::RecvNumberOfCaptureDevices( + const CaptureEngine& aCapEngine) { + LOG("%s", __PRETTY_FUNCTION__); + LOG("CaptureEngine=%d", aCapEngine); + RefPtr<CamerasParent> self(this); + RefPtr<Runnable> webrtc_runnable = NewRunnableFrom([self, aCapEngine]() { + int num = -1; + if (auto engine = self->EnsureInitialized(aCapEngine)) { + if (auto devInfo = engine->GetOrCreateVideoCaptureDeviceInfo()) { + num = devInfo->NumberOfDevices(); + } + } + RefPtr<nsIRunnable> ipc_runnable = NewRunnableFrom([self, num]() { + if (!self->mChildIsAlive) { + LOG("RecvNumberOfCaptureDevices failure: child not alive"); + return NS_ERROR_FAILURE; + } + + if (num < 0) { + LOG("RecvNumberOfCaptureDevices couldn't find devices"); + Unused << self->SendReplyFailure(); + return NS_ERROR_FAILURE; + } + + LOG("RecvNumberOfCaptureDevices: %d", num); + Unused << self->SendReplyNumberOfCaptureDevices(num); + return NS_OK; + }); + self->mPBackgroundEventTarget->Dispatch(ipc_runnable, NS_DISPATCH_NORMAL); + return NS_OK; + }); + DispatchToVideoCaptureThread(webrtc_runnable); + return IPC_OK(); +} + +mozilla::ipc::IPCResult CamerasParent::RecvEnsureInitialized( + const CaptureEngine& aCapEngine) { + LOG("%s", __PRETTY_FUNCTION__); + + RefPtr<CamerasParent> self(this); + RefPtr<Runnable> webrtc_runnable = NewRunnableFrom([self, aCapEngine]() { + bool result = self->EnsureInitialized(aCapEngine); + + RefPtr<nsIRunnable> ipc_runnable = NewRunnableFrom([self, result]() { + if (!self->mChildIsAlive) { + LOG("RecvEnsureInitialized: child not alive"); + return NS_ERROR_FAILURE; + } + + if (!result) { + LOG("RecvEnsureInitialized failed"); + Unused << self->SendReplyFailure(); + return NS_ERROR_FAILURE; + } + + LOG("RecvEnsureInitialized succeeded"); + Unused << self->SendReplySuccess(); + return NS_OK; + }); + self->mPBackgroundEventTarget->Dispatch(ipc_runnable, NS_DISPATCH_NORMAL); + return NS_OK; + }); + DispatchToVideoCaptureThread(webrtc_runnable); + return IPC_OK(); +} + +mozilla::ipc::IPCResult CamerasParent::RecvNumberOfCapabilities( + const CaptureEngine& aCapEngine, const nsACString& unique_id) { + LOG("%s", __PRETTY_FUNCTION__); + LOG("Getting caps for %s", PromiseFlatCString(unique_id).get()); + + RefPtr<CamerasParent> self(this); + RefPtr<Runnable> webrtc_runnable = + NewRunnableFrom([self, unique_id = nsCString(unique_id), aCapEngine]() { + int num = -1; + if (auto engine = self->EnsureInitialized(aCapEngine)) { + if (auto devInfo = engine->GetOrCreateVideoCaptureDeviceInfo()) { + num = devInfo->NumberOfCapabilities(unique_id.get()); + } + } + RefPtr<nsIRunnable> ipc_runnable = NewRunnableFrom([self, num]() { + if (!self->mChildIsAlive) { + LOG("RecvNumberOfCapabilities: child not alive"); + return NS_ERROR_FAILURE; + } + + if (num < 0) { + LOG("RecvNumberOfCapabilities couldn't find capabilities"); + Unused << self->SendReplyFailure(); + return NS_ERROR_FAILURE; + } + + LOG("RecvNumberOfCapabilities: %d", num); + Unused << self->SendReplyNumberOfCapabilities(num); + return NS_OK; + }); + self->mPBackgroundEventTarget->Dispatch(ipc_runnable, + NS_DISPATCH_NORMAL); + return NS_OK; + }); + DispatchToVideoCaptureThread(webrtc_runnable); + return IPC_OK(); +} + +mozilla::ipc::IPCResult CamerasParent::RecvGetCaptureCapability( + const CaptureEngine& aCapEngine, const nsACString& unique_id, + const int& num) { + LOG("%s", __PRETTY_FUNCTION__); + LOG("RecvGetCaptureCapability: %s %d", PromiseFlatCString(unique_id).get(), + num); + + RefPtr<CamerasParent> self(this); + RefPtr<Runnable> webrtc_runnable = NewRunnableFrom( + [self, unique_id = nsCString(unique_id), aCapEngine, num]() { + webrtc::VideoCaptureCapability webrtcCaps; + int error = -1; + if (auto engine = self->EnsureInitialized(aCapEngine)) { + if (auto devInfo = engine->GetOrCreateVideoCaptureDeviceInfo()) { + error = devInfo->GetCapability(unique_id.get(), num, webrtcCaps); + } + + if (!error && aCapEngine == CameraEngine) { + auto iter = self->mAllCandidateCapabilities.find(unique_id); + if (iter == self->mAllCandidateCapabilities.end()) { + std::map<uint32_t, webrtc::VideoCaptureCapability> + candidateCapabilities; + candidateCapabilities.emplace(num, webrtcCaps); + self->mAllCandidateCapabilities.emplace(nsCString(unique_id), + candidateCapabilities); + } else { + (iter->second).emplace(num, webrtcCaps); + } + } + } + RefPtr<nsIRunnable> ipc_runnable = NewRunnableFrom([self, webrtcCaps, + error]() { + if (!self->mChildIsAlive) { + LOG("RecvGetCaptureCapability: child not alive"); + return NS_ERROR_FAILURE; + } + VideoCaptureCapability capCap( + webrtcCaps.width, webrtcCaps.height, webrtcCaps.maxFPS, + static_cast<int>(webrtcCaps.videoType), webrtcCaps.interlaced); + LOG("Capability: %u %u %u %d %d", webrtcCaps.width, webrtcCaps.height, + webrtcCaps.maxFPS, static_cast<int>(webrtcCaps.videoType), + webrtcCaps.interlaced); + if (error) { + LOG("RecvGetCaptureCapability: reply failure"); + Unused << self->SendReplyFailure(); + return NS_ERROR_FAILURE; + } + Unused << self->SendReplyGetCaptureCapability(capCap); + return NS_OK; + }); + self->mPBackgroundEventTarget->Dispatch(ipc_runnable, + NS_DISPATCH_NORMAL); + return NS_OK; + }); + DispatchToVideoCaptureThread(webrtc_runnable); + return IPC_OK(); +} + +mozilla::ipc::IPCResult CamerasParent::RecvGetCaptureDevice( + const CaptureEngine& aCapEngine, const int& aDeviceIndex) { + LOG("%s", __PRETTY_FUNCTION__); + + RefPtr<CamerasParent> self(this); + RefPtr<Runnable> webrtc_runnable = NewRunnableFrom([self, aCapEngine, + aDeviceIndex]() { + char deviceName[MediaEngineSource::kMaxDeviceNameLength]; + char deviceUniqueId[MediaEngineSource::kMaxUniqueIdLength]; + nsCString name; + nsCString uniqueId; + pid_t devicePid = 0; + int error = -1; + if (auto engine = self->EnsureInitialized(aCapEngine)) { + if (auto devInfo = engine->GetOrCreateVideoCaptureDeviceInfo()) { + error = devInfo->GetDeviceName( + aDeviceIndex, deviceName, sizeof(deviceName), deviceUniqueId, + sizeof(deviceUniqueId), nullptr, 0, &devicePid); + } + } + if (!error) { + name.Assign(deviceName); + uniqueId.Assign(deviceUniqueId); + } + RefPtr<nsIRunnable> ipc_runnable = + NewRunnableFrom([self, error, name, uniqueId, devicePid]() { + if (!self->mChildIsAlive) { + return NS_ERROR_FAILURE; + } + if (error) { + LOG("GetCaptureDevice failed: %d", error); + Unused << self->SendReplyFailure(); + return NS_ERROR_FAILURE; + } + bool scary = (devicePid == getpid()); + + LOG("Returning %s name %s id (pid = %d)%s", name.get(), + uniqueId.get(), devicePid, (scary ? " (scary)" : "")); + Unused << self->SendReplyGetCaptureDevice(name, uniqueId, scary); + return NS_OK; + }); + self->mPBackgroundEventTarget->Dispatch(ipc_runnable, NS_DISPATCH_NORMAL); + return NS_OK; + }); + DispatchToVideoCaptureThread(webrtc_runnable); + return IPC_OK(); +} + +// Find out whether the given window with id has permission to use the +// camera. If the permission is not persistent, we'll make it a one-shot by +// removing the (session) permission. +static bool HasCameraPermission(const uint64_t& aWindowId) { + MOZ_ASSERT(NS_IsMainThread()); + + RefPtr<dom::WindowGlobalParent> window = + dom::WindowGlobalParent::GetByInnerWindowId(aWindowId); + if (!window) { + // Could not find window by id + return false; + } + + // If we delegate permission from first party, we should use the top level + // window + if (StaticPrefs::permissions_delegation_enabled()) { + RefPtr<dom::BrowsingContext> topBC = window->BrowsingContext()->Top(); + window = topBC->Canonical()->GetCurrentWindowGlobal(); + } + + // Return false if the window is not the currently-active window for its + // BrowsingContext. + if (!window || !window->IsCurrentGlobal()) { + return false; + } + + nsIPrincipal* principal = window->DocumentPrincipal(); + if (principal->GetIsNullPrincipal()) { + return false; + } + + if (principal->IsSystemPrincipal()) { + return true; + } + + MOZ_ASSERT(principal->GetIsContentPrincipal()); + + nsresult rv; + // Name used with nsIPermissionManager + static const nsLiteralCString cameraPermission = "MediaManagerVideo"_ns; + nsCOMPtr<nsIPermissionManager> mgr = + do_GetService(NS_PERMISSIONMANAGER_CONTRACTID, &rv); + if (NS_WARN_IF(NS_FAILED(rv))) { + return false; + } + + uint32_t video = nsIPermissionManager::UNKNOWN_ACTION; + rv = mgr->TestExactPermissionFromPrincipal(principal, cameraPermission, + &video); + if (NS_WARN_IF(NS_FAILED(rv))) { + return false; + } + + bool allowed = (video == nsIPermissionManager::ALLOW_ACTION); + + // Session permissions are removed after one use. + if (allowed) { + mgr->RemoveFromPrincipal(principal, cameraPermission); + } + + return allowed; +} + +mozilla::ipc::IPCResult CamerasParent::RecvAllocateCapture( + const CaptureEngine& aCapEngine, const nsACString& unique_id, + const uint64_t& aWindowID) { + LOG("%s: Verifying permissions", __PRETTY_FUNCTION__); + RefPtr<CamerasParent> self(this); + RefPtr<Runnable> mainthread_runnable = NewRunnableFrom( + [self, aCapEngine, unique_id = nsCString(unique_id), aWindowID]() { + // Verify whether the claimed origin has received permission + // to use the camera, either persistently or this session (one shot). + bool allowed = HasCameraPermission(aWindowID); + if (!allowed) { + // Developer preference for turning off permission check. + if (Preferences::GetBool("media.navigator.permission.disabled", + false)) { + allowed = true; + LOG("No permission but checks are disabled"); + } else { + LOG("No camera permission for this origin"); + } + } + // After retrieving the permission (or not) on the main thread, + // bounce to the WebRTC thread to allocate the device (or not), + // then bounce back to the IPC thread for the reply to content. + RefPtr<Runnable> webrtc_runnable = + NewRunnableFrom([self, allowed, aCapEngine, unique_id]() { + int captureId = -1; + int error = -1; + if (allowed && self->EnsureInitialized(aCapEngine)) { + StaticRefPtr<VideoEngine>& engine = self->sEngines[aCapEngine]; + captureId = engine->CreateVideoCapture(unique_id.get()); + engine->WithEntry(captureId, + [&error](VideoEngine::CaptureEntry& cap) { + if (cap.VideoCapture()) { + error = 0; + } + }); + } + RefPtr<nsIRunnable> ipc_runnable = + NewRunnableFrom([self, captureId, error]() { + if (!self->mChildIsAlive) { + LOG("RecvAllocateCapture: child not alive"); + return NS_ERROR_FAILURE; + } + + if (error) { + Unused << self->SendReplyFailure(); + LOG("RecvAllocateCapture: WithEntry error"); + return NS_ERROR_FAILURE; + } + + LOG("Allocated device nr %d", captureId); + Unused << self->SendReplyAllocateCapture(captureId); + return NS_OK; + }); + self->mPBackgroundEventTarget->Dispatch(ipc_runnable, + NS_DISPATCH_NORMAL); + return NS_OK; + }); + self->DispatchToVideoCaptureThread(webrtc_runnable); + return NS_OK; + }); + NS_DispatchToMainThread(mainthread_runnable); + return IPC_OK(); +} + +int CamerasParent::ReleaseCapture(const CaptureEngine& aCapEngine, + int aCaptureId) { + int error = -1; + if (auto engine = EnsureInitialized(aCapEngine)) { + error = engine->ReleaseVideoCapture(aCaptureId); + } + return error; +} + +mozilla::ipc::IPCResult CamerasParent::RecvReleaseCapture( + const CaptureEngine& aCapEngine, const int& aCaptureId) { + LOG("%s", __PRETTY_FUNCTION__); + LOG("RecvReleaseCamera device nr %d", aCaptureId); + + RefPtr<CamerasParent> self(this); + RefPtr<Runnable> webrtc_runnable = NewRunnableFrom([self, aCapEngine, + aCaptureId]() { + int error = self->ReleaseCapture(aCapEngine, aCaptureId); + RefPtr<nsIRunnable> ipc_runnable = + NewRunnableFrom([self, error, aCaptureId]() { + if (!self->mChildIsAlive) { + LOG("RecvReleaseCapture: child not alive"); + return NS_ERROR_FAILURE; + } + + if (error) { + Unused << self->SendReplyFailure(); + LOG("RecvReleaseCapture: Failed to free device nr %d", aCaptureId); + return NS_ERROR_FAILURE; + } + + Unused << self->SendReplySuccess(); + LOG("Freed device nr %d", aCaptureId); + return NS_OK; + }); + self->mPBackgroundEventTarget->Dispatch(ipc_runnable, NS_DISPATCH_NORMAL); + return NS_OK; + }); + DispatchToVideoCaptureThread(webrtc_runnable); + return IPC_OK(); +} + +mozilla::ipc::IPCResult CamerasParent::RecvStartCapture( + const CaptureEngine& aCapEngine, const int& aCaptureId, + const VideoCaptureCapability& ipcCaps) { + LOG("%s", __PRETTY_FUNCTION__); + + RefPtr<CamerasParent> self(this); + RefPtr<Runnable> webrtc_runnable = NewRunnableFrom([self, aCapEngine, + aCaptureId, ipcCaps]() { + LOG("%s", __PRETTY_FUNCTION__); + CallbackHelper** cbh; + int error = -1; + if (self->EnsureInitialized(aCapEngine)) { + cbh = self->mCallbacks.AppendElement(new CallbackHelper( + static_cast<CaptureEngine>(aCapEngine), aCaptureId, self)); + + self->sEngines[aCapEngine]->WithEntry( + aCaptureId, [&aCaptureId, &aCapEngine, &error, &ipcCaps, &cbh, + self](VideoEngine::CaptureEntry& cap) { + webrtc::VideoCaptureCapability capability; + capability.width = ipcCaps.width(); + capability.height = ipcCaps.height(); + capability.maxFPS = ipcCaps.maxFPS(); + capability.videoType = + static_cast<webrtc::VideoType>(ipcCaps.videoType()); + capability.interlaced = ipcCaps.interlaced(); + +#ifndef FUZZING_SNAPSHOT + MOZ_DIAGNOSTIC_ASSERT(sDeviceUniqueIDs.find(aCaptureId) == + sDeviceUniqueIDs.end()); +#endif + sDeviceUniqueIDs.emplace(aCaptureId, + cap.VideoCapture()->CurrentDeviceName()); + +#ifndef FUZZING_SNAPSHOT + MOZ_DIAGNOSTIC_ASSERT(sAllRequestedCapabilities.find(aCaptureId) == + sAllRequestedCapabilities.end()); +#endif + sAllRequestedCapabilities.emplace(aCaptureId, capability); + + if (aCapEngine == CameraEngine) { + for (const auto& it : sDeviceUniqueIDs) { + if (strcmp(it.second, + cap.VideoCapture()->CurrentDeviceName()) == 0) { + capability.width = + std::max(capability.width, + sAllRequestedCapabilities[it.first].width); + capability.height = + std::max(capability.height, + sAllRequestedCapabilities[it.first].height); + capability.maxFPS = + std::max(capability.maxFPS, + sAllRequestedCapabilities[it.first].maxFPS); + } + } + + auto candidateCapabilities = self->mAllCandidateCapabilities.find( + nsCString(cap.VideoCapture()->CurrentDeviceName())); + if ((candidateCapabilities != + self->mAllCandidateCapabilities.end()) && + (!candidateCapabilities->second.empty())) { + int32_t minIdx = -1; + uint64_t minDistance = UINT64_MAX; + + for (auto& candidateCapability : + candidateCapabilities->second) { + if (candidateCapability.second.videoType != + capability.videoType) { + continue; + } + // The first priority is finding a suitable resolution. + // So here we raise the weight of width and height + uint64_t distance = + uint64_t(ResolutionFeasibilityDistance( + candidateCapability.second.width, capability.width)) + + uint64_t(ResolutionFeasibilityDistance( + candidateCapability.second.height, + capability.height)) + + uint64_t( + FeasibilityDistance(candidateCapability.second.maxFPS, + capability.maxFPS)); + if (distance < minDistance) { + minIdx = candidateCapability.first; + minDistance = distance; + } + } + MOZ_ASSERT(minIdx != -1); + capability = candidateCapabilities->second[minIdx]; + } + } else if (aCapEngine == ScreenEngine || + aCapEngine == BrowserEngine || aCapEngine == WinEngine) { + for (const auto& it : sDeviceUniqueIDs) { + if (strcmp(it.second, + cap.VideoCapture()->CurrentDeviceName()) == 0) { + capability.maxFPS = + std::max(capability.maxFPS, + sAllRequestedCapabilities[it.first].maxFPS); + } + } + } + + cap.VideoCapture()->SetTrackingId( + (*cbh)->mTrackingId.mUniqueInProcId); + error = cap.VideoCapture()->StartCapture(capability); + + if (!error) { + cap.VideoCapture()->RegisterCaptureDataCallback( + static_cast<rtc::VideoSinkInterface<webrtc::VideoFrame>*>( + *cbh)); + } else { + sDeviceUniqueIDs.erase(aCaptureId); + sAllRequestedCapabilities.erase(aCaptureId); + } + }); + } + RefPtr<nsIRunnable> ipc_runnable = NewRunnableFrom([self, error]() { + if (!self->mChildIsAlive) { + LOG("RecvStartCapture failure: child is not alive"); + return NS_ERROR_FAILURE; + } + + if (!error) { + Unused << self->SendReplySuccess(); + return NS_OK; + } + + LOG("RecvStartCapture failure: StartCapture failed"); + Unused << self->SendReplyFailure(); + return NS_ERROR_FAILURE; + }); + self->mPBackgroundEventTarget->Dispatch(ipc_runnable, NS_DISPATCH_NORMAL); + return NS_OK; + }); + DispatchToVideoCaptureThread(webrtc_runnable); + return IPC_OK(); +} + +mozilla::ipc::IPCResult CamerasParent::RecvFocusOnSelectedSource( + const CaptureEngine& aCapEngine, const int& aCaptureId) { + LOG("%s", __PRETTY_FUNCTION__); + RefPtr<Runnable> webrtc_runnable = NewRunnableFrom( + [self = RefPtr<CamerasParent>(this), aCapEngine, aCaptureId]() { + if (auto engine = self->EnsureInitialized(aCapEngine)) { + engine->WithEntry(aCaptureId, [self](VideoEngine::CaptureEntry& cap) { + if (cap.VideoCapture()) { + bool result = cap.VideoCapture()->FocusOnSelectedSource(); + RefPtr<nsIRunnable> ipc_runnable = NewRunnableFrom([self, + result]() { + if (!self->mChildIsAlive) { + LOG("RecvFocusOnSelectedSource failure: child is not alive"); + return NS_ERROR_FAILURE; + } + + if (result) { + Unused << self->SendReplySuccess(); + return NS_OK; + } + + Unused << self->SendReplyFailure(); + LOG("RecvFocusOnSelectedSource failure."); + return NS_ERROR_FAILURE; + }); + self->mPBackgroundEventTarget->Dispatch(ipc_runnable, + NS_DISPATCH_NORMAL); + } + }); + } + LOG("RecvFocusOnSelectedSource CameraParent not initialized"); + return NS_ERROR_FAILURE; + }); + DispatchToVideoCaptureThread(webrtc_runnable); + return IPC_OK(); +} + +void CamerasParent::StopCapture(const CaptureEngine& aCapEngine, + int aCaptureId) { + if (auto engine = EnsureInitialized(aCapEngine)) { + // we're removing elements, iterate backwards + for (size_t i = mCallbacks.Length(); i > 0; i--) { + if (mCallbacks[i - 1]->mCapEngine == aCapEngine && + mCallbacks[i - 1]->mStreamId == (uint32_t)aCaptureId) { + CallbackHelper* cbh = mCallbacks[i - 1]; + engine->WithEntry(aCaptureId, [cbh, &aCaptureId]( + VideoEngine::CaptureEntry& cap) { + if (cap.VideoCapture()) { + cap.VideoCapture()->DeRegisterCaptureDataCallback( + static_cast<rtc::VideoSinkInterface<webrtc::VideoFrame>*>(cbh)); + cap.VideoCapture()->StopCaptureIfAllClientsClose(); + + sDeviceUniqueIDs.erase(aCaptureId); + sAllRequestedCapabilities.erase(aCaptureId); + } + }); + + delete mCallbacks[i - 1]; + mCallbacks.RemoveElementAt(i - 1); + break; + } + } + } +} + +mozilla::ipc::IPCResult CamerasParent::RecvStopCapture( + const CaptureEngine& aCapEngine, const int& aCaptureId) { + LOG("%s", __PRETTY_FUNCTION__); + + RefPtr<CamerasParent> self(this); + RefPtr<Runnable> webrtc_runnable = + NewRunnableFrom([self, aCapEngine, aCaptureId]() { + self->StopCapture(aCapEngine, aCaptureId); + return NS_OK; + }); + nsresult rv = DispatchToVideoCaptureThread(webrtc_runnable); + if (!self->mChildIsAlive) { + if (NS_FAILED(rv)) { + return IPC_FAIL_NO_REASON(this); + } + } else { + if (NS_SUCCEEDED(rv)) { + if (!SendReplySuccess()) { + return IPC_FAIL_NO_REASON(this); + } + } else { + if (!SendReplyFailure()) { + return IPC_FAIL_NO_REASON(this); + } + } + } + return IPC_OK(); +} + +void CamerasParent::StopIPC() { + MOZ_ASSERT(!mDestroyed); + // Release shared memory now, it's our last chance + mShmemPool.Cleanup(this); + // We don't want to receive callbacks or anything if we can't + // forward them anymore anyway. + mChildIsAlive = false; + mDestroyed = true; +} + +void CamerasParent::ActorDestroy(ActorDestroyReason aWhy) { + // No more IPC from here + LOG("%s", __PRETTY_FUNCTION__); + StopIPC(); + // Shut down WebRTC (if we're not in full shutdown, else this + // will already have happened) + StopVideoCapture(); +} + +nsString CamerasParent::GetNewName() { + static std::atomic<uint64_t> counter{0}; + nsString name(u"CamerasParent "_ns); + name.AppendInt(++counter); + return name; +} + +NS_IMETHODIMP CamerasParent::BlockShutdown(nsIAsyncShutdownClient*) { + mPBackgroundEventTarget->Dispatch( + NS_NewRunnableFunction(__func__, [self = RefPtr(this)]() { + // Send__delete() can return failure if AddBlocker() registered this + // CamerasParent while RecvPCamerasConstructor() called Send__delete() + // because it noticed that AppShutdown had started. + (void)Send__delete__(self); + })); + return NS_OK; +} + +CamerasParent::CamerasParent() + : mName(GetNewName()), + mShmemPool(CaptureEngine::MaxEngine), + mPBackgroundEventTarget(GetCurrentSerialEventTarget()), + mChildIsAlive(true), + mDestroyed(false), + mWebRTCAlive(false) { + MOZ_ASSERT(mPBackgroundEventTarget != nullptr, + "GetCurrentThreadEventTarget failed"); + LOG("CamerasParent: %p", this); + StaticMutexAutoLock slock(sMutex); + + if (sNumOfCamerasParents++ == 0) { + sThreadMonitor = new Monitor("CamerasParent::sThreadMonitor"); + } +} + +// RecvPCamerasConstructor() is used because IPC messages, for +// Send__delete__(), cannot be sent from AllocPCamerasParent(). +ipc::IPCResult CamerasParent::RecvPCamerasConstructor() { + ipc::AssertIsOnBackgroundThread(); + + // A shutdown blocker must be added if sNumOfOpenCamerasParentEngines might + // be incremented to indicate ownership of an sVideoCaptureThread. + // If this task were queued after checking !IsInOrBeyond(AppShutdown), then + // shutdown may have proceeded on the main thread and so the task may run + // too late to add the blocker. + // Don't dispatch from the constructor a runnable that may toggle the + // reference count, because the IPC thread does not get a reference until + // after the constructor returns. + NS_DispatchToMainThread( + NS_NewRunnableFunction(__func__, [self = RefPtr(this)]() { + nsresult rv = MustGetShutdownBarrier()->AddBlocker( + self, NS_LITERAL_STRING_FROM_CSTRING(__FILE__), __LINE__, u""_ns); + LOG("AddBlocker returned 0x%x", static_cast<unsigned>(rv)); + // AddBlocker() will fail if called after all + // AsyncShutdown.profileBeforeChange conditions have resolved or been + // removed. + // + // The success of this AddBlocker() call is expected when an + // sVideoCaptureThread is created based on the assumption that at + // least one condition (e.g. nsIAsyncShutdownBlocker) added with + // AsyncShutdown.profileBeforeChange.addBlocker() will not resolve or + // be removed until it has queued a task and that task has run. + // (AyncShutdown.jsm's Spinner#observe() makes a similar assumption + // when it calls processNextEvent(), assuming that there will be some + // other event generated, before checking whether its Barrier.wait() + // promise has resolved.) + // + // If AppShutdown::IsInOrBeyond(AppShutdown) returned false, + // then this main thread task was queued before AppShutdown's + // sCurrentShutdownPhase is set to AppShutdown, + // which is before profile-before-change is notified, + // which is when AsyncShutdown conditions are run, + // which is when one condition would queue a task to resolve the + // condition or remove the blocker. + // That task runs after this task and before AsyncShutdown prevents + // further conditions being added through AddBlocker(). + MOZ_ASSERT(NS_SUCCEEDED(rv) || !self->mWebRTCAlive); + })); + + // AsyncShutdown barriers are available only for ShutdownPhases as late as + // XPCOMWillShutdown. The IPC background thread shuts down during + // XPCOMShutdownThreads, so actors may be created when AsyncShutdown + // barriers are no longer available. + // IsInOrBeyond() checks sCurrentShutdownPhase, which is atomic. + // ShutdownPhase::AppShutdown corresponds to profileBeforeChange used by + // MustGetShutdownBarrier() in the parent process. + if (AppShutdown::IsInOrBeyond(ShutdownPhase::AppShutdown)) { + // The usual blocker removal path depends on the existence of the + // `sVideoCaptureThread`, which is not ensured. Queue removal now. + NS_DispatchToMainThread( + NS_NewRunnableFunction(__func__, [self = RefPtr(this)]() { + // May fail if AddBlocker() failed. + (void)MustGetShutdownBarrier()->RemoveBlocker(self); + })); + return Send__delete__(this) ? IPC_OK() : IPC_FAIL(this, "Failed to send"); + } + + LOG("Spinning up WebRTC Cameras Thread"); + MonitorAutoLock lock(*sThreadMonitor); + if (sVideoCaptureThread == nullptr) { + MOZ_ASSERT(sNumOfOpenCamerasParentEngines == 0); + sVideoCaptureThread = new base::Thread("VideoCapture"); + base::Thread::Options options; +#if defined(_WIN32) + options.message_loop_type = MessageLoop::TYPE_MOZILLA_NONMAINUITHREAD; +#else + options.message_loop_type = MessageLoop::TYPE_MOZILLA_NONMAINTHREAD; +#endif + if (!sVideoCaptureThread->StartWithOptions(options)) { + MOZ_CRASH(); + } + } + mWebRTCAlive = true; + sNumOfOpenCamerasParentEngines++; + return IPC_OK(); +} + +CamerasParent::~CamerasParent() { + LOG("~CamerasParent: %p", this); + StaticMutexAutoLock slock(sMutex); + if (--sNumOfCamerasParents == 0) { + delete sThreadMonitor; + sThreadMonitor = nullptr; + } +} + +already_AddRefed<CamerasParent> CamerasParent::Create() { + mozilla::ipc::AssertIsOnBackgroundThread(); + return MakeAndAddRef<CamerasParent>(); +} + +} // namespace camera +} // namespace mozilla |