summaryrefslogtreecommitdiffstats
path: root/netwerk/protocol/device/AndroidCaptureProvider.cpp
diff options
context:
space:
mode:
authorMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
committerMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
commit5f8de423f190bbb79a62f804151bc24824fa32d8 (patch)
tree10027f336435511475e392454359edea8e25895d /netwerk/protocol/device/AndroidCaptureProvider.cpp
parent49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff)
downloadUXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.lz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.xz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.zip
Add m-esr52 at 52.6.0
Diffstat (limited to 'netwerk/protocol/device/AndroidCaptureProvider.cpp')
-rw-r--r--netwerk/protocol/device/AndroidCaptureProvider.cpp301
1 files changed, 301 insertions, 0 deletions
diff --git a/netwerk/protocol/device/AndroidCaptureProvider.cpp b/netwerk/protocol/device/AndroidCaptureProvider.cpp
new file mode 100644
index 000000000..e69766085
--- /dev/null
+++ b/netwerk/protocol/device/AndroidCaptureProvider.cpp
@@ -0,0 +1,301 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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 "base/basictypes.h"
+#include "AndroidCaptureProvider.h"
+#include "nsXULAppAPI.h"
+#include "nsStreamUtils.h"
+#include "nsThreadUtils.h"
+#include "nsMemory.h"
+#include "RawStructs.h"
+
+// The maximum number of frames we keep in our queue. Don't live in the past.
+#define MAX_FRAMES_QUEUED 10
+
+using namespace mozilla::net;
+
+NS_IMPL_ISUPPORTS(AndroidCameraInputStream, nsIInputStream, nsIAsyncInputStream)
+
+AndroidCameraInputStream::AndroidCameraInputStream() :
+ mWidth(0), mHeight(0), mCamera(0), mHeaderSent(false), mClosed(true), mFrameSize(0),
+ mMonitor("AndroidCamera.Monitor")
+{
+ mAvailable = sizeof(RawVideoHeader);
+ mFrameQueue = new nsDeque();
+}
+
+AndroidCameraInputStream::~AndroidCameraInputStream() {
+ // clear the frame queue
+ while (mFrameQueue->GetSize() > 0) {
+ free(mFrameQueue->PopFront());
+ }
+ delete mFrameQueue;
+}
+
+NS_IMETHODIMP
+AndroidCameraInputStream::Init(nsACString& aContentType, nsCaptureParams* aParams)
+{
+ if (!XRE_IsParentProcess())
+ return NS_ERROR_NOT_IMPLEMENTED;
+
+ mContentType = aContentType;
+ mWidth = aParams->width;
+ mHeight = aParams->height;
+ mCamera = aParams->camera;
+
+ CameraStreamImpl *impl = CameraStreamImpl::GetInstance(0);
+ if (!impl)
+ return NS_ERROR_OUT_OF_MEMORY;
+ if (impl->Init(mContentType, mCamera, mWidth, mHeight, this)) {
+ mWidth = impl->GetWidth();
+ mHeight = impl->GetHeight();
+ mClosed = false;
+ }
+ return NS_OK;
+}
+
+void AndroidCameraInputStream::ReceiveFrame(char* frame, uint32_t length) {
+ {
+ mozilla::ReentrantMonitorAutoEnter autoMonitor(mMonitor);
+ if (mFrameQueue->GetSize() > MAX_FRAMES_QUEUED) {
+ free(mFrameQueue->PopFront());
+ mAvailable -= mFrameSize;
+ }
+ }
+
+ mFrameSize = sizeof(RawPacketHeader) + length;
+
+ char* fullFrame = (char*)moz_xmalloc(mFrameSize);
+
+ if (!fullFrame)
+ return;
+
+ RawPacketHeader* header = (RawPacketHeader*) fullFrame;
+ header->packetID = 0xFF;
+ header->codecID = 0x595556; // "YUV"
+
+ // we copy the Y plane, and de-interlace the CrCb
+
+ uint32_t yFrameSize = mWidth * mHeight;
+ uint32_t uvFrameSize = yFrameSize / 4;
+
+ memcpy(fullFrame + sizeof(RawPacketHeader), frame, yFrameSize);
+
+ char* uFrame = fullFrame + yFrameSize;
+ char* vFrame = fullFrame + yFrameSize + uvFrameSize;
+ char* yFrame = frame + yFrameSize;
+ for (uint32_t i = 0; i < uvFrameSize; i++) {
+ uFrame[i] = yFrame[2 * i + 1];
+ vFrame[i] = yFrame[2 * i];
+ }
+
+ {
+ mozilla::ReentrantMonitorAutoEnter autoMonitor(mMonitor);
+ mAvailable += mFrameSize;
+ mFrameQueue->Push((void*)fullFrame);
+ }
+
+ NotifyListeners();
+}
+
+NS_IMETHODIMP
+AndroidCameraInputStream::Available(uint64_t *aAvailable)
+{
+ mozilla::ReentrantMonitorAutoEnter autoMonitor(mMonitor);
+
+ *aAvailable = mAvailable;
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP AndroidCameraInputStream::IsNonBlocking(bool *aNonBlock) {
+ *aNonBlock = true;
+ return NS_OK;
+}
+
+NS_IMETHODIMP AndroidCameraInputStream::Read(char *aBuffer, uint32_t aCount, uint32_t *aRead) {
+ return ReadSegments(NS_CopySegmentToBuffer, aBuffer, aCount, aRead);
+}
+
+NS_IMETHODIMP AndroidCameraInputStream::ReadSegments(nsWriteSegmentFun aWriter, void *aClosure, uint32_t aCount, uint32_t *aRead) {
+ *aRead = 0;
+
+ nsresult rv;
+
+ if (mAvailable == 0)
+ return NS_BASE_STREAM_WOULD_BLOCK;
+
+ if (aCount > mAvailable)
+ aCount = mAvailable;
+
+ if (!mHeaderSent) {
+ CameraStreamImpl *impl = CameraStreamImpl::GetInstance(0);
+ RawVideoHeader header;
+ header.headerPacketID = 0;
+ header.codecID = 0x595556; // "YUV"
+ header.majorVersion = 0;
+ header.minorVersion = 1;
+ header.options = 1 | 1 << 1; // color, 4:2:2
+
+ header.alphaChannelBpp = 0;
+ header.lumaChannelBpp = 8;
+ header.chromaChannelBpp = 4;
+ header.colorspace = 1;
+
+ header.frameWidth = mWidth;
+ header.frameHeight = mHeight;
+ header.aspectNumerator = 1;
+ header.aspectDenominator = 1;
+
+ header.framerateNumerator = impl->GetFps();
+ header.framerateDenominator = 1;
+
+ rv = aWriter(this, aClosure, (const char*)&header, 0, sizeof(RawVideoHeader), aRead);
+
+ if (NS_FAILED(rv))
+ return NS_OK;
+
+ mHeaderSent = true;
+ aCount -= sizeof(RawVideoHeader);
+ mAvailable -= sizeof(RawVideoHeader);
+ }
+
+ {
+ mozilla::ReentrantMonitorAutoEnter autoMonitor(mMonitor);
+ while ((mAvailable > 0) && (aCount >= mFrameSize)) {
+ uint32_t readThisTime = 0;
+
+ char* frame = (char*)mFrameQueue->PopFront();
+ rv = aWriter(this, aClosure, (const char*)frame, *aRead, mFrameSize, &readThisTime);
+
+ if (readThisTime != mFrameSize) {
+ mFrameQueue->PushFront((void*)frame);
+ return NS_OK;
+ }
+
+ // RawReader does a copy when calling VideoData::Create()
+ free(frame);
+
+ if (NS_FAILED(rv))
+ return NS_OK;
+
+ aCount -= readThisTime;
+ mAvailable -= readThisTime;
+ *aRead += readThisTime;
+ }
+ }
+ return NS_OK;
+}
+
+NS_IMETHODIMP AndroidCameraInputStream::Close() {
+ return CloseWithStatus(NS_OK);
+}
+
+
+/**
+ * must be called on the main (java) thread
+ */
+void AndroidCameraInputStream::doClose() {
+ NS_ASSERTION(!mClosed, "Camera is already closed");
+
+ CameraStreamImpl *impl = CameraStreamImpl::GetInstance(0);
+ impl->Close();
+ mClosed = true;
+}
+
+
+void AndroidCameraInputStream::NotifyListeners() {
+ mozilla::ReentrantMonitorAutoEnter autoMonitor(mMonitor);
+
+ if (mCallback && (mAvailable > sizeof(RawVideoHeader))) {
+ nsCOMPtr<nsIInputStreamCallback> callback;
+ if (mCallbackTarget) {
+ callback = NS_NewInputStreamReadyEvent(mCallback, mCallbackTarget);
+ } else {
+ callback = mCallback;
+ }
+
+ NS_ASSERTION(callback, "Shouldn't fail to make the callback!");
+
+ // Null the callback first because OnInputStreamReady may reenter AsyncWait
+ mCallback = nullptr;
+ mCallbackTarget = nullptr;
+
+ callback->OnInputStreamReady(this);
+ }
+}
+
+NS_IMETHODIMP AndroidCameraInputStream::AsyncWait(nsIInputStreamCallback *aCallback, uint32_t aFlags, uint32_t aRequestedCount, nsIEventTarget *aTarget)
+{
+ if (aFlags != 0)
+ return NS_ERROR_NOT_IMPLEMENTED;
+
+ if (mCallback || mCallbackTarget)
+ return NS_ERROR_UNEXPECTED;
+
+ mCallbackTarget = aTarget;
+ mCallback = aCallback;
+
+ // What we are being asked for may be present already
+ NotifyListeners();
+ return NS_OK;
+}
+
+
+NS_IMETHODIMP AndroidCameraInputStream::CloseWithStatus(nsresult status)
+{
+ AndroidCameraInputStream::doClose();
+ return NS_OK;
+}
+
+/**
+ * AndroidCaptureProvider implementation
+ */
+
+NS_IMPL_ISUPPORTS0(AndroidCaptureProvider)
+
+AndroidCaptureProvider* AndroidCaptureProvider::sInstance = nullptr;
+
+AndroidCaptureProvider::AndroidCaptureProvider() {
+}
+
+AndroidCaptureProvider::~AndroidCaptureProvider() {
+ AndroidCaptureProvider::sInstance = nullptr;
+}
+
+nsresult AndroidCaptureProvider::Init(nsACString& aContentType,
+ nsCaptureParams* aParams,
+ nsIInputStream** aStream) {
+
+ NS_ENSURE_ARG_POINTER(aParams);
+
+ NS_ASSERTION(aParams->frameLimit == 0 || aParams->timeLimit == 0,
+ "Cannot set both a frame limit and a time limit!");
+
+ RefPtr<AndroidCameraInputStream> stream;
+
+ if (aContentType.EqualsLiteral("video/x-raw-yuv")) {
+ stream = new AndroidCameraInputStream();
+ if (stream) {
+ nsresult rv = stream->Init(aContentType, aParams);
+ if (NS_FAILED(rv))
+ return rv;
+ }
+ else
+ return NS_ERROR_OUT_OF_MEMORY;
+ } else {
+ NS_NOTREACHED("Should not have asked Android for this type!");
+ }
+ stream.forget(aStream);
+ return NS_OK;
+}
+
+already_AddRefed<AndroidCaptureProvider> GetAndroidCaptureProvider() {
+ if (!AndroidCaptureProvider::sInstance) {
+ AndroidCaptureProvider::sInstance = new AndroidCaptureProvider();
+ }
+ RefPtr<AndroidCaptureProvider> ret = AndroidCaptureProvider::sInstance;
+ return ret.forget();
+}