Ticket #5288: 5288-v3.patch

File 5288-v3.patch, 14.0 KB (added by danielk, 11 years ago)
  • libs/libmythtv/jobqueue.cpp

     
    19201920    int retrylimit = 3;
    19211921    while (retry)
    19221922    {
    1923         off_t origfilesize, filesize;
    1924         struct stat st;
    1925 
    19261923        retry = false;
    19271924
    19281925        ChangeJobStatus(jobID, JOB_STARTING);
     
    19301927
    19311928        QString filename = program_info->GetPlaybackURL(false, true);
    19321929
    1933         origfilesize = 0;
    1934         filesize = 0;
     1930        long long filesize = 0;
     1931        long long origfilesize = QFileInfo(filename).size();
    19351932
    1936         QByteArray fname = filename.toLocal8Bit();
    1937         if (stat(fname.constData(), &st) == 0)
    1938             origfilesize = st.st_size;
    1939 
    19401933        QString msg = QString("Transcode %1")
    19411934                              .arg(StatusText(GetJobStatus(jobID)));
    19421935
     
    19931986                retry = false;
    19941987
    19951988                filename = program_info->GetPlaybackURL(false, true);
    1996                 QByteArray fname = filename.toAscii();
     1989                QFileInfo st(filename);
    19971990
    1998                 if (stat(fname.constData(), &st) == 0)
     1991                if (st.exists())
    19991992                {
    2000                     filesize = st.st_size;
     1993                    filesize = st.size();
    20011994
    20021995                    QString comment = QString("%1: %2 => %3")
    20031996                                            .arg(transcoderName)
     
    20162009                }
    20172010                else
    20182011                {
    2019                     int saved = errno;
    2020                     QString comment = QString("couldn't stat \"%1\": %2")
    2021                         .arg(filename).arg(strerror(saved));
     2012                    QString comment =
     2013                        QString("could not stat '%1'").arg(filename);
     2014
    20222015                    ChangeJobStatus(jobID, JOB_FINISHED, comment);
    20232016
    20242017                    details = QString("%1%2: %3")
  • libs/libmythtv/previewgenerator.cpp

     
    606606    if (filename.left(1)=="/")
    607607    {
    608608        QFileInfo info(filename);
    609         bool invalid = !info.exists() || !info.isReadable() || !info.isFile();
    610         if (!invalid)
    611         {
    612             // Check size too, QFileInfo can not handle large files
    613             unsigned long long fsize =
    614                 myth_get_approximate_large_file_size(filename);
    615             invalid = (fsize < 8*1024);
    616         }
     609        bool invalid = (!info.exists() || !info.isReadable() ||
     610                        !info.isFile() || (info.size() < 8*1024));
    617611        if (invalid)
    618612        {
    619613            VERBOSE(VB_IMPORTANT, LOC_ERR + "Previewer file " +
  • libs/libmythtv/RingBuffer.cpp

     
    66
    77// POSIX C headers
    88#include <sys/types.h>
    9 #include <sys/stat.h>
    109#include <sys/time.h>
    1110#include <unistd.h>
    1211#include <fcntl.h>
     
    13561355    if (remotefile)
    13571356        return remotefile->GetFileSize();
    13581357
    1359     struct stat st;
    1360     QByteArray fname = filename.toLocal8Bit();
    1361     if (stat(fname.constData(), &st) == 0)
    1362         return st.st_size;
    1363     return -1;
     1358    QFileInfo info(filename);
     1359    return info.size();
    13641360}
    13651361
    13661362/** \fn RingBuffer::LiveMode(void) const
  • libs/libmyth/util.h

     
    5858MPUBLIC long long copy(QFile &dst, QFile &src, uint block_size = 0);
    5959MPUBLIC QString createTempFile(QString name_template = "/tmp/mythtv_XXXXXX",
    6060                               bool dir = false);
    61 MPUBLIC unsigned long long myth_get_approximate_large_file_size(
    62     const QString &fname);
    6361
    6462MPUBLIC double MythGetPixelAspectRatio(void);
    6563
  • libs/libmyth/util.cpp

     
    1515#include "compat.h"
    1616#ifdef USING_MINGW
    1717# include <sys/types.h>
    18 # include <sys/stat.h>
    1918# include <sys/param.h>
    2019#else
    2120# include <sys/types.h>
    2221# include <sys/wait.h>
    23 # include <sys/stat.h>
    2422# ifdef linux
    2523#   include <sys/vfs.h>
    26 #   include <sys/statvfs.h>
    2724#   include <sys/sysinfo.h>
    2825# else
    2926#   include <sys/param.h>
    3027#   ifdef __FreeBSD__
    3128#     include <sys/mount.h>
    3229#   endif
    33 #   ifdef CONFIG_CYGWIN
    34 #     include <sys/statfs.h>
    35 #   else // if !CONFIG_CYGWIN
    36 #     include <sys/sysctl.h>
    37 #   endif // !CONFIG_CYGWIN
    3830# endif
    3931#endif //MINGW
    4032
     
    813805    return pixelAspect;
    814806}
    815807
    816 unsigned long long myth_get_approximate_large_file_size(const QString &fname)
    817 {
    818     QByteArray filename = fname.toLocal8Bit();
    819 #ifdef USING_MINGW
    820     struct _stati64 status;
    821     _stati64(filename.constData(), &status);
    822     return status.st_size;
    823 #else
    824     struct stat status;
    825     if (stat(filename.constData(), &status) == -1)
    826         return 0;
    827 
    828     // Using off_t requires a lot of 32/64 bit checking.
    829     // So just get the size in blocks.
    830     unsigned long long bsize = status.st_blksize;
    831     unsigned long long nblk  = status.st_blocks;
    832     unsigned long long approx_size = nblk * bsize;
    833     return approx_size;
    834 #endif
    835 }
    836 
    837808/**
    838809 * In an interactive shell, prompt the user to input a string
    839810 */
  • libs/libmythupnp/httprequest.cpp

     
    317317    setsockopt( getSocketHandle(), SOL_TCP, TCP_CORK, &g_on, sizeof( g_on ));
    318318#endif
    319319
    320     if (QFile::exists( sFileName ))
     320    QFile tmpFile( sFileName );
     321    if (tmpFile.exists( ) && tmpFile.open( QIODevice::ReadOnly ))
    321322    {
    322323
    323324        m_sResponseTypeText = TestMimeType( sFileName );
     
    326327        // Get File size
    327328        // ------------------------------------------------------------------
    328329
    329         struct stat st;
     330        llSize = llEnd = tmpFile.size( );
    330331
    331         QByteArray tmp = sFileName.toAscii();
    332         if (stat( tmp.constData(), &st ) == 0)
    333             llSize = llEnd = st.st_size;
    334 
    335332        m_nResponseStatus = 200;
    336333
    337334        // ------------------------------------------------------------------
     
    405402    if (( m_eType != RequestTypeHead ) && (llSize != 0))
    406403    {
    407404        __off64_t  offset = llStart;
    408         QByteArray tmp    = sFileName.toAscii();
    409         int        file   = open( tmp.constData(), O_RDONLY | O_LARGEFILE );
     405        int        file   = tmpFile.handle( );
    410406        ssize_t    sent   = 0; 
    411407
    412         do
    413         { 
    414             // SSIZE_MAX should work in kernels 2.6.16 and later. 
    415             // The loop is needed in any case. 
     408        if ( file == -1 )
     409        {
     410            VERBOSE(VB_UPNP, QString("SendResponseFile( %1 ) Error: %2 [%3]" )
     411                                 .arg( sFileName )
     412                                 .arg( tmpFile.error( ))
     413                                 .arg( strerror( tmpFile.error( ) )));
     414            nBytes = -1;
     415        }
     416        else
     417        {
     418            do
     419            {
     420                // SSIZE_MAX should work in kernels 2.6.16 and later.
     421                // The loop is needed in any case.
    416422
    417             sent = sendfile64( getSocketHandle(), file, &offset,
    418                                 (size_t)(llSize > INT_MAX ? INT_MAX : llSize)); 
     423                sent = sendfile64(
     424                    getSocketHandle(), file, &offset,
     425                    (size_t) ((llSize > INT_MAX) ? INT_MAX : llSize));
    419426
    420             llSize  = llEnd - offset; 
    421             //VERBOSE(VB_UPNP, QString("SendResponseFile : --- size = %1, offset = %2, sent = %3").arg(llSize).arg(offset).arg(sent));
    422         }
    423         while (( sent >= 0 ) && ( llSize > 0 )); 
     427                llSize  = llEnd - offset; 
     428                //VERBOSE(VB_UPNP, QString("SendResponseFile : --- "
     429                //"size = %1, offset = %2, sent = %3")
     430                //.arg(llSize).arg(offset).arg(sent));
     431            }
     432            while (( sent >= 0 ) && ( llSize > 0 )); 
     433        }
    424434
    425435        if (sent == -1)
    426436        {
     
    431441
    432442            nBytes = -1;
    433443        }
    434            
    435         close( file );
    436444    }
    437445
    438446    // ----------------------------------------------------------------------
  • libs/libmythdb/mythversion.h

     
    88/// Update this whenever the plug-in API changes.
    99/// Including changes in the libmyth, libmythtv and libmythui class methods
    1010/// used by plug-ins.
    11 #define MYTH_BINARY_VERSION "0.22.20080818-1"
     11#define MYTH_BINARY_VERSION "0.22.20080819-1"
    1212
    1313/** \brief Increment this whenever the MythTV network protocol changes.
    1414 *
  • programs/mythtranscode/mpeg2fix.cpp

     
    77
    88#include <stdlib.h>
    99#include <stdio.h>
    10 #include <sys/types.h>
    11 #include <sys/stat.h>
    1210#include <fcntl.h>
    1311#include <unistd.h>
    1412#include <getopt.h>
     
    1614
    1715#include <Q3ValueList>
    1816#include <Q3PtrList>
     17#include <QFileInfo>
    1918
    2019#ifdef USING_MINGW
    2120#include <winsock2.h>
     
    271270        statustime = QDateTime::currentDateTime();
    272271        statustime = statustime.addSecs(status_update_time);
    273272
    274         struct stat filestat;
    275         if(stat(inf, &filestat)) {
    276         }
    277         filesize = filestat.st_size;
     273        const QFileInfo finfo(inf);
     274        filesize = finfo.size();
    278275    }
    279276}
    280277
  • programs/mythtranscode/main.cpp

     
    1 #include <qapplication.h>
    2 #include <qdir.h>
     1// POSIX headers
     2#include <fcntl.h> // for open flags
    33
    4 #include <unistd.h>
    5 #include <sys/types.h>
    6 #include <sys/stat.h>
    7 #include <fcntl.h>
     4// C++ headers
    85#include <iostream>
    96#include <fstream>
    107using namespace std;
    118
     9// Qt headers
     10#include <QApplication>
     11#include <QDir>
     12
     13// MythTV headers
    1214#include "exitcodes.h"
    1315#include "programinfo.h"
    1416#include "jobqueue.h"
     
    726728    QByteArray fname = filename.toLocal8Bit();
    727729    QString msg = QString("Error Truncating '%1'").arg(fname.constData());
    728730
    729 
    730     struct stat st;
    731     if (stat(fname.constData(), &st) != 0)
    732     {
    733         VERBOSE(VB_IMPORTANT, msg + " could not stat " + ENO +
    734                 ", unlinking immediately.");
     731    QFileInfo info(filename);
     732    long long fsize = info.size();
     733    if (fsize <= increment)
    735734        return unlink(fname.constData());
    736     }
    737     off_t fsize = st.st_size;
    738735
    739736    int fd = open(fname.constData(), O_WRONLY);
    740737    if (fd == -1)
  • programs/mythbackend/filetransfer.cpp

     
    1 #include <qapplication.h>
    2 #include <qdatetime.h>
     1#include <QApplication>
     2#include <QDateTime>
     3#include <QFileInfo>
    34
    4 #include <unistd.h>
    5 #include <iostream>
    6 #include <sys/types.h>
    7 #include <sys/stat.h>
    8 using namespace std;
    9 
    105#include "filetransfer.h"
    116#include "RingBuffer.h"
    127#include "util.h"
     
    157152
    158153long long FileTransfer::GetFileSize(void)
    159154{
    160     QString filename = rbuffer->GetFilename();
    161 
    162     struct stat st;
    163     long long size = 0;
    164 
    165     QByteArray fname = filename.toLocal8Bit();
    166     if (stat(fname.constData(), &st) == 0)
    167         size = st.st_size;
    168 
    169     return size;
     155    return QFileInfo(rbuffer->GetFilename()).size();
    170156}
    171157
    172158void FileTransfer::SetTimeout(bool fast)
  • programs/mythbackend/mainserver.cpp

     
    13461346                    QFile checkFile(tmpURL);
    13471347                    if (tmpURL != "" && checkFile.exists())
    13481348                    {
    1349                         QByteArray atmpurl = tmpURL.toLocal8Bit();
    1350                         struct stat st;
    1351                         if (stat(atmpurl.constData(), &st) == 0)
    1352                         {
    1353                             proginfo->filesize = st.st_size;
    1354 
    1355                             if (proginfo->recendts < QDateTime::currentDateTime())
    1356                                 proginfo->SetFilesize(proginfo->filesize);
    1357                         }
     1349                        proginfo->filesize = checkFile.size();
     1350                        if (proginfo->recendts < QDateTime::currentDateTime())
     1351                            proginfo->SetFilesize(proginfo->filesize);
    13581352                    }
    13591353                }
    13601354            }
     
    14781472        pginfo->pathname = QString("myth://") + ip + ":" + port
    14791473                           + "/" + pginfo->GetRecordBasename();
    14801474
    1481     struct stat st;
     1475    const QFileInfo info(lpath);
     1476    pginfo->filesize = info.size();
    14821477
    1483     long long size = 0;
    1484     QByteArray apath = lpath.toLocal8Bit();
    1485     if (stat(apath.constData(), &st) == 0)
    1486         size = st.st_size;
    1487 
    1488     pginfo->filesize = size;
    1489 
    14901478    QStringList strlist;
    14911479
    14921480    pginfo->ToStringList(strlist);
     
    15991587    {
    16001588        // Since stat fails after unlinking on some filesystems,
    16011589        // get the filesize first
    1602         QByteArray fname = ds->filename.toLocal8Bit();
    1603         struct stat st;
    1604         if (stat(fname.constData(), &st) == 0)
    1605             size = st.st_size;
     1590        const QFileInfo info(ds->filename);
     1591        size = info.size();
    16061592        fd = DeleteFile(ds->filename, followLinks);
    16071593
    16081594        if ((fd < 0) && checkFile.exists())