Ignore:
Timestamp:
May 3, 2016, 5:25:45 PM (9 years ago)
Author:
Silvan Scherrer
Message:

smplayer: update trunk to version 16.4

Location:
smplayer/trunk
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • smplayer/trunk

  • smplayer/trunk/src/inforeader.cpp

    r165 r176  
    11/*  smplayer, GUI front-end for mplayer.
    2     Copyright (C) 2006-2014 Ricardo Villalba <rvm@users.sourceforge.net>
     2    Copyright (C) 2006-2016 Ricardo Villalba <rvm@users.sourceforge.net>
    33
    44    This program is free software; you can redistribute it and/or modify
     
    1818
    1919#include "inforeader.h"
    20 #include <QStringList>
    21 #include <QApplication>
    22 #include <QRegExp>
    23 
    24 #include "colorutils.h"
    2520#include "global.h"
    2621#include "preferences.h"
    27 #include "mplayerversion.h"
    28 
    29 #if USE_QPROCESS
    30 #include <QProcess>
    31 #else
    32 #include "myprocess.h"
     22#include "playerprocess.h"
     23#include "paths.h"
     24#include <QFileInfo>
     25#include <QDateTime>
     26#include <QSettings>
     27#include <QDebug>
     28
     29#ifdef MPV_SUPPORT
     30#include "inforeadermpv.h"
    3331#endif
    3432
     33#ifdef MPLAYER_SUPPORT
     34#include "inforeadermplayer.h"
     35#endif
     36
     37#define INFOREADER_SAVE_VERSION 2
     38
    3539using namespace Global;
    3640
    37 #define NOME 0
    38 #define VO 1
    39 #define AO 2
    40 #define DEMUXER 3
    41 #define VC 4
    42 #define AC 5
    43 
    4441InfoReader * InfoReader::static_obj = 0;
    4542
    46 InfoReader * InfoReader::obj() {
     43InfoReader * InfoReader::obj(const QString & mplayer_bin) {
     44        QString player_bin = mplayer_bin;
     45        if (player_bin.isEmpty()) {
     46                player_bin = pref->mplayer_bin;
     47        }
    4748        if (!static_obj) {
    48                 static_obj = new InfoReader( pref->mplayer_bin );
    49                 static_obj->getInfo();
     49                static_obj = new InfoReader(player_bin);
     50        } else {
     51                static_obj->setPlayerBin(player_bin);
    5052        }
    5153        return static_obj;
    5254}
    5355
    54 InfoReader::InfoReader( QString mplayer_bin, QObject * parent )
     56InfoReader::InfoReader(QString mplayer_bin, QObject * parent)
    5557        : QObject(parent)
     58        , mplayer_svn(0)
     59        , is_mplayer2(false)
     60        , is_mpv(false)
    5661{
    57         mplayerbin = mplayer_bin;
    58 
    59 #if USE_QPROCESS
    60         proc = new QProcess(this);
    61         proc->setProcessChannelMode( QProcess::MergedChannels );
    62 #else
    63         proc = new MyProcess(this);
    64 
    65         connect( proc, SIGNAL(lineAvailable(QByteArray)),
    66              this, SLOT(readLine(QByteArray)) );
     62        setPlayerBin(mplayer_bin);
     63}
     64
     65InfoReader::~InfoReader() {
     66}
     67
     68void InfoReader::setPlayerBin(const QString & bin) {
     69        mplayerbin = bin;
     70
     71        QFileInfo fi(mplayerbin);
     72        if (fi.exists() && fi.isExecutable() && !fi.isDir()) {
     73                // mplayerbin = fi.absoluteFilePath();
     74        }
     75#ifdef Q_OS_LINUX
     76        else {
     77                QString fplayer = Helper::findExecutable(mplayerbin);
     78                qDebug() << "InfoReader::setPlayerBin: fplayer:" << fplayer;
     79                if (!fplayer.isEmpty()) mplayerbin = fplayer;
     80        }
    6781#endif
    68 }
    69 
    70 InfoReader::~InfoReader() {
     82        qDebug() << "InfoReader::setPlayerBin: mplayerbin:" << mplayerbin;
    7183}
    7284
    7385void InfoReader::getInfo() {
    74         waiting_for_key = true;
    75         vo_list.clear();
    76         ao_list.clear();
    77         demuxer_list.clear();
    78         mplayer_svn = -1;
    79 
    80         run("-identify -vo help -ao help -demuxer help -vc help -ac help");
    81 
    82         //list();
    83 }
    84 
    85 void InfoReader::list() {
    86         qDebug("InfoReader::list");
    87 
    88         InfoList::iterator it;
    89 
    90         qDebug(" vo_list:");
    91         for ( it = vo_list.begin(); it != vo_list.end(); ++it ) {
    92                 qDebug( "driver: '%s', desc: '%s'", (*it).name().toUtf8().data(), (*it).desc().toUtf8().data());
    93         }
    94 
    95         qDebug(" ao_list:");
    96         for ( it = ao_list.begin(); it != ao_list.end(); ++it ) {
    97                 qDebug( "driver: '%s', desc: '%s'", (*it).name().toUtf8().data(), (*it).desc().toUtf8().data());
    98         }
    99 
    100         qDebug(" demuxer_list:");
    101         for ( it = demuxer_list.begin(); it != demuxer_list.end(); ++it ) {
    102                 qDebug( "demuxer: '%s', desc: '%s'", (*it).name().toUtf8().data(), (*it).desc().toUtf8().data());
    103         }
    104 
    105         qDebug(" vc_list:");
    106         for ( it = vc_list.begin(); it != vc_list.end(); ++it ) {
    107                 qDebug( "codec: '%s', desc: '%s'", (*it).name().toUtf8().data(), (*it).desc().toUtf8().data());
    108         }
    109 
    110         qDebug(" ac_list:");
    111         for ( it = ac_list.begin(); it != ac_list.end(); ++it ) {
    112                 qDebug( "codec: '%s', desc: '%s'", (*it).name().toUtf8().data(), (*it).desc().toUtf8().data());
    113         }
    114 
    115 }
    116 
    117 static QRegExp rx_vo_key("^ID_VIDEO_OUTPUTS");
    118 static QRegExp rx_ao_key("^ID_AUDIO_OUTPUTS");
    119 static QRegExp rx_demuxer_key("^ID_DEMUXERS");
    120 static QRegExp rx_ac_key("^ID_AUDIO_CODECS");
    121 static QRegExp rx_vc_key("^ID_VIDEO_CODECS");
    122 
    123 static QRegExp rx_driver("\\t(.*)\\t(.*)");
    124 static QRegExp rx_demuxer("^\\s+([A-Z,a-z,0-9]+)\\s+(\\d+)\\s+(\\S.*)");
    125 static QRegExp rx_demuxer2("^\\s+([A-Z,a-z,0-9]+)\\s+(\\S.*)");
    126 static QRegExp rx_codec("^([A-Z,a-z,0-9]+)\\s+([A-Z,a-z,0-9]+)\\s+([A-Z,a-z,0-9]+)\\s+(\\S.*)");
    127 
    128 void InfoReader::readLine(QByteArray ba) {
    129 #if COLOR_OUTPUT_SUPPORT
    130     QString line = ColorUtils::stripColorsTags(QString::fromLocal8Bit(ba));
    131 #else
    132         QString line = QString::fromLocal8Bit(ba);
    133 #endif
    134 
    135         if (line.isEmpty()) return;
    136 
    137         qDebug("InfoReader::readLine: line: '%s'", line.toUtf8().data());
    138         //qDebug("waiting_for_key: %d", waiting_for_key);
    139 
    140         if (!waiting_for_key) {
    141                 if ((reading_type == VO) || (reading_type == AO)) {
    142                         if ( rx_driver.indexIn(line) > -1 ) {
    143                                 QString name = rx_driver.cap(1);
    144                                 QString desc = rx_driver.cap(2);
    145                                 qDebug("InfoReader::readLine: found driver: '%s' '%s'", name.toUtf8().data(), desc.toUtf8().data());
    146                                 if (reading_type==VO) {
    147                                         vo_list.append( InfoData(name, desc) );
    148                                 }
    149                                 else
    150                                 if (reading_type==AO) {
    151                                         ao_list.append( InfoData(name, desc) );
    152                                 }
    153                         } else {
    154                                 qWarning("InfoReader::readLine: can't parse output driver from line '%s'", line.toUtf8().constData());
    155                         }
     86        QString inifile = Paths::configPath() + "/player_info.ini";
     87        QSettings set(inifile, QSettings::IniFormat);
     88
     89        QString version_group = "version_" + QString::number(INFOREADER_SAVE_VERSION);
     90
     91        QString sname = mplayerbin;
     92        sname = sname.replace("/", "_").replace("\\", "_").replace(".", "_").replace(":", "_");
     93        QFileInfo fi(mplayerbin);
     94        if (fi.exists()) {
     95                sname += "_" + QString::number(fi.size());
     96
     97                qDebug() << "InfoReader::getInfo: sname:" << sname;
     98
     99                // Check if we already have info about the player in the ini file
     100                bool got_info = false;
     101                set.beginGroup(version_group +"/"+ sname);
     102                if (set.value("size", -1).toInt() == fi.size()) {
     103                        got_info = true;
     104                        vo_list = convertListToInfoList(set.value("vo_list").toStringList());
     105                        ao_list = convertListToInfoList(set.value("ao_list").toStringList());
     106                        #if ALLOW_DEMUXER_CODEC_CHANGE
     107                        demuxer_list = convertListToInfoList(set.value("demuxer_list").toStringList());
     108                        vc_list = convertListToInfoList(set.value("vc_list").toStringList());
     109                        ac_list = convertListToInfoList(set.value("ac_list").toStringList());
     110                        #endif
     111                        vf_list = set.value("vf_list").toStringList();
     112                        option_list = set.value("option_list").toStringList();
     113                        //qDebug() << "InfoReader::getInfo: option_list:" << option_list;
     114                        mplayer_svn = set.value("mplayer_svn").toInt();
     115                        mpv_version = set.value("mpv_version").toString();
     116                        mplayer2_version = set.value("mplayer2_version").toString();
     117                        is_mplayer2 = set.value("is_mplayer2").toBool();
     118                        is_mpv = set.value("is_mpv").toBool();
    156119                }
    157                 else
    158                 if (reading_type == DEMUXER) {
    159                         if ( rx_demuxer.indexIn(line) > -1 ) {
    160                                 QString name = rx_demuxer.cap(1);
    161                                 QString desc = rx_demuxer.cap(3);
    162                                 qDebug("InfoReader::readLine: found demuxer: '%s' '%s'", name.toUtf8().data(), desc.toUtf8().data());
    163                                 demuxer_list.append( InfoData(name, desc) );
    164                         }
    165                         else
    166                         if ( rx_demuxer2.indexIn(line) > -1 ) {
    167                                 QString name = rx_demuxer2.cap(1);
    168                                 QString desc = rx_demuxer2.cap(2);
    169                                 qDebug("InfoReader::readLine: found demuxer: '%s' '%s'", name.toUtf8().data(), desc.toUtf8().data());
    170                                 demuxer_list.append( InfoData(name, desc) );
    171                         }
    172                         else {
    173                                 qWarning("InfoReader::readLine: can't parse demuxer from line '%s'", line.toUtf8().constData());
    174                         }
     120                set.endGroup();
     121                if (got_info) {
     122                        qDebug() << "InfoReader::getInfo: loaded info from" << inifile;
     123                        return;
    175124                }
    176                 else
    177                 if ((reading_type == VC) || (reading_type == AC)) {
    178                         if ( rx_codec.indexIn(line) > -1 ) {
    179                                 QString name = rx_codec.cap(1);
    180                                 QString desc = rx_codec.cap(4);
    181                                 qDebug("InfoReader::readLine: found codec: '%s' '%s'", name.toUtf8().data(), desc.toUtf8().data());
    182                                 if (reading_type==VC) {
    183                                         vc_list.append( InfoData(name, desc) );
    184                                 }
    185                                 else
    186                                 if (reading_type==AC) {
    187                                         ac_list.append( InfoData(name, desc) );
    188                                 }
    189                         } else {
    190                                 qWarning("InfoReader::readLine: can't parse codec from line '%s'", line.toUtf8().constData());
    191                         }
     125        }
     126
     127        if (PlayerID::player(mplayerbin) == PlayerID::MPV) {
     128                #ifdef MPV_SUPPORT
     129                qDebug("InfoReader::getInfo: mpv");
     130                InfoReaderMPV ir(mplayerbin, this);
     131                ir.getInfo();
     132                vo_list = ir.voList();
     133                ao_list = ir.aoList();
     134                #if ALLOW_DEMUXER_CODEC_CHANGE
     135                demuxer_list = ir.demuxerList();
     136                vc_list = ir.vcList();
     137                ac_list = ir.acList();
     138                #endif
     139                vf_list = ir.vfList();
     140                option_list = ir.optionList();
     141                mplayer_svn = ir.mplayerSVN();
     142                mpv_version = ir.mpvVersion();
     143                mplayer2_version = "";
     144                is_mplayer2 = false;
     145                is_mpv = true;
     146                #endif
     147        } else {
     148                #ifdef MPLAYER_SUPPORT
     149                qDebug("InfoReader::getInfo: mplayer");
     150                InfoReaderMplayer ir(mplayerbin, this);
     151                ir.getInfo();
     152                vo_list = ir.voList();
     153                ao_list = ir.aoList();
     154                #if ALLOW_DEMUXER_CODEC_CHANGE
     155                demuxer_list = ir.demuxerList();
     156                vc_list = ir.vcList();
     157                ac_list = ir.acList();
     158                #endif
     159                vf_list.clear();
     160                option_list.clear();
     161                mplayer_svn = ir.mplayerSVN();
     162                mpv_version = "";
     163                mplayer2_version = ir.mplayer2Version();
     164                is_mplayer2 = ir.isMplayer2();
     165                is_mpv = false;
     166                #endif
     167        }
     168
     169        if (fi.exists()) {
     170                qDebug() << "InfoReader::getInfo: saving info to" << inifile;
     171                set.beginGroup(version_group +"/"+ sname);
     172                set.setValue("size", fi.size());
     173                set.setValue("date", fi.lastModified());
     174                set.setValue("vo_list", convertInfoListToList(vo_list));
     175                set.setValue("ao_list", convertInfoListToList(ao_list));
     176                #if ALLOW_DEMUXER_CODEC_CHANGE
     177                set.setValue("demuxer_list", convertInfoListToList(demuxer_list));
     178                set.setValue("vc_list", convertInfoListToList(vc_list));
     179                set.setValue("ac_list", convertInfoListToList(ac_list));
     180                #endif
     181                set.setValue("vf_list", vf_list);
     182                set.setValue("option_list", option_list);
     183                set.setValue("mplayer_svn", mplayer_svn);
     184                set.setValue("mpv_version", mpv_version);
     185                set.setValue("mplayer2_version", mplayer2_version);
     186                set.setValue("is_mplayer2", is_mplayer2);
     187                set.setValue("is_mpv", is_mpv);
     188                set.endGroup();
     189        }
     190}
     191
     192QString InfoReader::playerVersion() {
     193        QString player = QString("MPlayer SVN r%1").arg(mplayer_svn);
     194
     195        if (is_mplayer2) {
     196                player = "MPlayer2 " + mplayer2_version;
     197        }
     198        else
     199        if (is_mpv) {
     200                player = "MPV " + mpv_version;
     201        }
     202
     203        return player;
     204}
     205
     206QStringList InfoReader::convertInfoListToList(InfoList l) {
     207        QStringList r;
     208        for (int n = 0; n < l.count(); n++) {
     209                r << l[n].name() + "|" + l[n].desc();
     210        }
     211        return r;
     212}
     213
     214InfoList InfoReader::convertListToInfoList(QStringList l) {
     215        InfoList r;
     216        for (int n = 0; n < l.count(); n++) {
     217                QStringList s = l[n].split("|");
     218                if (s.count() >= 2) {
     219                        r.append(InfoData(s[0], s[1]));
    192220                }
    193221        }
    194 
    195         if ( rx_vo_key.indexIn(line) > -1 ) {
    196                 reading_type = VO;
    197                 waiting_for_key = false;
    198                 qDebug("InfoReader::readLine: found key: vo");
    199         }
    200 
    201         if ( rx_ao_key.indexIn(line) > -1 ) {
    202                 reading_type = AO;
    203                 waiting_for_key = false;
    204                 qDebug("InfoReader::readLine: found key: ao");
    205         }
    206 
    207         if ( rx_demuxer_key.indexIn(line) > -1 ) {
    208                 reading_type = DEMUXER;
    209                 waiting_for_key = false;
    210                 qDebug("InfoReader::readLine: found key: demuxer");
    211         }
    212 
    213         if ( rx_ac_key.indexIn(line) > -1 ) {
    214                 reading_type = AC;
    215                 waiting_for_key = false;
    216                 qDebug("InfoReader::readLine: found key: ac");
    217         }
    218 
    219         if ( rx_vc_key.indexIn(line) > -1 ) {
    220                 reading_type = VC;
    221                 waiting_for_key = false;
    222                 qDebug("InfoReader::readLines: found key: vc");
    223         }
    224 
    225         if (line.startsWith("MPlayer ")) {
    226                 mplayer_svn = MplayerVersion::mplayerVersion(line);
    227         }
    228 }
    229 
    230 #if USE_QPROCESS
    231 bool InfoReader::run(QString options) {
    232         qDebug("InfoReader::run: '%s'", options.toUtf8().data());
    233         qDebug("InfoReader::run: using QProcess");
    234 
    235         if (proc->state() == QProcess::Running) {
    236                 qWarning("InfoReader::run: process already running");
    237                 return false;
    238         }
    239 
    240         QStringList args = options.split(" ");
    241 
    242         proc->start(mplayerbin, args);
    243         if (!proc->waitForStarted()) {
    244                 qWarning("InfoReader::run: process can't start!");
    245                 return false;
    246         }
    247 
    248         //Wait until finish
    249         if (!proc->waitForFinished()) {
    250                 qWarning("InfoReader::run: process didn't finish. Killing it...");
    251                 proc->kill();
    252         }
    253 
    254         qDebug("InfoReader::run : terminating");
    255 
    256         QByteArray ba;
    257         while (proc->canReadLine()) {
    258                 ba = proc->readLine();
    259                 ba.replace("\n", "");
    260                 ba.replace("\r", "");
    261                 readLine( ba );
    262         }
    263 
    264         return true;
    265 }
    266 #else
    267 bool InfoReader::run(QString options) {
    268         qDebug("InfoReader::run: '%s'", options.toUtf8().data());
    269         qDebug("InfoReader::run: using myprocess");
    270 
    271         if (proc->isRunning()) {
    272                 qWarning("InfoReader::run: process already running");
    273                 return false;
    274         }
    275 
    276         proc->clearArguments();
    277 
    278         proc->addArgument(mplayerbin);
    279 
    280         QStringList args = options.split(" ");
    281         QStringList::Iterator it = args.begin();
    282         while( it != args.end() ) {
    283                 proc->addArgument( (*it) );
    284                 ++it;
    285         }
    286 
    287         proc->start();
    288         if (!proc->waitForStarted()) {
    289                 qWarning("InfoReader::run: process can't start!");
    290                 return false;
    291         }
    292 
    293         //Wait until finish
    294         if (!proc->waitForFinished()) {
    295                 qWarning("InfoReader::run: process didn't finish. Killing it...");
    296                 proc->kill();
    297         }
    298 
    299         qDebug("InfoReader::run : terminating");
    300 
    301         return true;
    302 }
    303 #endif
     222        return r;
     223}
    304224
    305225#include "moc_inforeader.cpp"
Note: See TracChangeset for help on using the changeset viewer.