Revision control
Copy as Markdown
// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
#include "qandroidcapturesession_p.h"
#include "androidcamera_p.h"
#include "qandroidcamerasession_p.h"
#include "qaudioinput.h"
#include "qaudiooutput.h"
#include "androidmediaplayer_p.h"
#include "androidmultimediautils_p.h"
#include "qandroidmultimediautils_p.h"
#include "qandroidvideooutput_p.h"
#include "qandroidglobal_p.h"
#include <private/qplatformaudioinput_p.h>
#include <private/qplatformaudiooutput_p.h>
#include <private/qmediarecorder_p.h>
#include <private/qmediastoragelocation_p.h>
#include <QtMultimedia/private/qmultimedia_ranges_p.h>
#include <algorithm>
QT_BEGIN_NAMESPACE
namespace ranges = QtMultimediaPrivate::ranges;
QAndroidCaptureSession::QAndroidCaptureSession()
: QObject()
, m_mediaRecorder(0)
, m_cameraSession(0)
, m_duration(0)
, m_state(QMediaRecorder::StoppedState)
, m_outputFormat(AndroidMediaRecorder::DefaultOutputFormat)
, m_audioEncoder(AndroidMediaRecorder::DefaultAudioEncoder)
, m_videoEncoder(AndroidMediaRecorder::DefaultVideoEncoder)
{
m_notifyTimer.setInterval(1000);
connect(&m_notifyTimer, &QTimer::timeout, this, &QAndroidCaptureSession::updateDuration);
}
QAndroidCaptureSession::~QAndroidCaptureSession()
{
stop();
m_mediaRecorder = nullptr;
if (m_audioInput && m_audioOutput)
AndroidMediaPlayer::stopSoundStreaming();
}
void QAndroidCaptureSession::setCameraSession(QAndroidCameraSession *cameraSession)
{
if (m_cameraSession) {
disconnect(m_connOpenCamera);
disconnect(m_connActiveChangedCamera);
}
m_cameraSession = cameraSession;
if (m_cameraSession) {
m_connOpenCamera = connect(cameraSession, &QAndroidCameraSession::opened,
this, &QAndroidCaptureSession::onCameraOpened);
m_connActiveChangedCamera = connect(cameraSession, &QAndroidCameraSession::activeChanged,
this, [this](bool isActive) {
if (!isActive)
stop();
});
}
}
void QAndroidCaptureSession::setAudioInput(QPlatformAudioInput *input)
{
if (m_audioInput == input)
return;
if (m_audioInput) {
disconnect(m_audioInputChanged);
}
m_audioInput = input;
if (m_audioInput) {
m_audioInputChanged = connect(m_audioInput->q, &QAudioInput::deviceChanged, this, [this]() {
if (m_state == QMediaRecorder::RecordingState)
m_mediaRecorder->setAudioInput(m_audioInput->device.id());
updateStreamingState();
});
}
updateStreamingState();
}
void QAndroidCaptureSession::setAudioOutput(QPlatformAudioOutput *output)
{
if (m_audioOutput == output)
return;
if (m_audioOutput)
disconnect(m_audioOutputChanged);
m_audioOutput = output;
if (m_audioOutput) {
m_audioOutputChanged = connect(m_audioOutput->q, &QAudioOutput::deviceChanged, this,
[this] () {
AndroidMediaPlayer::setAudioOutput(m_audioOutput->device.id());
updateStreamingState();
});
AndroidMediaPlayer::setAudioOutput(m_audioOutput->device.id());
}
updateStreamingState();
}
void QAndroidCaptureSession::updateStreamingState()
{
if (m_audioInput && m_audioOutput) {
AndroidMediaPlayer::startSoundStreaming(m_audioInput->device.id().toInt(),
m_audioOutput->device.id().toInt());
} else {
AndroidMediaPlayer::stopSoundStreaming();
}
}
QMediaRecorder::RecorderState QAndroidCaptureSession::state() const
{
return m_state;
}
void QAndroidCaptureSession::setKeepAlive(bool keepAlive)
{
if (m_cameraSession)
m_cameraSession->setKeepAlive(keepAlive);
}
void QAndroidCaptureSession::start(QMediaEncoderSettings &settings, const QUrl &outputLocation)
{
if (m_state == QMediaRecorder::RecordingState)
return;
if (!m_cameraSession && !m_audioInput) {
updateError(QMediaRecorder::ResourceError, QLatin1String("No devices are set"));
return;
}
setKeepAlive(true);
const bool validCameraSession = m_cameraSession && m_cameraSession->camera();
if (validCameraSession && !qt_androidCheckCameraPermission()) {
updateError(QMediaRecorder::ResourceError, QLatin1String("Camera permission denied."));
setKeepAlive(false);
return;
}
if (m_audioInput && !qt_androidCheckMicrophonePermission()) {
updateError(QMediaRecorder::ResourceError, QLatin1String("Microphone permission denied."));
setKeepAlive(false);
return;
}
m_mediaRecorder = std::make_shared<AndroidMediaRecorder>();
connect(m_mediaRecorder.get(), &AndroidMediaRecorder::error, this,
&QAndroidCaptureSession::onError);
connect(m_mediaRecorder.get(), &AndroidMediaRecorder::info, this,
&QAndroidCaptureSession::onInfo);
applySettings(settings);
// Set audio/video sources
if (validCameraSession) {
m_cameraSession->camera()->stopPreviewSynchronous();
m_cameraSession->camera()->unlock();
m_mediaRecorder->setCamera(m_cameraSession->camera());
m_mediaRecorder->setVideoSource(AndroidMediaRecorder::Camera);
}
if (m_audioInput) {
m_mediaRecorder->setAudioInput(m_audioInput->device.id());
if (!m_mediaRecorder->isAudioSourceSet())
m_mediaRecorder->setAudioSource(AndroidMediaRecorder::DefaultAudioSource);
}
// Set output format
m_mediaRecorder->setOutputFormat(m_outputFormat);
// Set video encoder settings
if (validCameraSession) {
m_mediaRecorder->setVideoSize(settings.videoResolution());
m_mediaRecorder->setVideoFrameRate(qRound(settings.videoFrameRate()));
m_mediaRecorder->setVideoEncodingBitRate(settings.videoBitRate());
m_mediaRecorder->setVideoEncoder(m_videoEncoder);
// media recorder is also compensanting the mirror on front camera
auto rotation = m_cameraSession->currentCameraRotation();
if (m_cameraSession->camera()->getFacing() == AndroidCamera::CameraFacingFront)
rotation = (360 - rotation) % 360; // remove mirror compensation
m_mediaRecorder->setOrientationHint(rotation);
}
// Set audio encoder settings
if (m_audioInput) {
m_mediaRecorder->setAudioChannels(settings.audioChannelCount());
m_mediaRecorder->setAudioEncodingBitRate(settings.audioBitRate());
m_mediaRecorder->setAudioSamplingRate(settings.audioSampleRate());
m_mediaRecorder->setAudioEncoder(m_audioEncoder);
}
QString extension = settings.preferredSuffix();
// Set output file
auto location = outputLocation.toString(QUrl::PreferLocalFile);
QString filePath = location;
if (QUrl(filePath).scheme() != QLatin1String("content")) {
filePath = QMediaStorageLocation::generateFileName(
location, m_cameraSession ? QStandardPaths::MoviesLocation
: QStandardPaths::MusicLocation, extension);
}
m_usedOutputLocation = QUrl::fromLocalFile(filePath);
m_outputLocationIsStandard = location.isEmpty() || QFileInfo(location).isRelative();
m_mediaRecorder->setOutputFile(filePath);
if (validCameraSession) {
m_cameraSession->disableRotation();
}
if (!m_mediaRecorder->prepare()) {
updateError(QMediaRecorder::FormatError,
QLatin1String("Unable to prepare the media recorder."));
restartViewfinder();
return;
}
if (!m_mediaRecorder->start()) {
updateError(QMediaRecorder::FormatError, QMediaRecorderPrivate::msgFailedStartRecording());
restartViewfinder();
return;
}
m_elapsedTime.start();
m_notifyTimer.start();
updateDuration();
if (validCameraSession) {
m_cameraSession->setReadyForCapture(false);
// Preview frame callback is cleared when setting up the camera with the media recorder.
// We need to reset it.
m_cameraSession->camera()->setupPreviewFrameCallback();
}
m_state = QMediaRecorder::RecordingState;
Q_EMIT stateChanged(m_state);
}
void QAndroidCaptureSession::stop(bool error)
{
if (m_state == QMediaRecorder::StoppedState || m_mediaRecorder == nullptr)
return;
m_mediaRecorder->stop();
m_notifyTimer.stop();
updateDuration();
m_elapsedTime.invalidate();
m_mediaRecorder = nullptr;
if (m_cameraSession && m_cameraSession->isActive()) {
// Viewport needs to be restarted after recording
restartViewfinder();
}
if (!error) {
// if the media is saved into the standard media location, register it
// with the Android media scanner so it appears immediately in apps
// such as the gallery.
if (m_outputLocationIsStandard)
AndroidMultimediaUtils::registerMediaFile(m_usedOutputLocation.toLocalFile());
Q_EMIT actualLocationChanged(m_usedOutputLocation);
}
m_state = QMediaRecorder::StoppedState;
Q_EMIT stateChanged(m_state);
}
qint64 QAndroidCaptureSession::duration() const
{
return m_duration;
}
void QAndroidCaptureSession::applySettings(QMediaEncoderSettings &settings)
{
// container settings
auto fileFormat = settings.mediaFormat().fileFormat();
if (!m_cameraSession && fileFormat == QMediaFormat::AAC) {
m_outputFormat = AndroidMediaRecorder::AAC_ADTS;
} else if (fileFormat == QMediaFormat::Ogg) {
m_outputFormat = AndroidMediaRecorder::OGG;
} else if (fileFormat == QMediaFormat::WebM) {
m_outputFormat = AndroidMediaRecorder::WEBM;
// } else if (fileFormat == QLatin1String("3gp")) {
// m_outputFormat = AndroidMediaRecorder::THREE_GPP;
} else {
// fallback to MP4
m_outputFormat = AndroidMediaRecorder::MPEG_4;
}
// audio settings
if (settings.audioChannelCount() <= 0)
settings.setAudioChannelCount(m_defaultSettings.audioChannels);
if (settings.audioBitRate() <= 0)
settings.setAudioBitRate(m_defaultSettings.audioBitRate);
if (settings.audioSampleRate() <= 0)
settings.setAudioSampleRate(m_defaultSettings.audioSampleRate);
if (settings.audioCodec() == QMediaFormat::AudioCodec::AAC)
m_audioEncoder = AndroidMediaRecorder::AAC;
else if (settings.audioCodec() == QMediaFormat::AudioCodec::Opus)
m_audioEncoder = AndroidMediaRecorder::OPUS;
else if (settings.audioCodec() == QMediaFormat::AudioCodec::Vorbis)
m_audioEncoder = AndroidMediaRecorder::VORBIS;
else
m_audioEncoder = m_defaultSettings.audioEncoder;
// video settings
if (m_cameraSession && m_cameraSession->camera()) {
if (settings.videoResolution().isEmpty()) {
settings.setVideoResolution(m_defaultSettings.videoResolution);
} else if (!m_supportedResolutions.contains(settings.videoResolution())) {
// if the requested resolution is not supported, find the closest one
QSize reqSize = settings.videoResolution();
int reqPixelCount = reqSize.width() * reqSize.height();
QList<int> supportedPixelCounts;
for (int i = 0; i < m_supportedResolutions.size(); ++i) {
const QSize &s = m_supportedResolutions.at(i);
supportedPixelCounts.append(s.width() * s.height());
}
int closestIndex = qt_findClosestValue(supportedPixelCounts, reqPixelCount);
settings.setVideoResolution(m_supportedResolutions.at(closestIndex));
}
if (settings.videoFrameRate() <= 0)
settings.setVideoFrameRate(m_defaultSettings.videoFrameRate);
if (settings.videoBitRate() <= 0)
settings.setVideoBitRate(m_defaultSettings.videoBitRate);
if (settings.videoCodec() == QMediaFormat::VideoCodec::H264)
m_videoEncoder = AndroidMediaRecorder::H264;
else if (settings.videoCodec() == QMediaFormat::VideoCodec::H265)
m_videoEncoder = AndroidMediaRecorder::HEVC;
else if (settings.videoCodec() == QMediaFormat::VideoCodec::MPEG4)
m_videoEncoder = AndroidMediaRecorder::MPEG_4_SP;
else
m_videoEncoder = m_defaultSettings.videoEncoder;
}
}
void QAndroidCaptureSession::restartViewfinder()
{
setKeepAlive(false);
if (!m_cameraSession)
return;
if (m_cameraSession && m_cameraSession->camera()) {
m_cameraSession->camera()->reconnect();
m_cameraSession->camera()->stopPreviewSynchronous();
m_cameraSession->camera()->startPreview();
m_cameraSession->setReadyForCapture(true);
m_cameraSession->enableRotation();
}
m_mediaRecorder = nullptr;
}
void QAndroidCaptureSession::updateDuration()
{
if (m_elapsedTime.isValid())
m_duration = m_elapsedTime.elapsed();
Q_EMIT durationChanged(m_duration);
}
void QAndroidCaptureSession::onCameraOpened()
{
m_supportedResolutions.clear();
m_supportedFramerates.clear();
// get supported resolutions from predefined profiles
for (int i = 0; i < 8; ++i) {
CaptureProfile profile = getProfile(i);
if (!profile.isNull) {
if (i == AndroidCamcorderProfile::QUALITY_HIGH)
m_defaultSettings = profile;
if (!m_supportedResolutions.contains(profile.videoResolution))
m_supportedResolutions.append(profile.videoResolution);
if (!m_supportedFramerates.contains(profile.videoFrameRate))
m_supportedFramerates.append(profile.videoFrameRate);
}
}
ranges::sort(m_supportedResolutions, qt_sizeLessThan);
ranges::sort(m_supportedFramerates);
QMediaEncoderSettings defaultSettings;
applySettings(defaultSettings);
m_cameraSession->applyResolution(defaultSettings.videoResolution());
}
QAndroidCaptureSession::CaptureProfile QAndroidCaptureSession::getProfile(int id)
{
CaptureProfile profile;
const bool hasProfile = AndroidCamcorderProfile::hasProfile(m_cameraSession->camera()->cameraId(),
AndroidCamcorderProfile::Quality(id));
if (hasProfile) {
AndroidCamcorderProfile camProfile = AndroidCamcorderProfile::get(m_cameraSession->camera()->cameraId(),
AndroidCamcorderProfile::Quality(id));
profile.outputFormat = AndroidMediaRecorder::OutputFormat(camProfile.getValue(AndroidCamcorderProfile::fileFormat));
profile.audioEncoder = AndroidMediaRecorder::AudioEncoder(camProfile.getValue(AndroidCamcorderProfile::audioCodec));
profile.audioBitRate = camProfile.getValue(AndroidCamcorderProfile::audioBitRate);
profile.audioChannels = camProfile.getValue(AndroidCamcorderProfile::audioChannels);
profile.audioSampleRate = camProfile.getValue(AndroidCamcorderProfile::audioSampleRate);
profile.videoEncoder = AndroidMediaRecorder::VideoEncoder(camProfile.getValue(AndroidCamcorderProfile::videoCodec));
profile.videoBitRate = camProfile.getValue(AndroidCamcorderProfile::videoBitRate);
profile.videoFrameRate = camProfile.getValue(AndroidCamcorderProfile::videoFrameRate);
profile.videoResolution = QSize(camProfile.getValue(AndroidCamcorderProfile::videoFrameWidth),
camProfile.getValue(AndroidCamcorderProfile::videoFrameHeight));
if (profile.outputFormat == AndroidMediaRecorder::MPEG_4)
profile.outputFileExtension = QStringLiteral("mp4");
else if (profile.outputFormat == AndroidMediaRecorder::THREE_GPP)
profile.outputFileExtension = QStringLiteral("3gp");
else if (profile.outputFormat == AndroidMediaRecorder::AMR_NB_Format)
profile.outputFileExtension = QStringLiteral("amr");
else if (profile.outputFormat == AndroidMediaRecorder::AMR_WB_Format)
profile.outputFileExtension = QStringLiteral("awb");
profile.isNull = false;
}
return profile;
}
void QAndroidCaptureSession::onError(int what, int extra)
{
Q_UNUSED(what);
Q_UNUSED(extra);
stop(true);
updateError(QMediaRecorder::ResourceError, QLatin1String("Unknown error."));
}
void QAndroidCaptureSession::onInfo(int what, int extra)
{
Q_UNUSED(extra);
if (what == 800) {
// MEDIA_RECORDER_INFO_MAX_DURATION_REACHED
stop();
updateError(QMediaRecorder::OutOfSpaceError, QLatin1String("Maximum duration reached."));
} else if (what == 801) {
// MEDIA_RECORDER_INFO_MAX_FILESIZE_REACHED
stop();
updateError(QMediaRecorder::OutOfSpaceError, QLatin1String("Maximum file size reached."));
}
}
QT_END_NAMESPACE
#include "moc_qandroidcapturesession_p.cpp"