rutils.cpp

Go to the documentation of this file.

 
#include <stdio.h>
 
#include <QStringList>
#include <QJsonDocument>
#include <QFile>
#include <QRegularExpression>
 
#include "VFS.h"
#include "rutils.h"
 
QString rutils::cleanPath(QString path)
{
        QStringList parts = path.split('/',Qt::SkipEmptyParts);
        return parts.join('/');
}
 
QByteArray rutils::resourceContents(QString resource, bool *ok, bool squashHash)
{
        if (resource.at(0) != ':')              //it must represent a resource path, not an arbtrary filesystem path
        {
                VFS::WARN( "rutils::resourceContents() can only access qrc resources." );
                if (ok) *ok = false;
                return "";
        }
 
        QFile r(resource);
        if (r.open(QIODevice::ReadOnly))
        {
                if (ok) *ok = true;
 
                if (squashHash)
                        return r.readAll().replace('#',"%23");
                else
                        return r.readAll();
        }
        else
                VFS::WARN( QString("Bad resourceContents path: %1").arg(resource) );
 
        if (ok) *ok = false;
        return "";
}
 
 
QJsonObject rutils::jsonResource(QString resource, bool *ok)
{
        bool rok;
 
        QByteArray r = rutils::resourceContents(resource, &rok);
 
        if (rok)
        {
                QJsonParseError err;
                QJsonDocument d = QJsonDocument::fromJson( r, &err );
 
                if (err.error == QJsonParseError::NoError)
                {
                        if (ok) *ok = true;
                        return d.object();
                }
                else
                        VFS::ERROR( resource+": "+err.errorString() );
        }
 
        if (ok) *ok = false;
        return QJsonObject();
}
 
 
//this list may ultimately want to come from some config entry, but for now it's hardcoded in
QStringList rutils::sequenceTypes = QStringList() << "jpe?g" << "tif?f" << "exr" << "png" << "dpx";
 
QJsonValue rutils::parseSequenceSyntax(QString p)
{
        QRegularExpression seqrx( "^(.*)\\.?\\[([-,x\\d]+)#(\\d+)\\]\\.(\\w{2,5})$");                           //support extensions from 2-5 alphanumeric characters
        QRegularExpressionMatch match = seqrx.match(p);
 
        if (match.hasMatch())
        {
                QJsonObject o;
 
                o["prefix"] = match.captured(1);
                o["range"] = match.captured(2);
                o["padding"] = match.captured(3).toInt();
                o["extension"] = match.captured(4);
 
                o["entries"] = QJsonArray::fromStringList(expandSequenceListing(p));
 
                return o;
        }
 
        return QJsonValue::Null;
}
 
