diff options
Diffstat (limited to 'dom/media/systemservices/CamerasChild.h')
| -rw-r--r-- | dom/media/systemservices/CamerasChild.h | 250 |
1 files changed, 250 insertions, 0 deletions
diff --git a/dom/media/systemservices/CamerasChild.h b/dom/media/systemservices/CamerasChild.h new file mode 100644 index 000000000..1530714e9 --- /dev/null +++ b/dom/media/systemservices/CamerasChild.h @@ -0,0 +1,250 @@ +/* -*- 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/. */ + +#ifndef mozilla_CamerasChild_h +#define mozilla_CamerasChild_h + +#include "mozilla/Move.h" +#include "mozilla/Pair.h" +#include "mozilla/dom/ContentChild.h" +#include "mozilla/camera/PCamerasChild.h" +#include "mozilla/camera/PCamerasParent.h" +#include "mozilla/media/DeviceChangeCallback.h" +#include "mozilla/Mutex.h" +#include "base/singleton.h" +#include "nsCOMPtr.h" + +// conflicts with #include of scoped_ptr.h +#undef FF +#include "webrtc/common.h" +// Video Engine +#include "webrtc/video_engine/include/vie_base.h" +#include "webrtc/video_engine/include/vie_capture.h" +#include "webrtc/video_engine/include/vie_render.h" + +namespace mozilla { + +namespace ipc { +class BackgroundChildImpl; +} + +namespace camera { + +struct CapturerElement { + CaptureEngine engine; + int id; + webrtc::ExternalRenderer* callback; +}; + +// Forward declaration so we can work with pointers to it. +class CamerasChild; +// Helper class in impl that we friend. +template <class T> class LockAndDispatch; + +// We emulate the sync webrtc.org API with the help of singleton +// CamerasSingleton, which manages a pointer to an IPC object, a thread +// where IPC operations should run on, and a mutex. +// The static function Cameras() will use that Singleton to set up, +// if needed, both the thread and the associated IPC objects and return +// a pointer to the IPC object. Users can then do IPC calls on that object +// after dispatching them to aforementioned thread. + +// 2 Threads are involved in this code: +// - the MediaManager thread, which will call the (static, sync API) functions +// through MediaEngineRemoteVideoSource +// - the Cameras IPC thread, which will be doing our IPC to the parent process +// via PBackground + +// Our main complication is that we emulate a sync API while (having to do) +// async messaging. We dispatch the messages to another thread to send them +// async and hold a Monitor to wait for the result to be asynchronously received +// again. The requirement for async messaging originates on the parent side: +// it's not reasonable to block all PBackground IPC there while waiting for +// something like device enumeration to complete. + +class CamerasSingleton { +public: + CamerasSingleton(); + ~CamerasSingleton(); + + static OffTheBooksMutex& Mutex() { + return gTheInstance.get()->mCamerasMutex; + } + + static CamerasChild*& Child() { + Mutex().AssertCurrentThreadOwns(); + return gTheInstance.get()->mCameras; + } + + static nsCOMPtr<nsIThread>& Thread() { + Mutex().AssertCurrentThreadOwns(); + return gTheInstance.get()->mCamerasChildThread; + } + + static nsCOMPtr<nsIThread>& FakeDeviceChangeEventThread() { + Mutex().AssertCurrentThreadOwns(); + return gTheInstance.get()->mFakeDeviceChangeEventThread; + } + +private: + static Singleton<CamerasSingleton> gTheInstance; + + // Reinitializing CamerasChild will change the pointers below. + // We don't want this to happen in the middle of preparing IPC. + // We will be alive on destruction, so this needs to be off the books. + mozilla::OffTheBooksMutex mCamerasMutex; + + // This is owned by the IPC code, and the same code controls the lifetime. + // It will set and clear this pointer as appropriate in setup/teardown. + // We'd normally make this a WeakPtr but unfortunately the IPC code already + // uses the WeakPtr mixin in a protected base class of CamerasChild, and in + // any case the object becomes unusable as soon as IPC is tearing down, which + // will be before actual destruction. + CamerasChild* mCameras; + nsCOMPtr<nsIThread> mCamerasChildThread; + nsCOMPtr<nsIThread> mFakeDeviceChangeEventThread; +}; + +// Get a pointer to a CamerasChild object we can use to do IPC with. +// This does everything needed to set up, including starting the IPC +// channel with PBackground, blocking until thats done, and starting the +// thread to do IPC on. This will fail if we're in shutdown. On success +// it will set up the CamerasSingleton. +CamerasChild* GetCamerasChild(); + +CamerasChild* GetCamerasChildIfExists(); + +// Shut down the IPC channel and everything associated, like WebRTC. +// This is a static call because the CamerasChild object may not even +// be alive when we're called. +void Shutdown(void); + +// Obtain the CamerasChild object (if possible, i.e. not shutting down), +// and maintain a grip on the object for the duration of the call. +template <class MEM_FUN, class... ARGS> +int GetChildAndCall(MEM_FUN&& f, ARGS&&... args) +{ + OffTheBooksMutexAutoLock lock(CamerasSingleton::Mutex()); + CamerasChild* child = GetCamerasChild(); + if (child) { + return (child->*f)(mozilla::Forward<ARGS>(args)...); + } else { + return -1; + } +} + +class CamerasChild final : public PCamerasChild + ,public DeviceChangeCallback +{ + friend class mozilla::ipc::BackgroundChildImpl; + template <class T> friend class mozilla::camera::LockAndDispatch; + +public: + // We are owned by the PBackground thread only. CamerasSingleton + // takes a non-owning reference. + NS_INLINE_DECL_REFCOUNTING(CamerasChild) + + // IPC messages recevied, received on the PBackground thread + // these are the actual callbacks with data + virtual bool RecvDeliverFrame(const CaptureEngine&, const int&, mozilla::ipc::Shmem&&, + const size_t&, const uint32_t&, const int64_t&, + const int64_t&) override; + virtual bool RecvFrameSizeChange(const CaptureEngine&, const int&, + const int& w, const int& h) override; + + virtual bool RecvDeviceChange() override; + virtual int AddDeviceChangeCallback(DeviceChangeCallback* aCallback) override; + int SetFakeDeviceChangeEvents(); + + // these are response messages to our outgoing requests + virtual bool RecvReplyNumberOfCaptureDevices(const int&) override; + virtual bool RecvReplyNumberOfCapabilities(const int&) override; + virtual bool RecvReplyAllocateCaptureDevice(const int&) override; + virtual bool RecvReplyGetCaptureCapability(const CaptureCapability& capability) override; + virtual bool RecvReplyGetCaptureDevice(const nsCString& device_name, + const nsCString& device_id, + const bool& scary) override; + virtual bool RecvReplyFailure(void) override; + virtual bool RecvReplySuccess(void) override; + virtual void ActorDestroy(ActorDestroyReason aWhy) override; + + // the webrtc.org ViECapture calls are mirrored here, but with access + // to a specific PCameras instance to communicate over. These also + // run on the MediaManager thread + int NumberOfCaptureDevices(CaptureEngine aCapEngine); + int NumberOfCapabilities(CaptureEngine aCapEngine, + const char* deviceUniqueIdUTF8); + int ReleaseCaptureDevice(CaptureEngine aCapEngine, + const int capture_id); + int StartCapture(CaptureEngine aCapEngine, + const int capture_id, webrtc::CaptureCapability& capability, + webrtc::ExternalRenderer* func); + int StopCapture(CaptureEngine aCapEngine, const int capture_id); + int AllocateCaptureDevice(CaptureEngine aCapEngine, + const char* unique_idUTF8, + const unsigned int unique_idUTF8Length, + int& capture_id, + const nsACString& aOrigin); + int GetCaptureCapability(CaptureEngine aCapEngine, + const char* unique_idUTF8, + const unsigned int capability_number, + webrtc::CaptureCapability& capability); + int GetCaptureDevice(CaptureEngine aCapEngine, + unsigned int list_number, char* device_nameUTF8, + const unsigned int device_nameUTF8Length, + char* unique_idUTF8, + const unsigned int unique_idUTF8Length, + bool* scary = nullptr); + void ShutdownAll(); + int EnsureInitialized(CaptureEngine aCapEngine); + + webrtc::ExternalRenderer* Callback(CaptureEngine aCapEngine, int capture_id); + +private: + CamerasChild(); + ~CamerasChild(); + // Dispatch a Runnable to the PCamerasParent, by executing it on the + // decidecated Cameras IPC/PBackground thread. + bool DispatchToParent(nsIRunnable* aRunnable, + MonitorAutoLock& aMonitor); + void AddCallback(const CaptureEngine aCapEngine, const int capture_id, + webrtc::ExternalRenderer* render); + void RemoveCallback(const CaptureEngine aCapEngine, const int capture_id); + void ShutdownParent(); + void ShutdownChild(); + + nsTArray<CapturerElement> mCallbacks; + // Protects the callback arrays + Mutex mCallbackMutex; + + bool mIPCIsAlive; + + // Hold to prevent multiple outstanding requests. We don't use + // request IDs so we only support one at a time. Don't want try + // to use the webrtc.org API from multiple threads simultanously. + // The monitor below isn't sufficient for this, as it will drop + // the lock when Wait-ing for a response, allowing us to send a new + // request. The Notify on receiving the response will then unblock + // both waiters and one will be guaranteed to get the wrong result. + // Take this one before taking mReplyMonitor. + Mutex mRequestMutex; + // Hold to wait for an async response to our calls + Monitor mReplyMonitor; + // Async response valid? + bool mReceivedReply; + // Async responses data contents; + bool mReplySuccess; + int mReplyInteger; + webrtc::CaptureCapability mReplyCapability; + nsCString mReplyDeviceName; + nsCString mReplyDeviceID; + bool mReplyScary; +}; + +} // namespace camera +} // namespace mozilla + +#endif // mozilla_CamerasChild_h |