src/capture/mediacapture.cpp

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 }