QJsonObject rutils::sequenceListing(QJsonObject l, QStringList types)
{
        //1. convert the list of filenames to regexp signatures
        //2. remove any signatures that only match one entry
        //3. for every file in the list, find a matching signature that has the highest count and score(?) and add it to signatureFrames
        //     --any file that doesn't match any signature just gets added to the output list
        //4. for every entry in signatureFrames, create a range-notated string and add it to the output list
        //5. (the result list is already sorted by QJsonObject before returning)
 
        //printf("==SEQUENCE LISTING START==\n");
 
        QString name,nameEsc,t,t2;
        bool container;
        int o,c,d,capLen;
 
        QJsonObject r;
        QRegExp digrx( "(-?\\d+)");                                                     //an optional sign character followed by one or more digits
        QString digrxs("(-?\\d{%1})");                                                  //a string that will be inserted to make a new regex for each permutation of name/digits
        QRegExp digrxrx( QRegExp::escape(digrxs.arg('#')).replace('#',"(-?\\d+)") );    //a capturing regex matching the regex used to match the signature, so we can get the number of digits
        QRegExp typerx( "^.*\\.?("+types.join('|')+")$" );                              //the list of sequenceTypes joined as a master regex
        typerx.setCaseSensitivity(Qt::CaseInsensitive);
 
        //$, (,), *, +, ., ?, [, ,], ^, {, | and }                      //http://doc.qt.io/qt-4.8/qregexp.html#escape
        QRegExp unescaperx( "\\\\(\\$|\\(|\\)|\\*|\\+|\\.|\\?|\\[|\\]|\\^|\\{|\\||\\})" );
 
        QHash<QRegExp,int> signatures;
        QHash<QRegExp, QList<int> > signatureFrames;
 
 
        //1. convert the list of filenames to regexp signatures
        //========================================================
                for( QJsonObject::const_iterator it = l.begin(); it != l.end(); ++it)
                {
                        name = it.key();
                        container = it.value().toBool();
 
                        if (!container && typerx.exactMatch(name))                              //for files only, and only those that match the types we care about
                        {
                                nameEsc = QRegExp::escape(name);                                //a filename may contain regex characters... escape those
 
                                for (c=d=o=0; c<100; c++)
                                {
                                        t = nameEsc;                                            //make a copy of the escaped name...
                                        t2 = nameEsc;                                           //make a copy of the escaped name...
                                        o = digrx.indexIn(t,o);
 
                                        if (o>=0)
                                        {
                                                capLen = digrx.cap(1).length();
                                                t.replace(o,capLen,digrxs.arg(capLen));
                                                t2.replace(o,capLen,digrx.pattern());
 
                                                d++;
                                                o+=capLen;
 
                                                signatures[QRegExp(t)]++;                       //increment the count for that signature
                                                signatures[QRegExp(t2)]++;                      //increment the count for that signature
                                        }
                                        else
                                                break;
                                }
 
                                if (c == 100)
                                {       VFS::ERROR("Too many loops when trying to do sequence listing for '"+nameEsc+"'");
                                        return l;
                                }
 
                                if (d==0)                                                       //it didn't contain any digit sequences, so just add it to the output list
                                        r[name] = container;
                        }
                        else                                                                    //for directories
                                r[name] = container;
                }
 
 
        //2. remove any signatures that only match one entry
        //========================================================
                QHash<QRegExp, int>::iterator pit = signatures.begin();
                while (pit != signatures.end())
                {
                        if (pit.value() == 1)   pit = signatures.erase(pit);                    //remove any signatures that only have a count of one. Those can't be signatures.
                        else                    ++pit;
                }
 
                //for ( QHash<QRegExp,int>::const_iterator pit = signatures.begin(); pit != signatures.end(); ++pit )
                //      printf("%s -> %d\n",qUtf8Printable(pit.key().pattern()),pit.value());
 
 
        //3. for every file in the list, find a matching signature that has the highest count/score, and add the frame number to the signatureFrames list
        //========================================================
                QRegExp bestSignature,s;
                int bestSignatureCount,frame;
                for( QJsonObject::const_iterator it = l.begin(); it != l.end(); ++it)
                {
                        name = it.key();
                        container = it.value().toBool();
 
                        if (!container && typerx.exactMatch(name))
                        {
                                bestSignatureCount = 0;
                                for ( QHash<QRegExp,int>::const_iterator pit = signatures.begin(); pit != signatures.end(); ++pit )
                                {
                                        s = pit.key();
                                        c = pit.value();
 
                                        if (s.exactMatch(name))
                                        {
                                                if (c == bestSignatureCount)                    //sometimes two signatures match equally... take the shorter one
                                                        if (s.pattern().length() < bestSignature.pattern().length())
                                                        {       bestSignature = s;
                                                                frame = s.cap(1).toInt();
                                                        }
 
                                                if (c > bestSignatureCount)
                                                {       bestSignatureCount = c;
                                                        bestSignature = s;
                                                        frame = s.cap(1).toInt();
                                                }
                                        }
                                }
 
                                if (bestSignatureCount == 0)
                                        r[name] = container;
                                else
                                {       signatureFrames[bestSignature].append(frame);
                                        //printf("%s -> %d\n",qUtf8Printable(bestSignature.pattern()),frame);
                                }
                        }
                        else                                                                    //this should have already happened above
                                r[name] = container;
                }
 
                //for ( QHash<QRegExp,QList<int> >::const_iterator fit = signatureFrames.begin(); fit != signatureFrames.end(); ++fit )
                //{
                //      QRegExp sr = fit.key();
                //      QList<int> fl = fit.value();
 
                //      printf("%s => ",qUtf8Printable(sr.pattern()));
                //      for (int i=0;i<fl.length();i++)
                //              printf("%d, ",fl.at(i));
                //      printf("\n");
                //}
 
 
        //4. for every entry in signatureFrames, create a range-notated string and add it to the output list
        //   range notation will be a comma-separated list of singletons and/or ranges:
        //   1-100,245,500-1000,1963,2000-2200
        //========================================================
                for ( QHash<QRegExp,QList<int> >::const_iterator fit = signatureFrames.begin(); fit != signatureFrames.end(); ++fit )
                {
                        QString sr = fit.key().pattern();
                        QList<int> fl = fit.value();
                        std::sort(fl.begin(),fl.end());                                         //sort the incoming frame list
 
                        //printf("%s => ",qUtf8Printable(sr));
                        //for (int i=0;i<fl.length();i++)
                        //      printf("%4d, ",fl.at(i));
                        //printf("\n");
 
                        QList<int> deltas;
                        deltas << 0;                                                            //enter a dummy value to offset the pyramid
                        for (int i=0;i<fl.length()-1;i++)
                                deltas.append(fl[i+1]-fl[i]);                                   //find the deltas/steps between each frame
 
                        //printf("%s => ",qUtf8Printable(sr));
                        //for (int i=0;i<deltas.length();i++)
                        //      printf("%4d, ",deltas.at(i));
                        //printf("\n");
 
                        QStringList chunks;
                        int delta = 0;                                                          //stride between
                        int b,e,c;                                                              //begin,end
                        for (int i=1;i<=deltas.length();i++)
                        {
                                b = fl[i-1];                                                    //grab the begin
                                c = 0;
                                delta = deltas[i];
                                while(i<deltas.length() && deltas[i] == delta) i++,c++;         //increment to the next moment
                                e = fl[i-1];                                                    //grab the end
 
                                if (b==e)               chunks << QString("%1").arg(b);
                                else if (c==1)          chunks << QString("%1,%2").arg(b).arg(e);
                                else if (delta > 1)     chunks << QString("%1-%2x%3").arg(b).arg(e).arg(delta);
                                else                    chunks << QString("%1-%2").arg(b).arg(e);
                        }
 
                        //printf("%s => %s\n",qUtf8Printable(sr),qUtf8Printable(chunks.join(',')));
 
                        int p = digrxrx.indexIn(sr);                                            //position of regex in the regex
                        if (p > -1)
                        {
                                //printf("CAP: %d %s %s\n",p,qUtf8Printable( digrxrx.cap(0) ),qUtf8Printable( digrxrx.cap(1) ));
 
                                int d = digrxrx.cap(1).toInt();                                 //number of digits in the regex
                                sr.replace( digrxrx, QString("[%1#%2]").arg(chunks.join(',')).arg(d) );
                                sr.replace( unescaperx, "\\1" );
                                //printf("%s\n",qUtf8Printable(sr));
                                r[sr] = false;                                                  //finally add the entry to the return list
                        }
                        else if (sr.indexOf(digrx.pattern()) > -1)
                        {
                                sr.replace( digrx.pattern(), QString("[%1@]").arg(chunks.join(',')) );
                                sr.replace( unescaperx, "\\1" );
                                //printf("%s\n",qUtf8Printable(sr));
                                r[sr] = false;                                                  //finally add the entry to the return list
                        }
                        else
                        {       VFS::ERROR( "Unexplained regex error... reverting to non-sequence view: "+sr );
                                return l;
                        }
                }
 
        //printf("==SEQUENCE LISTING END==\n");
 
        //return l;
        return r;
}
 
