Ticket #5866: mpegrecorder-hdpvr-v2a.patch

File mpegrecorder-hdpvr-v2a.patch, 19.3 KB (added by jppoet@…, 11 years ago)

Minor refresh to mpegrecorder-hdpvr-v2 so applies to current trunk.

  • libs/libmythtv/DeviceReadBuffer.cpp

    old new bool DeviceReadBuffer::IsPaused(void) co 
    169169    return paused;
    170170}
    171171
    172 bool DeviceReadBuffer::WaitForUnpause(int timeout)
     172bool DeviceReadBuffer::WaitForPaused(unsigned long timeout)
     173{
     174    QMutexLocker locker(&lock);
     175
     176    if (!paused)
     177        pauseWait.wait(&lock, timeout);
     178
     179    return paused;
     180}
     181
     182bool DeviceReadBuffer::WaitForUnpause(unsigned long timeout)
    173183{
    174184    QMutexLocker locker(&lock);
    175185
  • libs/libmythtv/DeviceReadBuffer.h

    old new class DeviceReadBuffer 
    4242
    4343    void SetRequestPause(bool request);
    4444    bool IsPaused(void) const;
    45     bool WaitForUnpause(int timeout);
     45    bool WaitForUnpause(unsigned long timeout);
     46    bool WaitForPaused(unsigned long timeout);
    4647   
    4748    bool IsErrored(void) const { return error; }
    4849    bool IsEOF(void)     const { return eof;   }
  • libs/libmythtv/mpegrecorder.cpp

    old new using namespace std; 
    1919#include <sys/stat.h>
    2020#include <sys/ioctl.h>
    2121#include <sys/time.h>
     22#include <sys/poll.h>
    2223
    2324// avlib headers
    2425extern "C" {
    MpegRecorder::MpegRecorder(TVRec *rec) : 
    8687    requires_special_pause(false),
    8788    // State
    8889    recording(false),             encoding(false),
    89     needs_resolution(false),      start_stop_encoding_lock(QMutex::Recursive),
     90    start_stop_encoding_lock(QMutex::Recursive),
    9091    recording_wait_lock(),        recording_wait(),
    9192    // Pausing state
    9293    cleartimeonpause(false),
    bool MpegRecorder::OpenV4L2DeviceAsInput 
    493494
    494495bool MpegRecorder::SetFormat(int chanfd)
    495496{
     497    uint   idx;
    496498    struct v4l2_format vfmt;
    497499    bzero(&vfmt, sizeof(vfmt));
    498500
    499501    vfmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    500502
    501     if (ioctl(chanfd, VIDIOC_G_FMT, &vfmt) < 0)
     503    for (idx = 0; idx < 20; ++idx)
     504    {
     505        if (ioctl(chanfd, VIDIOC_G_FMT, &vfmt) == 0)
     506            break;
     507        usleep(100 * 1000);
     508    }
     509
     510    if (idx == 10)
    502511    {
    503512        VERBOSE(VB_IMPORTANT, LOC_ERR + "Error getting format" + ENO);
    504513        return false;
    bool MpegRecorder::SetFormat(int chanfd) 
    507516    vfmt.fmt.pix.width = width;
    508517    vfmt.fmt.pix.height = height;
    509518
    510     if (ioctl(chanfd, VIDIOC_S_FMT, &vfmt) < 0)
     519    for (idx = 0; idx < 20; ++idx)
     520    {
     521        if (ioctl(chanfd, VIDIOC_S_FMT, &vfmt) == 0)
     522            break;
     523        usleep(100 * 1000);
     524    }
     525
     526    if (idx == 20)
    511527    {
    512528        VERBOSE(VB_IMPORTANT, LOC_ERR + "Error setting format" + ENO);
    513529        return false;
    bool MpegRecorder::SetFormat(int chanfd) 
    519535/// Set audio language mode
    520536bool MpegRecorder::SetLanguageMode(int chanfd)
    521537{
     538    uint   idx;
    522539    struct v4l2_tuner vt;
    523540    bzero(&vt, sizeof(struct v4l2_tuner));
    524     if (ioctl(chanfd, VIDIOC_G_TUNER, &vt) < 0)
     541
     542    for (idx = 0; idx < 20; ++idx)
     543    {
     544        if (ioctl(chanfd, VIDIOC_G_TUNER, &vt) == 0)
     545            break;
     546        usleep(100 * 1000);
     547    }
     548
     549    if (idx == 20)
    525550    {
    526551        VERBOSE(VB_IMPORTANT, LOC_WARN + "Unable to get audio mode" + ENO);
    527552        return false;
    bool MpegRecorder::SetLanguageMode(int c 
    555580        success = false;
    556581    }
    557582
    558     if (ioctl(chanfd, VIDIOC_S_TUNER, &vt) < 0)
     583    for (idx = 0; idx < 20; ++idx)
     584    {
     585        if (ioctl(chanfd, VIDIOC_S_TUNER, &vt) == 0)
     586            break;
     587        usleep(100 * 1000);
     588    }
     589
     590    if (idx == 20)
    559591    {
    560592        VERBOSE(VB_IMPORTANT, LOC_WARN + "Unable to set audio mode" + ENO);
    561593        success = false;
    bool MpegRecorder::SetLanguageMode(int c 
    567599bool MpegRecorder::SetRecordingVolume(int chanfd)
    568600{
    569601    // Get volume min/max values
     602    uint   idx;
    570603    struct v4l2_queryctrl qctrl;
    571604    qctrl.id = V4L2_CID_AUDIO_VOLUME;
    572     if (ioctl(chanfd, VIDIOC_QUERYCTRL, &qctrl) < 0)
     605
     606    for (idx = 0; idx < 20; ++idx)
     607    {
     608        if (ioctl(chanfd, VIDIOC_QUERYCTRL, &qctrl) == 0)
     609            break;
     610        usleep(100 * 1000);
     611    }
     612
     613    if (idx == 20)
    573614    {
    574615        VERBOSE(VB_IMPORTANT, LOC_WARN +
    575616                "Unable to get recording volume parameters(max/min)" + ENO +
    bool MpegRecorder::SetRecordingVolume(in 
    588629    ctrl.id = V4L2_CID_AUDIO_VOLUME;
    589630    ctrl.value = ctrl_volume;
    590631
    591     if (ioctl(chanfd, VIDIOC_S_CTRL, &ctrl) < 0)
     632    for (idx = 0; idx < 20; ++idx)
     633    {
     634        if (ioctl(chanfd, VIDIOC_S_CTRL, &ctrl) == 0)
     635            break;
     636        usleep(100 * 1000);
     637    }
     638
     639    if (idx == 20)
    592640    {
    593641        VERBOSE(VB_IMPORTANT, LOC_WARN +
    594642                "Unable to set recording volume" + ENO + "\n\t\t\t" +
    static void set_ctrls(int fd, vector<str 
    771819
    772820    for (uint i = 0; i < ext_ctrls.size(); i++)
    773821    {
     822        uint   idx;
    774823        struct v4l2_ext_controls ctrls;
    775824        bzero(&ctrls, sizeof(struct v4l2_ext_controls));
    776825
    static void set_ctrls(int fd, vector<str 
    780829        ctrls.count       = 1;
    781830        ctrls.controls    = &ext_ctrls[i];
    782831           
    783         if (ioctl(fd, VIDIOC_S_EXT_CTRLS, &ctrls) < 0)
     832        for (idx = 0; idx < 20; ++idx)
     833        {
     834            if (ioctl(fd, VIDIOC_S_EXT_CTRLS, &ctrls) == 0)
     835                break;
     836            usleep(100 * 1000);
     837        }
     838
     839        if (idx == 20)
    784840        {
    785841            QMutexLocker locker(&control_description_lock);
    786842            VERBOSE(VB_IMPORTANT, QString("mpegrecorder.cpp:set_ctrls(): ") +
    bool MpegRecorder::SetV4L2DeviceOptions( 
    820876    {
    821877        maxbitrate = high_mpeg4peakbitrate;
    822878        bitrate    = high_mpeg4avgbitrate;
     879
     880        // query supported audio codecs and prefer AC3
     881        uint   idx;
     882        struct v4l2_queryctrl qctrl;
     883        qctrl.id = V4L2_CID_MPEG_AUDIO_ENCODING;
     884
     885        for (idx = 0; idx < 20; ++idx)
     886        {
     887            if (ioctl(chanfd, VIDIOC_QUERYCTRL, &qctrl) == 0)
     888                break;
     889            usleep(100 * 1000);
     890        }
     891
     892        if (idx == 20)
     893        {
     894            VERBOSE(VB_IMPORTANT, LOC_WARN +
     895                    "Unable to get supported audio codecs." + ENO);
     896        }
     897        else
     898        {
     899            if (qctrl.minimum != qctrl.maximum)
     900                add_ext_ctrl(ext_ctrls, V4L2_CID_MPEG_AUDIO_ENCODING,
     901                             qctrl.maximum);
     902        }
    823903    }
    824904    maxbitrate = std::max(maxbitrate, bitrate);
    825905
    bool MpegRecorder::SetV4L2DeviceOptions( 
    843923    int audioinput = audiodevice.toUInt(&ok);
    844924    if (ok)
    845925    {
     926        uint   idx;
    846927        struct v4l2_audio ain;
    847928        bzero(&ain, sizeof(ain));
    848929        ain.index = audioinput;
    849         if (ioctl(chanfd, VIDIOC_ENUMAUDIO, &ain) < 0)
     930
     931        for (idx = 0; idx < 20; ++idx)
     932        {
     933            if (ioctl(chanfd, VIDIOC_ENUMAUDIO, &ain) == 0)
     934                break;
     935            usleep(100 * 1000);
     936        }
     937
     938        if (idx == 20)
    850939        {
    851940            VERBOSE(VB_IMPORTANT, LOC_WARN +
    852941                    "Unable to get audio input.");
    bool MpegRecorder::SetV4L2DeviceOptions( 
    854943        else
    855944        {
    856945            ain.index = audioinput;
    857             if (ioctl(chanfd, VIDIOC_S_AUDIO, &ain) < 0)
     946
     947            for (idx = 0; idx < 20; ++idx)
     948            {
     949                if (ioctl(chanfd, VIDIOC_S_AUDIO, &ain) == 0)
     950                    break;
     951                usleep(100 * 1000);
     952            }
     953
     954            if (idx == 20)
    858955            {
    859956                VERBOSE(VB_IMPORTANT, LOC_WARN +
    860957                        "Unable to set audio input.");
    void MpegRecorder::StartRecording(void) 
    10421139    if (deviceIsMpegFile)
    10431140        elapsedTimer.start();
    10441141    else if (_device_read_buffer)
    1045         _device_read_buffer->Start();
     1142    {
     1143        VERBOSE(VB_RECORD, LOC + "Initial startup of recorder");
    10461144
    1047     needs_resolution = (driver == "hdpvr");
     1145        if (StartEncoding(readfd))
     1146            _device_read_buffer->Start();
     1147        else
     1148        {
     1149            VERBOSE(VB_IMPORTANT, LOC_ERR + "Failed to start recording");
     1150            recording = false;
     1151            QMutexLocker locker(&recording_wait_lock);
     1152            recording_wait.wakeAll();
     1153            _error = true;
     1154        }
     1155    }
    10481156
    10491157    QByteArray vdevice = videodevice.toAscii();
    10501158    while (encoding && !_error)
    10511159    {
    10521160        if (PauseAndWait(100))
    10531161            continue;
    1054 
    1055         HandleResolutionChanges();
    10561162       
    10571163        if (deviceIsMpegFile)
    10581164        {
    void MpegRecorder::StartRecording(void) 
    10961202            {
    10971203                VERBOSE(VB_IMPORTANT, LOC_ERR + "Device error detected");
    10981204
    1099                 _device_read_buffer->Stop();
    1100 
    1101                 QMutexLocker locker(&start_stop_encoding_lock);
    1102 
    1103                 StopEncoding(readfd);
    1104 
    1105                 // Make sure the next things in the file are a PAT & PMT
    1106                 if (_stream_data->PATSingleProgram() &&
    1107                     _stream_data->PMTSingleProgram())
    1108                 {
    1109                     bool tmp = _wait_for_keyframe_option;
    1110                     _wait_for_keyframe_option = false;
    1111                     HandleSingleProgramPAT(_stream_data->PATSingleProgram());
    1112                     HandleSingleProgramPMT(_stream_data->PMTSingleProgram());
    1113                     _wait_for_keyframe_option = tmp;
    1114                 }
    1115 
    1116                 if (StartEncoding(readfd))
    1117                 {
    1118                     _device_read_buffer->Start();
    1119                 }
    1120                 else
    1121                 {
    1122                     if (0 != close(readfd))
    1123                         VERBOSE(VB_IMPORTANT, LOC_ERR + "Close error" + ENO);
    1124                    
    1125                     // Force card to be reopened on next iteration..
    1126                     readfd = -1;
    1127                 }
     1205                RestartEncoding();
    11281206            }
    11291207            else if (_device_read_buffer->IsEOF())
    11301208            {
    void MpegRecorder::StartRecording(void) 
    12221300        }
    12231301    }
    12241302
     1303    VERBOSE(VB_RECORD, LOC + "StartRecording finishing up");
     1304
    12251305    if (_device_read_buffer)
    12261306    {
    12271307        if (_device_read_buffer->IsRunning())
    void MpegRecorder::StartRecording(void) 
    12301310        delete _device_read_buffer;
    12311311        _device_read_buffer = NULL;
    12321312    }
     1313
    12331314    StopEncoding(readfd);
    12341315
    12351316    FinishRecording();
    bool MpegRecorder::PauseAndWait(int time 
    13791460
    13801461        if (!paused)
    13811462        {
     1463            VERBOSE(VB_RECORD, LOC + "PauseAndWait pause");
     1464
    13821465            if (_device_read_buffer)
    13831466            {
    13841467                QMutex drb_lock;
    13851468                drb_lock.lock();
    1386 
    13871469                _device_read_buffer->SetRequestPause(true);
    1388 
    1389                 pauseWait.wait(&drb_lock, timeout);
    1390             }
    1391             else
    1392             {
    1393                 paused = true;
    1394                 pauseWait.wakeAll();
     1470                _device_read_buffer->WaitForPaused(4000);
    13951471            }
    13961472
    13971473            // Some drivers require streaming to be disabled before
    bool MpegRecorder::PauseAndWait(int time 
    13991475            if (requires_special_pause)
    14001476                StopEncoding(readfd);
    14011477
     1478            paused = true;
     1479            pauseWait.wakeAll();
     1480
    14021481            if (tvrec)
    14031482                tvrec->RecorderPaused();
    14041483        }
    14051484
    14061485        unpauseWait.wait(&waitlock, timeout);
    14071486    }
    1408     if (!request_pause)
     1487
     1488    if (!request_pause && paused)
    14091489    {
    1410         if (paused)
     1490        VERBOSE(VB_RECORD, LOC + "PauseAndWait unpause");
     1491
     1492        if (driver == "hdpvr")
    14111493        {
    1412             // Some drivers require streaming to be disabled before
    1413             // an input switch and other channel format setting.
    1414             if (requires_special_pause)
    1415                 StartEncoding(readfd);
     1494            m_h264_parser.Reset();
     1495            _wait_for_keyframe_option = true;
     1496            _seen_sps = false;
     1497        }
    14161498
    1417             if (_device_read_buffer)
    1418                 _device_read_buffer->SetRequestPause(false);
     1499        // Some drivers require streaming to be disabled before
     1500        // an input switch and other channel format setting.
     1501        if (requires_special_pause)
     1502            StartEncoding(readfd);
     1503       
     1504        if (_device_read_buffer)
     1505            _device_read_buffer->SetRequestPause(false);
     1506       
     1507        if (_stream_data)
     1508            _stream_data->Reset(_stream_data->DesiredProgram());
    14191509
    1420             if (_stream_data)
    1421                 _stream_data->Reset(_stream_data->DesiredProgram());
    1422         }
    14231510        paused = false;
    14241511    }
     1512
    14251513    return paused;
    14261514}
    14271515
     1516void MpegRecorder::RestartEncoding(void)
     1517{
     1518    VERBOSE(VB_RECORD, LOC + "RestartEncoding");
     1519
     1520    _device_read_buffer->Stop();
     1521   
     1522    QMutexLocker locker(&start_stop_encoding_lock);
     1523   
     1524    StopEncoding(readfd);
     1525   
     1526    // Make sure the next things in the file are a PAT & PMT
     1527    if (_stream_data->PATSingleProgram() &&
     1528        _stream_data->PMTSingleProgram())
     1529    {
     1530        _wait_for_keyframe_option = false;
     1531        HandleSingleProgramPAT(_stream_data->PATSingleProgram());
     1532        HandleSingleProgramPMT(_stream_data->PMTSingleProgram());
     1533    }
     1534   
     1535    if (StartEncoding(readfd))
     1536    {
     1537        _device_read_buffer->Start();
     1538    }
     1539    else
     1540    {
     1541        if (0 != close(readfd))
     1542            VERBOSE(VB_IMPORTANT, LOC_ERR + "Close error" + ENO);
     1543       
     1544        readfd = -1;
     1545    }
     1546}
     1547
    14281548bool MpegRecorder::StartEncoding(int fd)
    14291549{
    14301550    QMutexLocker locker(&start_stop_encoding_lock);
    bool MpegRecorder::StartEncoding(int fd) 
    14331553    memset(&command, 0, sizeof(struct v4l2_encoder_cmd));
    14341554    command.cmd = V4L2_ENC_CMD_START;
    14351555
     1556    if (driver == "hdpvr")
     1557        HandleResolutionChanges();
     1558
    14361559    VERBOSE(VB_RECORD, LOC + "StartEncoding");
    1437     needs_resolution = (driver == "hdpvr");
    14381560
    1439     for (int idx = 0; idx < 10; ++idx)
     1561    for (int idx = 0; idx < 20; ++idx)
    14401562    {
    14411563        if (ioctl(fd, VIDIOC_ENCODER_CMD, &command) == 0)
    14421564        {
     1565            if (driver == "hdpvr")
     1566            {
     1567                m_h264_parser.Reset();
     1568                _wait_for_keyframe_option = true;
     1569                _seen_sps = false;
     1570            }
     1571
    14431572            VERBOSE(VB_RECORD, LOC + "Encoding started");
    14441573            return true;
    14451574        }
    bool MpegRecorder::StartEncoding(int fd) 
    14501579            return false;
    14511580        }
    14521581
    1453         usleep(250 * 1000);
     1582        usleep(100 * 1000);
    14541583    }
    14551584
    14561585    VERBOSE(VB_IMPORTANT, LOC_ERR + "StartEncoding - giving up" + ENO);
    bool MpegRecorder::StopEncoding(int fd) 
    14671596
    14681597    VERBOSE(VB_RECORD, LOC + "StopEncoding");
    14691598
    1470     for (int idx = 0; idx < 10; ++idx)
     1599    for (int idx = 0; idx < 20; ++idx)
    14711600    {
    1472 
    14731601        if (ioctl(fd, VIDIOC_ENCODER_CMD, &command) == 0)
    14741602        {
    14751603            VERBOSE(VB_RECORD, LOC + "Encoding stopped");
    bool MpegRecorder::StopEncoding(int fd) 
    14821610            return false;
    14831611        }
    14841612
    1485         usleep(250 * 1000);
     1613        usleep(100 * 1000);
    14861614    }
    14871615
    14881616    VERBOSE(VB_IMPORTANT, LOC_ERR + "StopEncoding - giving up" + ENO);
    void MpegRecorder::HandleSingleProgramPA 
    15501678void MpegRecorder::HandleSingleProgramPMT(ProgramMapTable *pmt)
    15511679{
    15521680    if (!pmt)
    1553 {
     1681    {
    15541682        return;
    15551683    }
    15561684
    void MpegRecorder::HandleSingleProgramPM 
    15701698        DTVRecorder::BufferedWrite(*(reinterpret_cast<TSPacket*>(&buf[i])));
    15711699}
    15721700
    1573 void MpegRecorder::HandleResolutionChanges(void)
     1701bool MpegRecorder::WaitFor_HDPVR(void)
    15741702{
    1575     if (!needs_resolution)
    1576         return;
     1703    // After a resolution change, it can take the HD-PVR a few
     1704    // seconds before it is usable again.
     1705
     1706    // Tell it to start encoding, then wait for it to actually feed us
     1707    // some data.
     1708    QMutexLocker locker(&start_stop_encoding_lock);
     1709
     1710
     1711    // Sleep any less than 1.5 seconds, and the HD-PVR will
     1712    // return the old resolution, when the resolution is changing.
     1713    usleep(1500 * 1000);
    15771714
     1715    struct v4l2_encoder_cmd command;
     1716    struct pollfd polls;
     1717    int    idx;
     1718
     1719    memset(&command, 0, sizeof(struct v4l2_encoder_cmd));
     1720    command.cmd = V4L2_ENC_CMD_START;
     1721
     1722    for (idx = 0; idx < 20; ++idx)
     1723    {
     1724        if (ioctl(readfd, VIDIOC_ENCODER_CMD, &command) == 0)
     1725            break;
     1726        usleep(100 * 1000);
     1727    }
     1728
     1729    if (idx == 20)
     1730        return false;
     1731
     1732    polls.fd      = readfd;
     1733    polls.events  = POLLIN;
     1734    polls.revents = 0;
     1735
     1736    for (idx = 0; idx < 10; ++idx)
     1737    {
     1738        if (poll(&polls, 1, 250) > 0)
     1739            break;
     1740    }
     1741
     1742    if (idx == 10)
     1743        return false;
     1744
     1745    // HD-PVR should now be "ready"
     1746    command.cmd = V4L2_ENC_CMD_STOP;
     1747
     1748    for (idx = 0; idx < 20; ++idx)
     1749    {
     1750        if (ioctl(readfd, VIDIOC_ENCODER_CMD, &command) == 0)
     1751            return true;
     1752        usleep(100 * 1000);
     1753    }
     1754
     1755    return false;
     1756}
     1757
     1758void MpegRecorder::HandleResolutionChanges(void)
     1759{
    15781760    VERBOSE(VB_RECORD, LOC + "Checking Resolution");
    15791761    struct v4l2_format vfmt;
    15801762    memset(&vfmt, 0, sizeof(vfmt));
    15811763    vfmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    15821764           
     1765    if (driver == "hdpvr")
     1766        WaitFor_HDPVR();
     1767
     1768    uint idx;
    15831769    uint pix = 0;
     1770
     1771    for (idx = 0; idx < 20; ++idx)
     1772    {
    15841773    if (0 == ioctl(chanfd, VIDIOC_G_FMT, &vfmt))
    15851774    {
    15861775        VERBOSE(VB_RECORD, LOC + QString("Got Resolution %1x%2")
    15871776                .arg(vfmt.fmt.pix.width).arg(vfmt.fmt.pix.height));
    15881777        pix = vfmt.fmt.pix.width * vfmt.fmt.pix.height;
    1589         needs_resolution = false;
     1778            break;
     1779        }
     1780        // Typically takes 0.9 seconds after a resolution change
     1781        usleep(100 * 1000);
    15901782    }
    15911783
    15921784    if (!pix)
     1785    {
     1786        VERBOSE(VB_RECORD, LOC + "Giving up detecting resolution");
    15931787        return; // nothing to do, we don't have a resolution yet
     1788    }
    15941789
    15951790    int old_max = maxbitrate, old_avg = bitrate;
    15961791    if (pix <= 768*568)
    void MpegRecorder::HandleResolutionChang 
    16481843                     maxbitrate * 1000);
    16491844
    16501845        set_ctrls(readfd, ext_ctrls);
    1651     }
    16521846
    1653     // Restart streaming. Shouldn't be needed? seems to be with current driver.
    1654     QMutexLocker locker(&start_stop_encoding_lock);
    1655     StopEncoding(readfd);
    1656     StartEncoding(readfd);
    1657 
    1658     needs_resolution = false;
     1847    }
    16591848}
  • libs/libmythtv/mpegrecorder.h

    old new class MpegRecorder : public DTVRecorder, 
    8080    uint GetFilteredAudioLayer(void) const;
    8181    uint GetFilteredAudioBitRate(uint audio_layer) const;
    8282
     83    void RestartEncoding(void);
    8384    bool StartEncoding(int fd);
    8485    bool StopEncoding(int fd);
    8586
    8687    void ResetForNewFile(void);
    8788
     89    bool WaitFor_HDPVR(void);
    8890    void HandleResolutionChanges(void);
    8991
    9092    inline bool CheckCC(uint pid, uint cc);
    class MpegRecorder : public DTVRecorder, 
    104106    // State
    105107    bool recording;
    106108    bool encoding;
    107     bool needs_resolution;
    108109    mutable QMutex start_stop_encoding_lock;
    109110    QMutex recording_wait_lock;
    110111    QWaitCondition recording_wait;
    class MpegRecorder : public DTVRecorder, 
    113114    bool cleartimeonpause;
    114115
    115116    // Encoding info
    116     int width, height;
     117    uint width, height;
    117118    int bitrate, maxbitrate, streamtype, aspectratio;
    118119    int audtype, audsamplerate, audbitratel1, audbitratel2, audbitratel3;
    119120    int audvolume;