private int m_actualPreviewBuffer = 0;
private final ReentrantLock m_buffersLock = new ReentrantLock();
private boolean m_isReleased = false;
+ private boolean m_fetchEachFrame = false;
private static final String TAG = "Qt Camera";
}
}
+ public void fetchEachFrame(boolean fetch)
+ {
+ m_fetchEachFrame = fetch;
+ }
+
public void startPreview()
{
Camera.Size previewSize = m_camera.getParameters().getPreviewSize();
public void onPreviewFrame(byte[] data, Camera camera)
{
m_buffersLock.lock();
+
+ if (data != null && m_fetchEachFrame)
+ notifyFrameFetched(m_cameraId, data);
+
if (data == m_cameraPreviewFirstBuffer)
m_actualPreviewBuffer = 1;
else if (data == m_cameraPreviewSecondBuffer)
private static native void notifyAutoFocusComplete(int id, boolean success);
private static native void notifyPictureExposed(int id);
private static native void notifyPictureCaptured(int id, byte[] data);
+ private static native void notifyFrameFetched(int id, byte[] data);
}
$$PWD/qandroidaudioencodersettingscontrol.cpp \
$$PWD/qandroidmediacontainercontrol.cpp \
$$PWD/qandroidvideoencodersettingscontrol.cpp \
- $$PWD/qandroidaudioinputselectorcontrol.cpp
+ $$PWD/qandroidaudioinputselectorcontrol.cpp \
+ $$PWD/qandroidmediavideoprobecontrol.cpp
HEADERS += \
$$PWD/qandroidcaptureservice.h \
$$PWD/qandroidaudioencodersettingscontrol.h \
$$PWD/qandroidmediacontainercontrol.h \
$$PWD/qandroidvideoencodersettingscontrol.h \
- $$PWD/qandroidaudioinputselectorcontrol.h
+ $$PWD/qandroidaudioinputselectorcontrol.h \
+ $$PWD/qandroidmediavideoprobecontrol.h
#include "jcamera.h"
#include "jmultimediautils.h"
#include "qandroidvideooutput.h"
+#include "qandroidmediavideoprobecontrol.h"
#include "qandroidmultimediautils.h"
#include <QtConcurrent/qtconcurrentrun.h>
#include <qfile.h>
#include <qguiapplication.h>
#include <qdebug.h>
+#include <qvideoframe.h>
QT_BEGIN_NAMESPACE
if (m_camera) {
connect(m_camera, SIGNAL(pictureExposed()), this, SLOT(onCameraPictureExposed()));
connect(m_camera, SIGNAL(previewFetched(QByteArray)), this, SLOT(onCameraPreviewFetched(QByteArray)));
+ connect(m_camera, SIGNAL(frameFetched(QByteArray)),
+ this, SLOT(onCameraFrameFetched(QByteArray)),
+ Qt::DirectConnection);
connect(m_camera, SIGNAL(pictureCaptured(QByteArray)), this, SLOT(onCameraPictureCaptured(QByteArray)));
connect(m_camera, SIGNAL(previewStarted()), this, SLOT(onCameraPreviewStarted()));
connect(m_camera, SIGNAL(previewStopped()), this, SLOT(onCameraPreviewStopped()));
if (m_camera->getPreviewFormat() != JCamera::NV21)
m_camera->setPreviewFormat(JCamera::NV21);
+ m_camera->fetchEachFrame(m_videoProbes.count());
+
emit opened();
} else {
m_status = QCamera::UnavailableStatus;
return rotation;
}
+void QAndroidCameraSession::addProbe(QAndroidMediaVideoProbeControl *probe)
+{
+ m_videoProbesMutex.lock();
+ if (probe)
+ m_videoProbes << probe;
+ if (m_camera)
+ m_camera->fetchEachFrame(m_videoProbes.count());
+ m_videoProbesMutex.unlock();
+}
+
+void QAndroidCameraSession::removeProbe(QAndroidMediaVideoProbeControl *probe)
+{
+ m_videoProbesMutex.lock();
+ m_videoProbes.remove(probe);
+ if (m_camera)
+ m_camera->fetchEachFrame(m_videoProbes.count());
+ m_videoProbesMutex.unlock();
+}
+
void QAndroidCameraSession::applyImageSettings()
{
if (!m_camera || !m_imageSettingsDirty)
}
}
+void QAndroidCameraSession::onCameraFrameFetched(const QByteArray &frame)
+{
+ m_videoProbesMutex.lock();
+ if (frame.size() && m_videoProbes.count()) {
+ QVideoFrame videoFrame(new DataVideoBuffer(frame),
+ m_camera->previewSize(),
+ QVideoFrame::Format_NV21);
+ foreach (QAndroidMediaVideoProbeControl *probe, m_videoProbes)
+ probe->newFrameProbed(videoFrame);
+ }
+ m_videoProbesMutex.unlock();
+}
+
void QAndroidCameraSession::onCameraPictureCaptured(const QByteArray &data)
{
if (!m_captureCanceled) {
void QAndroidCameraSession::processPreviewImage(int id, const QByteArray &data, int rotation)
{
+ emit imageCaptured(id, prepareImageFromPreviewData(data, rotation));
+}
+
+QImage QAndroidCameraSession::prepareImageFromPreviewData(const QByteArray &data, int rotation)
+{
QSize frameSize = m_camera->previewSize();
- QImage preview(frameSize, QImage::Format_ARGB32);
+ QImage result(frameSize, QImage::Format_ARGB32);
qt_convert_NV21_to_ARGB32((const uchar *)data.constData(),
- (quint32 *)preview.bits(),
+ (quint32 *)result.bits(),
frameSize.width(),
frameSize.height());
transform.rotate(rotation);
- preview = preview.transformed(transform);
+ result = result.transformed(transform);
- emit imageCaptured(id, preview);
+ return result;
}
void QAndroidCameraSession::onVideoOutputReady(bool ready)
#include <qcamera.h>
#include <qmediaencodersettings.h>
#include <QCameraImageCapture>
+#include <QSet>
+#include <QMutex>
#include "qandroidmediastoragelocation.h"
QT_BEGIN_NAMESPACE
class JCamera;
class QAndroidVideoOutput;
+class QAndroidMediaVideoProbeControl;
class QAndroidCameraSession : public QObject
{
int currentCameraRotation() const;
+ void addProbe(QAndroidMediaVideoProbeControl *probe);
+ void removeProbe(QAndroidMediaVideoProbeControl *probe);
+
Q_SIGNALS:
void statusChanged(QCamera::Status status);
void stateChanged(QCamera::State);
void onCameraPictureExposed();
void onCameraPreviewFetched(const QByteArray &preview);
+ void onCameraFrameFetched(const QByteArray &frame);
void onCameraPictureCaptured(const QByteArray &data);
void onCameraPreviewStarted();
void onCameraPreviewStopped();
void applyImageSettings();
void processPreviewImage(int id, const QByteArray &data, int rotation);
+ QImage prepareImageFromPreviewData(const QByteArray &data, int rotation);
void processCapturedImage(int id,
const QByteArray &data,
const QSize &resolution,
QString m_currentImageCaptureFileName;
QAndroidMediaStorageLocation m_mediaStorageLocation;
+
+ QSet<QAndroidMediaVideoProbeControl *> m_videoProbes;
+ QMutex m_videoProbesMutex;
};
QT_END_NAMESPACE
#include "qandroidaudioencodersettingscontrol.h"
#include "qandroidvideoencodersettingscontrol.h"
#include "qandroidmediacontainercontrol.h"
+#include "qandroidmediavideoprobecontrol.h"
#include <qmediaserviceproviderplugin.h>
return m_videoRendererControl;
}
+ if (qstrcmp(name,QMediaVideoProbeControl_iid) == 0) {
+ QAndroidMediaVideoProbeControl *videoProbe = 0;
+ if (m_cameraSession) {
+ videoProbe = new QAndroidMediaVideoProbeControl(this);
+ m_cameraSession->addProbe(videoProbe);
+ }
+ return videoProbe;
+ }
+
return 0;
}
void QAndroidCaptureService::releaseControl(QMediaControl *control)
{
- if (control && control == m_videoRendererControl) {
- m_cameraSession->setVideoPreview(0);
- delete m_videoRendererControl;
- m_videoRendererControl = 0;
+ if (control) {
+ if (control == m_videoRendererControl) {
+ m_cameraSession->setVideoPreview(0);
+ delete m_videoRendererControl;
+ m_videoRendererControl = 0;
+ return;
+ }
+
+ QAndroidMediaVideoProbeControl *videoProbe = qobject_cast<QAndroidMediaVideoProbeControl *>(control);
+ if (videoProbe) {
+ if (m_cameraSession)
+ m_cameraSession->removeProbe(videoProbe);
+ delete videoProbe;
+ return;
+ }
}
+
}
QT_END_NAMESPACE
--- /dev/null
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Copyright (C) 2013 Integrated Computer Solutions, Inc
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia. For licensing terms and
+** conditions see http://qt.digia.com/licensing. For further information
+** use the contact form at http://qt.digia.com/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Digia gives you certain additional
+** rights. These rights are described in the Digia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qandroidmediavideoprobecontrol.h"
+#include <qvideoframe.h>
+
+QAndroidMediaVideoProbeControl::QAndroidMediaVideoProbeControl(QObject *parent) :
+ QMediaVideoProbeControl(parent)
+{
+}
+
+QAndroidMediaVideoProbeControl::~QAndroidMediaVideoProbeControl()
+{
+
+}
+
+void QAndroidMediaVideoProbeControl::newFrameProbed(const QVideoFrame &frame)
+{
+ emit videoFrameProbed(frame);
+}
--- /dev/null
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Copyright (C) 2013 Integrated Computer Solutions, Inc
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia. For licensing terms and
+** conditions see http://qt.digia.com/licensing. For further information
+** use the contact form at http://qt.digia.com/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Digia gives you certain additional
+** rights. These rights are described in the Digia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QANDROIDMEDIAVIDEOPROBECONTROL_H
+#define QANDROIDMEDIAVIDEOPROBECONTROL_H
+
+#include <qmediavideoprobecontrol.h>
+
+class QAndroidMediaVideoProbeControl : public QMediaVideoProbeControl
+{
+ Q_OBJECT
+public:
+ explicit QAndroidMediaVideoProbeControl(QObject *parent = 0);
+ virtual ~QAndroidMediaVideoProbeControl();
+
+ void newFrameProbed(const QVideoFrame& frame);
+
+};
+
+#endif // QANDROIDMEDIAVIDEOPROBECONTROL_H
}
}
+static void notifyFrameFetched(JNIEnv *env, jobject, int id, jbyteArray data)
+{
+ g_objectMapMutex.lock();
+ JCamera *obj = g_objectMap.value(id, 0);
+ g_objectMapMutex.unlock();
+ if (obj) {
+ QByteArray bytes;
+ int arrayLength = env->GetArrayLength(data);
+ bytes.resize(arrayLength);
+ env->GetByteArrayRegion(data, 0, arrayLength, (jbyte*)bytes.data());
+
+ Q_EMIT obj->frameFetched(bytes);
+ }
+}
+
class JCameraInstantiator : public QObject
{
Q_OBJECT
Q_INVOKABLE void startPreview();
Q_INVOKABLE void stopPreview();
+ Q_INVOKABLE void fetchEachFrame(bool fetch);
Q_INVOKABLE void fetchLastPreviewFrame();
Q_INVOKABLE void applyParameters();
QMetaObject::invokeMethod(d, "callVoidMethod", Q_ARG(QByteArray, "takePicture"));
}
+void JCamera::fetchEachFrame(bool fetch)
+{
+ QMetaObject::invokeMethod(d, "fetchEachFrame", Q_ARG(bool, fetch));
+}
+
void JCamera::fetchLastPreviewFrame()
{
QMetaObject::invokeMethod(d, "fetchLastPreviewFrame");
emit previewStopped();
}
+void JCameraWorker::fetchEachFrame(bool fetch)
+{
+ callMethod<void>("fetchEachFrame", "(Z)V", fetch);
+}
+
void JCameraWorker::fetchLastPreviewFrame()
{
QJNIEnvironmentPrivate env;
static JNINativeMethod methods[] = {
{"notifyAutoFocusComplete", "(IZ)V", (void *)notifyAutoFocusComplete},
{"notifyPictureExposed", "(I)V", (void *)notifyPictureExposed},
- {"notifyPictureCaptured", "(I[B)V", (void *)notifyPictureCaptured}
+ {"notifyPictureCaptured", "(I[B)V", (void *)notifyPictureCaptured},
+ {"notifyFrameFetched", "(I[B)V", (void *)notifyFrameFetched}
};
bool JCamera::initJNI(JNIEnv *env)
void takePicture();
+ void fetchEachFrame(bool fetch);
void fetchLastPreviewFrame();
QJNIObjectPrivate getCameraObject();
void pictureExposed();
void pictureCaptured(const QByteArray &data);
void previewFetched(const QByteArray &preview);
+ void frameFetched(const QByteArray &frame);
private:
JCamera(int cameraId, jobject cam, QThread *workerThread);