QStringList rutils::expandSequence(QString sequence)
{
        if (sequence == "")
                return QStringList();
 
        QRegularExpression seqrx( "^([-,x\\d]+)([@#]?)(\\d*)$");
 
        QRegularExpressionMatch match = seqrx.match(sequence);
        if (match.hasMatch())
        {
                bool ok=false;
                QStringList l;
 
                QString seq = match.captured(1);
                QString hash = match.captured(2);
                int pad = match.captured(3).toInt(&ok);
 
                if (!ok) pad = 0;
                if (hash=="" || hash=="@") pad = 0;
 
                //printf( "match: %s\n", qUtf8Printable( QString("%1 %2 %3 %4").arg(prefix).arg(seq).arg(pad).arg(ext) ) );
 
                QStringList n = seq.split(",",Qt::SkipEmptyParts);
 
                QRegularExpression digrx( "^(-?\\d+)$");                        //an optional sign character followed by one or more digits
                QRegularExpression rangerx( "^(-?\\d+)-(-?\\d+)$");             //a pair of digrx connected by a '-' to create a range
                QRegularExpression steprx( "^(-?\\d+)-(-?\\d+)x(\\d+)$");       //a rangerx with a step
                QRegularExpressionMatch m;
                int b=0,e=0,s=1;
                ok = false;
 
                while (n.length())
                {
                        QString c = n.takeFirst();
                        ok = false;
 
                        if (!ok)
                        {
                                m = steprx.match(c);
                                if (m.hasMatch())
                                {       b = m.captured(1).toInt();
                                        e = m.captured(2).toInt();
                                        s = m.captured(3).toInt();
                                        ok = true;
                                }
                        }
 
                        if (!ok)
                        {
                                m = rangerx.match(c);
                                if (m.hasMatch())
                                {       b = m.captured(1).toInt();
                                        e = m.captured(2).toInt();
                                        s = 1;
                                        ok = true;
                                }
                        }
 
                        if (!ok)
                        {
                                m = digrx.match(c);
                                if (m.hasMatch())
                                {       b = e = m.captured(1).toInt();
                                        s = 1;
                                        ok = true;
                                }
                        }
 
                        if (!ok || b > e)
                        {       VFS::ERROR("Invalid range: "+sequence);
                                return QStringList();
                        }
 
                        for (int i=b;i<=e;i+=s)
                                //l << QString("%1.%2%3.%4").arg(prefix).arg(i<0?"-":"").arg(abs(i),pad.toInt(),10,QChar('0')).arg(ext);
                                l << QString("%1").arg(i,pad,10,QChar('0'));
                }
 
                return l;
        }
        else
                VFS::ERROR("Invalid sequence: "+sequence);
 
        return QStringList();
}
 
