File indexing completed on 2024-03-24 04:54:06
0001 /* 0002 SPDX-FileCopyrightText: 2019 Akhil K Gangadharan <helloimakhil@gmail.com> 0003 This file is part of Kdenlive. See www.kdenlive.org. 0004 0005 SPDX-License-Identifier: GPL-3.0-only OR LicenseRef-KDE-Accepted-GPL 0006 */ 0007 0008 #include "mediacapture.h" 0009 #include "audiomixer/iecscale.h" 0010 #include "audiomixer/mixermanager.hpp" 0011 #include "core.h" 0012 #include "kdenlivesettings.h" 0013 #include <QAudioOutput> 0014 // TODO: fix video capture (Hint: QCameraInfo is not available in Qt6 anymore) 0015 //#include <QCameraInfo> 0016 #include <QDir> 0017 #include <QtEndian> 0018 #include <utility> 0019 0020 AudioDevInfo::AudioDevInfo(const QAudioFormat &format, QObject *parent) 0021 : QIODevice(parent) 0022 , m_format(format) 0023 { 0024 #if QT_VERSION < QT_VERSION_CHECK(6, 0, 0) 0025 switch (m_format.sampleSize()) { 0026 case 8: 0027 switch (m_format.sampleType()) { 0028 case QAudioFormat::UnSignedInt: 0029 maxAmplitude = 255; 0030 break; 0031 case QAudioFormat::SignedInt: 0032 maxAmplitude = 127; 0033 break; 0034 default: 0035 break; 0036 } 0037 break; 0038 case 16: 0039 switch (m_format.sampleType()) { 0040 case QAudioFormat::UnSignedInt: 0041 maxAmplitude = 65535; 0042 break; 0043 case QAudioFormat::SignedInt: 0044 maxAmplitude = 32767; 0045 break; 0046 default: 0047 break; 0048 } 0049 break; 0050 0051 case 32: 0052 switch (m_format.sampleType()) { 0053 case QAudioFormat::UnSignedInt: 0054 maxAmplitude = 0xffffffff; 0055 break; 0056 case QAudioFormat::SignedInt: 0057 maxAmplitude = 0x7fffffff; 0058 break; 0059 case QAudioFormat::Float: 0060 maxAmplitude = 0x7fffffff; // Kind of 0061 default: 0062 break; 0063 } 0064 break; 0065 0066 default: 0067 break; 0068 } 0069 #else 0070 // TODO: qt6 0071 #endif 0072 } 0073 0074 qint64 AudioDevInfo::readData(char *data, qint64 maxSize) 0075 { 0076 Q_UNUSED(data) 0077 Q_UNUSED(maxSize) 0078 return 0; 0079 } 0080 0081 qint64 AudioDevInfo::writeData(const char *data, qint64 len) 0082 { 0083 #if QT_VERSION < QT_VERSION_CHECK(6, 0, 0) 0084 if (maxAmplitude) { 0085 Q_ASSERT(m_format.sampleSize() % 8 == 0); 0086 const int channelBytes = m_format.sampleSize() / 8; 0087 const int sampleBytes = m_format.channelCount() * channelBytes; 0088 Q_ASSERT(len % sampleBytes == 0); 0089 const int numSamples = len / sampleBytes; 0090 0091 const unsigned char *ptr = reinterpret_cast<const unsigned char *>(data); 0092 QVector<quint32> levels; 0093 for (int j = 0; j < m_format.channelCount(); ++j) { 0094 levels << 0; 0095 } 0096 for (int i = 0; i < numSamples; ++i) { 0097 for (int j = 0; j < m_format.channelCount(); ++j) { 0098 quint32 value = 0; 0099 if (m_format.sampleSize() == 8 && m_format.sampleType() == QAudioFormat::UnSignedInt) { 0100 value = *reinterpret_cast<const quint8 *>(ptr); 0101 } else if (m_format.sampleSize() == 8 && m_format.sampleType() == QAudioFormat::SignedInt) { 0102 value = qAbs(*reinterpret_cast<const qint8 *>(ptr)); 0103 } else if (m_format.sampleSize() == 16 && m_format.sampleType() == QAudioFormat::UnSignedInt) { 0104 if (m_format.byteOrder() == QAudioFormat::LittleEndian) 0105 value = qFromLittleEndian<quint16>(ptr); 0106 else 0107 value = qFromBigEndian<quint16>(ptr); 0108 } else if (m_format.sampleSize() == 16 && m_format.sampleType() == QAudioFormat::SignedInt) { 0109 if (m_format.byteOrder() == QAudioFormat::LittleEndian) 0110 value = qAbs(qFromLittleEndian<qint16>(ptr)); 0111 else 0112 value = qAbs(qFromBigEndian<qint16>(ptr)); 0113 } else if (m_format.sampleSize() == 32 && m_format.sampleType() == QAudioFormat::UnSignedInt) { 0114 if (m_format.byteOrder() == QAudioFormat::LittleEndian) 0115 value = qFromLittleEndian<quint32>(ptr); 0116 else 0117 value = qFromBigEndian<quint32>(ptr); 0118 } else if (m_format.sampleSize() == 32 && m_format.sampleType() == QAudioFormat::SignedInt) { 0119 if (m_format.byteOrder() == QAudioFormat::LittleEndian) 0120 value = qAbs(qFromLittleEndian<qint32>(ptr)); 0121 else 0122 value = qAbs(qFromBigEndian<qint32>(ptr)); 0123 } else if (m_format.sampleSize() == 32 && m_format.sampleType() == QAudioFormat::Float) { 0124 value = qAbs(*reinterpret_cast<const float *>(ptr) * 0x7fffffff); // assumes 0-1.0 0125 } 0126 levels[j] = qMax(value, levels.at(j)); 0127 ptr += channelBytes; 0128 } 0129 } 0130 QVector<qreal> dbLevels; 0131 QVector<qreal> recLevels; 0132 for (int j = 0; j < m_format.channelCount(); ++j) { 0133 qreal val = qMin(levels.at(j), maxAmplitude); 0134 val = 20. * log10(val / maxAmplitude); 0135 recLevels << val; 0136 dbLevels << IEC_ScaleMax(val, 0); 0137 } 0138 Q_EMIT levelRecChanged(recLevels); 0139 Q_EMIT levelChanged(dbLevels); 0140 } 0141 #else 0142 // TODO: qt6 0143 #endif 0144 return len; 0145 } 0146 0147 MediaCapture::MediaCapture(QObject *parent) 0148 : QObject(parent) 0149 , currentState(-1) 0150 , m_audioInput(nullptr) 0151 , m_audioInfo(nullptr) 0152 , m_audioDevice("default:") 0153 , m_path(QUrl()) 0154 , m_recordState(0) 0155 , m_recOffset(0) 0156 , m_tid(-1) 0157 , m_readyForRecord(false) 0158 { 0159 m_resetTimer.setInterval(5000); 0160 m_resetTimer.setSingleShot(true); 0161 connect(&m_resetTimer, &QTimer::timeout, this, &MediaCapture::resetIfUnused); 0162 } 0163 0164 void MediaCapture::switchMonitorState(int tid, bool run) 0165 { 0166 pCore->mixer()->monitorAudio(tid, run); 0167 } 0168 0169 void MediaCapture::switchMonitorState(bool run) 0170 { 0171 #if QT_VERSION < QT_VERSION_CHECK(6, 0, 0) 0172 if (run) { 0173 // Start monitoring audio 0174 QAudioFormat format; 0175 format.setSampleRate(KdenliveSettings::audiocapturesamplerate()); 0176 format.setChannelCount(KdenliveSettings::audiocapturechannels()); 0177 format.setSampleSize(16); 0178 format.setSampleType(QAudioFormat::SignedInt); 0179 format.setByteOrder(QAudioFormat::LittleEndian); 0180 format.setCodec("audio/pcm"); 0181 QAudioDeviceInfo deviceInfo = QAudioDeviceInfo::defaultInputDevice(); 0182 if (!m_audioDevice.isEmpty()) { 0183 const auto deviceInfos = QAudioDeviceInfo::availableDevices(QAudio::AudioInput); 0184 for (const QAudioDeviceInfo &devInfo : deviceInfos) { 0185 qDebug() << "Device name: " << devInfo.deviceName(); 0186 if (devInfo.deviceName() == m_audioDevice) { 0187 deviceInfo = devInfo; 0188 break; 0189 } 0190 } 0191 } 0192 if (!deviceInfo.isFormatSupported(format)) { 0193 qWarning() << "Default format not supported - trying to use nearest"; 0194 format = deviceInfo.nearestFormat(format); 0195 } 0196 m_audioInfo.reset(new AudioDevInfo(format)); 0197 m_audioInput.reset(); 0198 m_audioInput = std::make_unique<QAudioInput>(deviceInfo, format, this); 0199 QObject::connect(m_audioInfo.data(), &AudioDevInfo::levelChanged, m_audioInput.get(), [&](const QVector<qreal> &level) { 0200 m_levels = level; 0201 if (m_recordState == QMediaRecorder::RecordingState) { 0202 // Get the frame number 0203 int currentPos = qRound(m_recTimer.elapsed() / 1000. * pCore->getCurrentFps()); 0204 if (currentPos > m_lastPos) { 0205 // Only store 1 value per frame 0206 switch (level.count()) { 0207 case 2: 0208 for (int i = 0; i < currentPos - m_lastPos; i++) { 0209 m_recLevels << qMax(level.first(), level.last()); 0210 } 0211 break; 0212 default: 0213 for (int i = 0; i < currentPos - m_lastPos; i++) { 0214 m_recLevels << level.first(); 0215 } 0216 break; 0217 } 0218 m_lastPos = currentPos; 0219 Q_EMIT recDurationChanged(); 0220 } 0221 } 0222 Q_EMIT levelsChanged(); 0223 }); 0224 QObject::connect(m_audioInfo.data(), &AudioDevInfo::levelRecChanged, this, &MediaCapture::audioLevels); 0225 qreal linearVolume = QAudio::convertVolume(KdenliveSettings::audiocapturevolume() / 100.0, QAudio::LogarithmicVolumeScale, QAudio::LinearVolumeScale); 0226 m_audioInput->setVolume(linearVolume); 0227 m_audioInfo->open(QIODevice::WriteOnly); 0228 m_audioInput->start(m_audioInfo.data()); 0229 } else { 0230 if (m_audioInfo) { 0231 m_audioInfo->close(); 0232 m_audioInfo.reset(); 0233 } 0234 m_audioInput.reset(); 0235 } 0236 #else 0237 // TODO: qt6 0238 #endif 0239 } 0240 0241 int MediaCapture::recDuration() const 0242 { 0243 return m_recOffset + m_lastPos; 0244 } 0245 0246 const QVector<double> MediaCapture::recLevels() const 0247 { 0248 return m_recLevels; 0249 } 0250 0251 bool MediaCapture::isMonitoring() const 0252 { 0253 return m_audioInput != nullptr && !isRecording(); 0254 } 0255 0256 MediaCapture::~MediaCapture() = default; 0257 0258 void MediaCapture::displayErrorMessage() 0259 { 0260 qDebug() << " !!!!!!!!!!!!!!!! ERROR : QMediarecorder - Capture failed"; 0261 } 0262 0263 void MediaCapture::resetIfUnused() 0264 { 0265 QMutexLocker lk(&m_recMutex); 0266 qDebug() << "// CLEARING REC MANAGER"; 0267 #if QT_VERSION < QT_VERSION_CHECK(6, 0, 0) 0268 if (m_audioRecorder && m_audioRecorder->state() == QMediaRecorder::StoppedState) { 0269 m_audioRecorder.reset(); 0270 } 0271 #else 0272 // TODO: Qt6 0273 /*if (m_audioRecorder && m_audioRecorder->state() == QMediaRecorder::StoppedState) { 0274 m_audioRecorder.reset(); 0275 }*/ 0276 #endif 0277 } 0278 0279 void MediaCapture::recordAudio(int tid, bool record) 0280 { 0281 QMutexLocker lk(&m_recMutex); 0282 m_tid = tid; 0283 #if QT_VERSION < QT_VERSION_CHECK(6, 0, 0) 0284 if (!m_audioRecorder) { 0285 m_audioRecorder = std::make_unique<QAudioRecorder>(this); 0286 connect(m_audioRecorder.get(), &QAudioRecorder::stateChanged, this, [&, tid](QMediaRecorder::State state) { 0287 m_recordState = state; 0288 if (m_recordState == QMediaRecorder::StoppedState) { 0289 m_resetTimer.start(); 0290 m_recLevels.clear(); 0291 m_lastPos = -1; 0292 m_recOffset = 0; 0293 Q_EMIT audioLevels(QVector<qreal>()); 0294 // m_readyForRecord is true if we were only displaying the countdown but real recording didn't start yet 0295 if (!m_readyForRecord) { 0296 Q_EMIT pCore->finalizeRecording(getCaptureOutputLocation().toLocalFile()); 0297 } 0298 m_readyForRecord = false; 0299 } 0300 Q_EMIT recordStateChanged(tid, m_recordState == QMediaRecorder::RecordingState); 0301 }); 0302 } 0303 0304 if (record && m_audioRecorder->state() == QMediaRecorder::StoppedState) { 0305 m_recTimer.invalidate(); 0306 m_resetTimer.stop(); 0307 m_readyForRecord = true; 0308 setAudioCaptureDevice(); 0309 m_audioRecorder->setAudioInput(m_audioDevice); 0310 setCaptureOutputLocation(); 0311 qreal linearVolume = QAudio::convertVolume(KdenliveSettings::audiocapturevolume() / 100.0, QAudio::LogarithmicVolumeScale, QAudio::LinearVolumeScale); 0312 m_audioRecorder->setVolume(linearVolume); 0313 // qDebug()<<"START AREC: "<<m_path<<"\n; CODECS: "<<m_audioRecorder->supportedAudioCodecs(); 0314 connect(m_audioRecorder.get(), static_cast<void (QAudioRecorder::*)(QMediaRecorder::Error)>(&QAudioRecorder::error), this, 0315 &MediaCapture::displayErrorMessage); 0316 0317 QAudioEncoderSettings audioSettings; 0318 // audioSettings.setCodec("audio/x-flac"); 0319 audioSettings.setSampleRate(KdenliveSettings::audiocapturesamplerate()); 0320 audioSettings.setChannelCount(KdenliveSettings::audiocapturechannels()); 0321 m_audioRecorder->setEncodingSettings(audioSettings); 0322 m_audioRecorder->setOutputLocation(m_path); 0323 m_recLevels.clear(); 0324 } else if (!record) { 0325 m_audioRecorder->stop(); 0326 m_recTimer.invalidate(); 0327 } else { 0328 qDebug() << "::: RESTARTING RECORD\n\nBBBBBB"; 0329 m_lastPos = -1; 0330 m_recTimer.start(); 0331 m_audioRecorder->record(); 0332 } 0333 #else 0334 // TODO: Qt6 0335 /*if (!m_audioRecorder) { 0336 m_audioRecorder = std::make_unique<QAudioRecorder>(this); 0337 connect(m_audioRecorder.get(), &QAudioRecorder::stateChanged, this, [&, tid](QMediaRecorder::State state) { 0338 m_recordState = state; 0339 if (m_recordState == QMediaRecorder::StoppedState) { 0340 m_resetTimer.start(); 0341 m_recLevels.clear(); 0342 m_lastPos = -1; 0343 m_recOffset = 0; 0344 Q_EMIT audioLevels(QVector<qreal>()); 0345 // m_readyForRecord is true if we were only displaying the countdown but real recording didn't start yet 0346 if (!m_readyForRecord) { 0347 Q_EMIT pCore->finalizeRecording(getCaptureOutputLocation().toLocalFile()); 0348 } 0349 m_readyForRecord = false; 0350 } 0351 Q_EMIT recordStateChanged(tid, m_recordState == QMediaRecorder::RecordingState); 0352 }); 0353 } 0354 0355 if (record && m_audioRecorder->state() == QMediaRecorder::StoppedState) { 0356 m_recTimer.invalidate(); 0357 m_resetTimer.stop(); 0358 m_readyForRecord = true; 0359 setAudioCaptureDevice(); 0360 m_audioRecorder->setAudioInput(m_audioDevice); 0361 setCaptureOutputLocation(); 0362 qreal linearVolume = QAudio::convertVolume(KdenliveSettings::audiocapturevolume() / 100.0, QAudio::LogarithmicVolumeScale, QAudio::LinearVolumeScale); 0363 m_audioRecorder->setVolume(linearVolume); 0364 // qDebug()<<"START AREC: "<<m_path<<"\n; CODECS: "<<m_audioRecorder->supportedAudioCodecs(); 0365 connect(m_audioRecorder.get(), static_cast<void (QAudioRecorder::*)(QMediaRecorder::Error)>(&QAudioRecorder::error), this, 0366 &MediaCapture::displayErrorMessage); 0367 0368 QAudioEncoderSettings audioSettings; 0369 // audioSettings.setCodec("audio/x-flac"); 0370 audioSettings.setSampleRate(KdenliveSettings::audiocapturesamplerate()); 0371 audioSettings.setChannelCount(KdenliveSettings::audiocapturechannels()); 0372 m_audioRecorder->setEncodingSettings(audioSettings); 0373 m_audioRecorder->setOutputLocation(m_path); 0374 m_recLevels.clear(); 0375 } else if (!record) { 0376 m_audioRecorder->stop(); 0377 m_recTimer.invalidate(); 0378 } else { 0379 qDebug() << "::: RESTARTING RECORD\n\nBBBBBB"; 0380 m_lastPos = -1; 0381 m_recTimer.start(); 0382 m_audioRecorder->record(); 0383 } */ 0384 #endif 0385 } 0386 0387 int MediaCapture::startCapture() 0388 { 0389 m_lastPos = -1; 0390 m_recOffset = 0; 0391 m_recTimer.start(); 0392 #if QT_VERSION < QT_VERSION_CHECK(6, 0, 0) 0393 m_audioRecorder->record(); 0394 #else 0395 // TODO: Qt6 0396 //m_audioRecorder->record(); 0397 #endif 0398 m_readyForRecord = false; 0399 return m_tid; 0400 } 0401 0402 // TODO: fix video capture 0403 0404 /*void MediaCapture::recordVideo(int tid, bool record) 0405 { 0406 Q_UNUSED(tid) 0407 if (!m_videoRecorder) { 0408 QList<QCameraInfo> availableCameras = QCameraInfo::availableCameras(); 0409 foreach (const QCameraInfo &cameraInfo, availableCameras) { 0410 if (cameraInfo == QCameraInfo::defaultCamera()) { 0411 m_camera = std::make_unique<QCamera>(cameraInfo, this); 0412 break; 0413 } 0414 } 0415 m_videoRecorder = std::make_unique<QMediaRecorder>(m_camera.get(), this); 0416 } 0417 0418 if (record && m_videoRecorder->state() == QMediaRecorder::StoppedState) { 0419 setCaptureOutputLocation(); 0420 m_videoRecorder->setOutputLocation(m_path); 0421 #if QT_VERSION < QT_VERSION_CHECK(6, 0, 0) 0422 connect(m_videoRecorder.get(), static_cast<void (QMediaRecorder::*)(QMediaRecorder::Error)>(&QAudioRecorder::error), this, 0423 &MediaCapture::displayErrorMessage); 0424 #else 0425 // TODO: Qt6 0426 connect(m_videoRecorder.get(), static_cast<void (QMediaRecorder::*)(QMediaRecorder::Error)>(&QAudioRecorder::error), this, 0427 &MediaCapture::displayErrorMessage); 0428 #endif 0429 m_camera->setCaptureMode(QCamera::CaptureVideo); 0430 m_camera->start(); 0431 // QString container = "video/mpeg"; 0432 // By default, Qt chooses appropriate parameters 0433 m_videoRecorder->record(); 0434 } else { 0435 m_videoRecorder->stop(); 0436 m_camera->stop(); 0437 m_videoRecorder.reset(); 0438 m_camera.reset(); 0439 } 0440 }*/ 0441 0442 void MediaCapture::setCaptureOutputLocation() 0443 { 0444 QDir captureFolder; 0445 bool audioCapture = m_videoRecorder.get() == nullptr; 0446 if (KdenliveSettings::capturetoprojectfolder() < 2) { 0447 captureFolder = QDir(pCore->getProjectFolderName(audioCapture)); 0448 } else { 0449 captureFolder = QDir(KdenliveSettings::capturefolder()); 0450 } 0451 QString extension; 0452 if (m_videoRecorder.get() != nullptr) { 0453 extension = QStringLiteral(".mpeg"); 0454 #if QT_VERSION < QT_VERSION_CHECK(6, 0, 0) 0455 // TODO: Qt6 0456 } else if (m_audioRecorder.get() != nullptr) { 0457 // extension = QStringLiteral(".flac"); 0458 extension = QStringLiteral(".wav"); 0459 } 0460 #else 0461 // TODO: Qt6 0462 } /*else if (m_audioRecorder.get() != nullptr) { 0463 // extension = QStringLiteral(".flac"); 0464 extension = QStringLiteral(".wav"); 0465 }*/ 0466 #endif 0467 QString path = captureFolder.absoluteFilePath("capture0000" + extension); 0468 int fileCount = 1; 0469 while (QFile::exists(path)) { 0470 QString num = QString::number(fileCount).rightJustified(4, '0', false); 0471 path = captureFolder.absoluteFilePath("capture" + num + extension); 0472 ++fileCount; 0473 } 0474 m_path = QUrl::fromLocalFile(path); 0475 } 0476 0477 QUrl MediaCapture::getCaptureOutputLocation() 0478 { 0479 return m_path; 0480 } 0481 0482 QStringList MediaCapture::getAudioCaptureDevices() 0483 { 0484 #if QT_VERSION < QT_VERSION_CHECK(6, 0, 0) 0485 std::unique_ptr<QAudioRecorder> audioRecorder = std::make_unique<QAudioRecorder>(this); 0486 QStringList audioDevices = audioRecorder->audioInputs(); 0487 audioRecorder.reset(); 0488 return audioDevices; 0489 #else 0490 // TODO: Qt6 0491 /*std::unique_ptr<QAudioRecorder> audioRecorder = std::make_unique<QAudioRecorder>(this); 0492 QStringList audioDevices = audioRecorder->audioInputs(); 0493 audioRecorder.reset(); 0494 return audioDevices;*/ 0495 return {}; 0496 #endif 0497 } 0498 0499 void MediaCapture::setAudioCaptureDevice() 0500 { 0501 QString deviceName = KdenliveSettings::defaultaudiocapture(); 0502 if (!deviceName.isNull()) { 0503 m_audioDevice = deviceName; 0504 } 0505 } 0506 0507 void MediaCapture::setAudioVolume() 0508 { 0509 qreal linearVolume = QAudio::convertVolume(KdenliveSettings::audiocapturevolume() / 100.0, QAudio::LogarithmicVolumeScale, QAudio::LinearVolumeScale); 0510 #if QT_VERSION < QT_VERSION_CHECK(6, 0, 0) 0511 if (m_audioRecorder) { 0512 m_audioRecorder->setVolume(linearVolume); 0513 } 0514 if (m_audioInput) { 0515 m_audioInput->setVolume(linearVolume); 0516 } 0517 #else 0518 // TODO: Qt6 0519 /*if (m_audioRecorder) { 0520 m_audioRecorder->setVolume(linearVolume); 0521 } 0522 if (m_audioInput) { 0523 m_audioInput->setVolume(linearVolume); 0524 }*/ 0525 #endif 0526 } 0527 0528 int MediaCapture::getState() 0529 { 0530 #if QT_VERSION < QT_VERSION_CHECK(6, 0, 0) 0531 if (m_audioRecorder != nullptr) { 0532 currentState = m_audioRecorder->state(); 0533 } else if (m_videoRecorder != nullptr) { 0534 currentState = m_videoRecorder->state(); 0535 } 0536 #else 0537 // TODO: Qt6 0538 /*if (m_audioRecorder != nullptr) { 0539 currentState = m_audioRecorder->state(); 0540 } else if (m_videoRecorder != nullptr) { 0541 currentState = m_videoRecorder->state(); 0542 }*/ 0543 #endif 0544 return currentState; 0545 } 0546 0547 QVector<qreal> MediaCapture::levels() const 0548 { 0549 return m_levels; 0550 } 0551 0552 int MediaCapture::recordState() const 0553 { 0554 return m_recordState; 0555 } 0556 0557 bool MediaCapture::isRecording() const 0558 { 0559 #if QT_VERSION < QT_VERSION_CHECK(6, 0, 0) 0560 if (m_readyForRecord || (m_audioRecorder && m_audioRecorder->state() != QMediaRecorder::StoppedState)) { 0561 return true; 0562 } 0563 if (m_videoRecorder && m_videoRecorder->state() != QMediaRecorder::StoppedState) { 0564 return true; 0565 } 0566 #else 0567 //TODO: Qt6 0568 /*if (m_readyForRecord || (m_audioRecorder && m_audioRecorder->state() != QMediaRecorder::StoppedState)) { 0569 return true; 0570 } 0571 if (m_videoRecorder && m_videoRecorder->state() != QMediaRecorder::StoppedState) { 0572 return true; 0573 }*/ 0574 #endif 0575 0576 return false; 0577 } 0578 0579 void MediaCapture::pauseRecording() 0580 { 0581 #if QT_VERSION < QT_VERSION_CHECK(6, 0, 0) 0582 m_audioRecorder->pause(); 0583 if (m_audioRecorder->state() == QMediaRecorder::RecordingState) { 0584 // Pause is not supported on this platform 0585 qDebug() << ":::: PAUSING FAILED!!!!"; 0586 m_audioRecorder->stop(); 0587 } else { 0588 qDebug() << ":::: MEDIA CAPTURE PAUSED!!!!"; 0589 } 0590 #else 0591 // TODO: Qt6 0592 /*m_audioRecorder->pause(); 0593 if (m_audioRecorder->state() == QMediaRecorder::RecordingState) { 0594 // Pause is not supported on this platform 0595 qDebug() << ":::: PAUSING FAILED!!!!"; 0596 m_audioRecorder->stop(); 0597 } else { 0598 qDebug() << ":::: MEDIA CAPTURE PAUSED!!!!"; 0599 }*/ 0600 #endif 0601 } 0602 0603 void MediaCapture::resumeRecording() 0604 { 0605 #if QT_VERSION < QT_VERSION_CHECK(6, 0, 0) 0606 0607 if (m_audioRecorder->state() == QMediaRecorder::PausedState) { 0608 m_recOffset += m_lastPos; 0609 m_lastPos = -1; 0610 m_recTimer.start(); 0611 m_audioRecorder->record(); 0612 } 0613 #else 0614 // TODO: Qt6 0615 /*if (m_audioRecorder->state() == QMediaRecorder::PausedState) { 0616 m_recOffset += m_lastPos; 0617 m_lastPos = -1; 0618 m_recTimer.start(); 0619 m_audioRecorder->record(); 0620 }*/ 0621 #endif 0622 }