File indexing completed on 2024-04-14 03:47:57

 // SPDX-License-Identifier: LGPL-2.1-or-later
 //
 // SPDX-FileCopyrightText: 2013 Illya Kovalevskyy <illya.kovalevskyy@gmail.com>
 // SPDX-FileCopyrightText: 2014 Dennis Nienhüser <nienhueser@kde.org>
 //
 
 #include "MovieCapture.h"
 #include "MarbleWidget.h"
 #include "MarbleDebug.h"
 
 #include <QProcess>
 #include <QMessageBox>
 #include <QTimer>
 #include <QElapsedTimer>
 #include <QFile>
 
 namespace Marble
 {
 
 class MovieCapturePrivate
 {
 public:
     explicit MovieCapturePrivate(MarbleWidget *widget) :
         marbleWidget(widget), method(MovieCapture::TimeDriven)
     {}
 
     /**
      * @brief This gets called when user doesn't have avconv/ffmpeg installed
      */
     void missingToolsWarning() {
         QMessageBox::warning(marbleWidget,
                              QObject::tr("Missing encoding tools"),
                              QObject::tr("Marble requires additional software in order to "
                                          "create movies. Please get %1 "
                                         ).arg("<a href=\"https://libav.org/"
                                                "download.html\">avconv</a>"),
                              QMessageBox::Ok);
     }
 
     QTimer frameTimer;
     MarbleWidget *marbleWidget;
     QString encoderExec;
     QString destinationFile;
     QProcess process;
     MovieCapture::SnapshotMethod method;
     int fps;
 };
 
 MovieCapture::MovieCapture(MarbleWidget *widget, QObject *parent) :
     QObject(parent),
     d_ptr(new MovieCapturePrivate(widget))
 {
     Q_D(MovieCapture);
     if( d->method == MovieCapture::TimeDriven ){
         d->frameTimer.setInterval(1000/30); // fps = 30 (default)
         connect(&d->frameTimer, SIGNAL(timeout()), this, SLOT(recordFrame()));
     }
     d->fps = 30;
     MovieFormat avi( "avi", tr( "AVI (mpeg4)" ), "avi" );
     MovieFormat flv( "flv", tr( "FLV" ), "flv" );
     MovieFormat mkv( "matroska", tr( "Matroska (h264)" ), "mkv" );
     MovieFormat mp4( "mp4", tr( "MPEG-4" ), "mp4" );
     MovieFormat vob( "vob", tr( "MPEG-2 PS (VOB)" ), "vob" );
     MovieFormat ogg( "ogg", tr( "OGG" ), "ogg" );
     MovieFormat swf( "swf", tr( "SWF" ), "swf" );
     m_supportedFormats << avi << flv << mkv << mp4 << vob << ogg << swf;
 }
 
 MovieCapture::~MovieCapture()
 {
     delete d_ptr;
 }
 
 void MovieCapture::setFps(int fps)
 {
     Q_D(MovieCapture);
     if( d->method == MovieCapture::TimeDriven ){
         d->frameTimer.setInterval(1000/fps);
     }
     d->fps = fps;
 }
 
 void MovieCapture::setFilename(const QString &path)
 {
     Q_D(MovieCapture);
     d->destinationFile = path;
 }
 
 void MovieCapture::setSnapshotMethod(MovieCapture::SnapshotMethod method)
 {
     Q_D(MovieCapture);
     d->method = method;
 }
 
 int MovieCapture::fps() const
 {
     Q_D(const MovieCapture);
     return d->fps;
 }
 
 QString MovieCapture::destination() const
 {
     Q_D(const MovieCapture);
     return d->destinationFile;
 }
 
 QVector<MovieFormat> MovieCapture::availableFormats()
 {
     Q_D(MovieCapture);
     static QVector<MovieFormat> availableFormats;
     if ( availableFormats.isEmpty() && checkToolsAvailability() ) {
         QProcess encoder(this);
         for ( const MovieFormat &format: m_supportedFormats ) {
             QString type = format.type();
             QStringList args;
             args << "-h" << QLatin1String("muxer=") + type;
             encoder.start( d->encoderExec, args );
             encoder.waitForFinished();
             QString output = encoder.readAll();
             bool isFormatAvailable = !output.contains(QLatin1String("Unknown format"));
             if( isFormatAvailable ) {
                 availableFormats << format;
             }
         }
     }
     return availableFormats;
 }
 
 MovieCapture::SnapshotMethod MovieCapture::snapshotMethod() const
 {
     Q_D(const MovieCapture);
     return d->method;
 }
 
 bool MovieCapture::checkToolsAvailability()
 {
     Q_D(MovieCapture);
     static bool toolsAvailable = false;
     if (toolsAvailable == false) {
         QProcess encoder(this);
         encoder.start("avconv", QStringList() << "-version");
         encoder.waitForFinished();
         if ( !encoder.readAll().isEmpty() ) { // avconv have output when it's here
             d->encoderExec = "avconv";
             toolsAvailable = true;
         } else {
             encoder.start("ffmpeg", QStringList() << "-version");
             encoder.waitForFinished();
             if ( !encoder.readAll().isEmpty() ) {
                 d->encoderExec = "ffmpeg";
                 toolsAvailable = true;
             }
         }
     }
     return toolsAvailable;
 }
 
 void MovieCapture::recordFrame()
 {
     Q_D(MovieCapture);
     QImage const screenshot = d->marbleWidget->mapScreenShot().toImage().convertToFormat(QImage::Format_RGB888);
     if (d->process.state() == QProcess::NotRunning) {
         QStringList const arguments = QStringList()
                 << "-y"
                 << "-r" << QString::number(fps())
                 << "-f" << "rawvideo"
                 << "-pix_fmt" << "rgb24"
                 << "-s" << QString("%1x%2").arg( screenshot.width() ).arg( screenshot.height() )
                 << "-i" << "pipe:"
                 << "-b" << "2000k"
                 << d->destinationFile;
         d->process.start( d->encoderExec, arguments );
         connect(&d->process, SIGNAL(finished(int)), this, SLOT(processWrittenMovie(int)));
     }
     d->process.write( (char*) screenshot.bits(), screenshot.sizeInBytes() );
     for (int i=0; i<30 && d->process.bytesToWrite()>0; ++i) {
         QElapsedTimer t;
         int then = d->process.bytesToWrite();
         t.start();
         d->process.waitForBytesWritten( 100 );
         int span = t.elapsed();
         int now = d->process.bytesToWrite();
         int bytesWritten = then - now;
         double rate = ( bytesWritten * 1000.0 ) / ( qMax(1, span) * 1024 );
         emit rateCalculated( rate );
     }
 }
 
 bool MovieCapture::startRecording()
 {
     Q_D(MovieCapture);
 
     if( !checkToolsAvailability() ) {
         d->missingToolsWarning();
         return false;
     }
 
     if( d->method == MovieCapture::TimeDriven ){
         d->frameTimer.start();
     }
     recordFrame();
     return true;
 }
 
 void MovieCapture::stopRecording()
 {
     Q_D(MovieCapture);
 
     d->frameTimer.stop();
     d->process.closeWriteChannel();
 }
 
 void MovieCapture::cancelRecording()
 {
     Q_D(MovieCapture);
 
     d->frameTimer.stop();
     d->process.close();
     QFile::remove( d->destinationFile );
 }
 
 void MovieCapture::processWrittenMovie(int exitCode)
 {
     if (exitCode != 0) {
         mDebug() << "[*] avconv finished with" << exitCode;
         emit errorOccured();
     }
 }
 
 } // namespace Marble
 
 #include "moc_MovieCapture.cpp"