QStringList rutils::expandSequenceListing(QString sequence)
{
        QRegularExpression seqrx( "^(.*)\\.\\[([-,x\\d]+)#(\\d+)\\]\\.(\\w{2,5})$");                            //support extensions from 2-5 alphanumeric characters
 
        QRegularExpressionMatch match = seqrx.match(sequence);
        if (match.hasMatch())
        {
                QStringList l;
 
                QString prefix = match.captured(1);
                QString seq = match.captured(2);
                QString pad = match.captured(3);
                QString ext = match.captured(4);
 
                //printf( "match: %s\n", qUtf8Printable( QString("%1 %2 %3 %4").arg(prefix).arg(seq).arg(pad).arg(ext) ) );
 
                QStringList n = seq.split(",",Qt::SkipEmptyParts);
 
                QRegularExpression digrx( "^(-?\\d+)$");                        //an optional sign character followed by one or more digits
                QRegularExpression rangerx( "^(-?\\d+)-(-?\\d+)$");             //a pair of digrx connected by a '-' to create a range
                QRegularExpression steprx( "^(-?\\d+)-(-?\\d+)x(\\d+)$");       //a rangerx with a step
                QRegularExpressionMatch m;
                int b=0,e=0,s=1;
                bool ok = false;
 
                while (n.length())
                {
                        QString c = n.takeFirst();
                        ok = false;
 
                        if (!ok)
                        {
                                m = steprx.match(c);
                                if (m.hasMatch())
                                {       b = m.captured(1).toInt();
                                        e = m.captured(2).toInt();
                                        s = m.captured(3).toInt();
                                        ok = true;
                                }
                        }
 
                        if (!ok)
                        {
                                m = rangerx.match(c);
                                if (m.hasMatch())
                                {       b = m.captured(1).toInt();
                                        e = m.captured(2).toInt();
                                        s = 1;
                                        ok = true;
                                }
                        }
 
                        if (!ok)
                        {
                                m = digrx.match(c);
                                if (m.hasMatch())
                                {       b = e = m.captured(1).toInt();
                                        s = 1;
                                        ok = true;
                                }
                        }
 
                        if (!ok || b > e)
                        {       VFS::ERROR("Invalid range: "+sequence);
                                return QStringList();
                        }
 
                        for (int i=b;i<=e;i+=s)
                                //l << QString("%1.%2%3.%4").arg(prefix).arg(i<0?"-":"").arg(abs(i),pad.toInt(),10,QChar('0')).arg(ext);
                                l << QString("%1.%2.%3").arg(prefix).arg(i,pad.toInt(),10,QChar('0')).arg(ext);
                }
 
                //printf("LIST: %s\n",qPrintable(l.join(" ")));
 
                return l;
        }
        else
                VFS::ERROR("Invalid sequence: "+sequence);
 
        return QStringList();
}
 
 
 
QByteArray rutils::encodeBase64Path( QJsonObject p )
{
        QJsonDocument d(p);
        QByteArray r = d.toJson().toBase64();
        QByteArray b = r.replace('/','_');
 
        return b;
}
 
 
 
QJsonObject rutils::decodeBase64Path( QByteArray p, bool *ok )
{
        QByteArray r = p.replace('_','/');
        QByteArray b = QByteArray::fromBase64(r);
 
        QJsonParseError e;
        QJsonDocument d = QJsonDocument::fromJson(b,&e);
 
        if (!d.isNull() && e.error == QJsonParseError::NoError)
        {       *ok = true;
                return d.object();
        }
 
        *ok = false;
        return QJsonObject();
}
 
QString rutils::unescapeXMLAttribute( QString attribute )
{
        attribute = attribute.replace("&lt;","<");
        attribute = attribute.replace("&gt;",">");
 
        return attribute;
}
 
 
//https://www.tutorialspoint.com/How-to-execute-a-command-and-get-the-output-of-command-within-Cplusplus-using-POSIX
QStringList rutils::exec(QString command,bool *ok)
{
        QString result;
 
        // Open pipe to file
        FILE* pipe = popen(qUtf8Printable(command), "r");
        if (!pipe)
        {
                if (ok) *ok = false;
                return QStringList();
        }
 
        // read till end of process:
        char buffer[128];
        while (!feof(pipe))
        {
                // use buffer to read and add to result
                if (fgets(buffer, 128, pipe) != nullptr)
                        result += buffer;
        }
 
        pclose(pipe);
 
        if (ok) *ok = true;
        return result.split("\n",Qt::SkipEmptyParts);
}