Initial checkin for mythtv-trunk builds

5 files changed, 1207 insertions, 0 deletions

diff --git a/abs/core-testing/mythtv/trunk/mythtv-svn/patches/DeviceReadBuffer-polltimeout.2.patch b/abs/core-testing/mythtv/trunk/mythtv-svn/patches/DeviceReadBuffer-polltimeout.2.patch
new file mode 100644
index 0000000..5bb713f
--- /dev/null
+++ b/abs/core-testing/mythtv/trunk/mythtv-svn/patches/DeviceReadBuffer-polltimeout.2.patch
@@ -0,0 +1,219 @@
+Index: libs/libmythtv/DeviceReadBuffer.h
+===================================================================
+--- libs/libmythtv/DeviceReadBuffer.h	(revision 18515)
++++ libs/libmythtv/DeviceReadBuffer.h	(working copy)
+@@ -59,7 +59,7 @@
+     void IncrReadPointer(uint len);
+ 
+     bool HandlePausing(void);
+-    bool Poll(void) const;
++    bool Poll(void);
+     uint WaitForUnused(uint bytes_needed) const;
+     uint WaitForUsed  (uint bytes_needed) const;
+ 
+Index: libs/libmythtv/DeviceReadBuffer.cpp
+===================================================================
+--- libs/libmythtv/DeviceReadBuffer.cpp	(revision 18515)
++++ libs/libmythtv/DeviceReadBuffer.cpp	(working copy)
+@@ -90,9 +90,14 @@
+ 
+ void DeviceReadBuffer::Start(void)
+ {
+-    lock.lock();
+-    bool was_running = running;
+-    lock.unlock();
++    bool was_running;
++
++    {
++        QMutexLocker locker(&lock);
++        was_running = running;
++        error = false;
++    }
++
+     if (was_running)
+     {
+         VERBOSE(VB_IMPORTANT, LOC_ERR + "Start(): Already running.");
+@@ -104,6 +109,8 @@
+     {
+         VERBOSE(VB_IMPORTANT,
+                 LOC_ERR + QString("Start(): pthread_create failed.") + ENO);
++
++        QMutexLocker locker(&lock);
+         error = true;
+     }
+ }
+@@ -118,21 +125,25 @@
+     used          = 0;
+     readPtr       = buffer;
+     writePtr      = buffer;
++
++    error         = false;
+ }
+ 
+ void DeviceReadBuffer::Stop(void)
+ {
+     bool was_running = IsRunning();
+-    lock.lock();
+-    run = false;
+-    lock.unlock();
+ 
+     if (!was_running)
+     {
+-        VERBOSE(VB_IMPORTANT, LOC_ERR + "Stop(): Not running.");
++        VERBOSE(VB_IMPORTANT, LOC + "Stop(): Not running.");
+         return;
+     }
+ 
++    {
++        QMutexLocker locker(&lock);
++        run = false;
++    }
++
+     pthread_join(thread, NULL);
+ }
+ 
+@@ -229,10 +240,11 @@
+ {
+     uint      errcnt = 0;
+ 
+-    lock.lock();
+-    run     = true;
+-    running = true;
+-    lock.unlock();
++    {
++        QMutexLocker locker(&lock);
++        run     = true;
++        running = true;
++    }
+ 
+     while (run)
+     {
+@@ -248,6 +260,15 @@
+         if (using_poll && !Poll())
+             continue;
+ 
++        {
++            QMutexLocker locker(&lock);
++            if (error)
++            {
++                VERBOSE(VB_RECORD, LOC + "fill_ringbuffer: error state");
++                break;
++            }
++        }
++
+         // Limit read size for faster return from read
+         size_t read_size =
+             min(dev_read_size, (size_t) WaitForUnused(TSPacket::SIZE));
+@@ -268,9 +289,10 @@
+         }
+     }
+ 
+-    lock.lock();
+-    running = false;
+-    lock.unlock();
++    {
++        QMutexLocker locker(&lock);
++        running = false;
++    }
+ }
+ 
+ bool DeviceReadBuffer::HandlePausing(void)
+@@ -293,7 +315,7 @@
+     return true;
+ }
+ 
+-bool DeviceReadBuffer::Poll(void) const
++bool DeviceReadBuffer::Poll(void)
+ {
+ #ifdef USING_MINGW
+ #warning mingw DeviceReadBuffer::Poll
+@@ -302,31 +324,53 @@
+     return false;
+ #else
+     bool retval = true;
+-    while (true)
++    uint timeout_cnt = 0;
++
++    for (;;)
+     {
+         struct pollfd polls;
+         polls.fd      = _stream_fd;
+         polls.events  = POLLIN;
+         polls.revents = 0;
+ 
+-        int ret = poll(&polls, 1 /*number of polls*/, 10 /*msec*/);
+-        if (IsPauseRequested() || !IsOpen() || !run)
++        int ret = poll(&polls, 1 /*number of polls*/, 250 /*msec*/);
++
++        if (polls.revents & (POLLERR | POLLHUP | POLLNVAL))
+         {
++            VERBOSE(VB_IMPORTANT, LOC + "poll error");
++            error = true;
++            return true;
++        }
++
++        if (!run || !IsOpen() || IsPauseRequested())
++        {
+             retval = false;
+             break; // are we supposed to pause, stop, etc.
+         }
+ 
+         if (ret > 0)
+             break; // we have data to read :)
+-        if ((-1 == ret) && (EOVERFLOW == errno))
+-            break; // we have an error to handle
+-
+-        if ((-1 == ret) && ((EAGAIN == errno) || (EINTR  == errno)))
+-            continue; // errors that tell you to try again
+-        if (ret == 0)
+-            continue; // timed out, try again
+-
+-        usleep(2500);
++        if (ret < 0)
++        {
++            if ((EOVERFLOW == errno))
++                break; // we have an error to handle
++            if ((EAGAIN == errno) || (EINTR  == errno))
++                continue; // errors that tell you to try again
++            usleep(2500);
++        }
++        else //  ret == 0
++        {
++            if (++timeout_cnt > 9)
++            {
++                VERBOSE(VB_RECORD, LOC_ERR + "Poll giving up");
++                QMutexLocker locker(&lock);
++                error = true;
++                return true;
++            }
++            if (timeout_cnt % 2)
++                VERBOSE(VB_RECORD, LOC_ERR + QString("Poll timeout (%1)")
++                        .arg(timeout_cnt));
++        }
+     }
+     return retval;
+ #endif //!USING_MINGW
+@@ -360,9 +404,9 @@
+ 
+         if (++errcnt > 5)
+         {
+-            lock.lock();
++            QMutexLocker locker(&lock);
++            VERBOSE(VB_RECORD, LOC + "Too many errors.");
+             error = true;
+-            lock.unlock();
+             return false;
+         }
+ 
+@@ -376,10 +420,8 @@
+             VERBOSE(VB_IMPORTANT, LOC +
+                     QString("End-Of-File? fd(%1)").arg(_stream_fd));
+ 
+-            lock.lock();
++            QMutexLocker locker(&lock);
+             eof = true;
+-            lock.unlock();
+-
+             return false;
+         }
+         usleep(500);
diff --git a/abs/core-testing/mythtv/trunk/mythtv-svn/patches/aacdecoder.cpp.patch b/abs/core-testing/mythtv/trunk/mythtv-svn/patches/aacdecoder.cpp.patch
new file mode 100644
index 0000000..8796eb4
--- /dev/null
+++ b/abs/core-testing/mythtv/trunk/mythtv-svn/patches/aacdecoder.cpp.patch
@@ -0,0 +1,12 @@
+--- mythmusic/mythmusic/aacdecoder.cpp.orig	2008-11-19 12:51:48.000000000 -0500
++++ mythmusic/mythmusic/aacdecoder.cpp	2008-11-19 12:52:42.000000000 -0500
+@@ -17,6 +17,9 @@
+ #define FAAD_MODIFIED
+ #endif
+ 
++// LinHES need this undefined
++#undef FAAD_MODIFIED
++
+ // ANSI C headers
+ #include <cstdlib>
+ 
diff --git a/abs/core-testing/mythtv/trunk/mythtv-svn/patches/hdpvr-v4lchannel-tweak.patch b/abs/core-testing/mythtv/trunk/mythtv-svn/patches/hdpvr-v4lchannel-tweak.patch
new file mode 100644
index 0000000..3535310
--- /dev/null
+++ b/abs/core-testing/mythtv/trunk/mythtv-svn/patches/hdpvr-v4lchannel-tweak.patch
@@ -0,0 +1,139 @@
+Index: libs/libmythtv/v4lchannel.h
+===================================================================
+--- libs/libmythtv/v4lchannel.h	(revision 18874)
++++ libs/libmythtv/v4lchannel.h	(working copy)
+@@ -103,6 +103,8 @@
+     VidModV4L2  videomode_v4l2; ///< Current video mode if 'usingv4l2' is true
+ 
+     int         defaultFreqTable;
++    int         prev_inputNumV4L;
++    v4l2_std_id prev_vid_mode;
+ };
+ 
+ #endif
+Index: libs/libmythtv/v4lchannel.cpp
+===================================================================
+--- libs/libmythtv/v4lchannel.cpp	(revision 18874)
++++ libs/libmythtv/v4lchannel.cpp	(working copy)
+@@ -40,7 +40,8 @@
+       device_name(QString::null),   driver_name(QString::null),
+       curList(NULL),                totalChannels(0),
+       currentFormat(""),            is_dtv(false),
+-      usingv4l2(false),             defaultFreqTable(1)
++      usingv4l2(false),             defaultFreqTable(1),
++      prev_inputNumV4L(-1),         prev_vid_mode(-1)
+ {
+ }
+ 
+@@ -795,62 +796,75 @@
+     {
+         VERBOSE(VB_CHANNEL, LOC + msg + "(v4l v2)");
+ 
+-        int ioctlval = ioctl(videofd, VIDIOC_S_INPUT, &inputNumV4L);
++	int ioctlval;
++	bool streamingDisabled = false;
++	int  streamType = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+ 
+-        // ConvertX (wis-go7007) requires streaming to be disabled
+-        // before an input switch, do this if initial switch failed.
+-        bool streamingDisabled = false;
+-        int  streamType = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+-        if ((ioctlval < 0) && (errno == EBUSY))
++        if (prev_inputNumV4L != inputNumV4L)
+         {
+-            ioctlval = ioctl(videofd, VIDIOC_STREAMOFF, &streamType);
++            ioctlval = ioctl(videofd, VIDIOC_S_INPUT, &inputNumV4L);
++
++            // ConvertX (wis-go7007) requires streaming to be disabled
++            // before an input switch, do this if initial switch failed.
++            if ((ioctlval < 0) && (errno == EBUSY))
++            {
++                ioctlval = ioctl(videofd, VIDIOC_STREAMOFF, &streamType);
++                if (ioctlval < 0)
++                {
++                    VERBOSE(VB_IMPORTANT, LOC_ERR + msg +
++                            "\n\t\t\twhile disabling streaming (v4l v2)" + ENO);
++
++                    ok = false;
++                    ioctlval = 0;
++                }
++                else
++                {
++                    streamingDisabled = true;
++
++                    // Resend the input switch ioctl.
++                    ioctlval = ioctl(videofd, VIDIOC_S_INPUT, &inputNumV4L);
++                }
++            }
++
+             if (ioctlval < 0)
+             {
+                 VERBOSE(VB_IMPORTANT, LOC_ERR + msg +
+-                        "\n\t\t\twhile disabling streaming (v4l v2)" + ENO);
++                        "\n\t\t\twhile setting input (v4l v2)" + ENO);
+ 
+                 ok = false;
+-                ioctlval = 0;
+             }
+-            else
+-            {
+-                streamingDisabled = true;
+ 
+-                // Resend the input switch ioctl.
+-                ioctlval = ioctl(videofd, VIDIOC_S_INPUT, &inputNumV4L);
+-            }
++            prev_inputNumV4L = inputNumV4L;
+         }
+ 
+-        if (ioctlval < 0)
+-        {
+-            VERBOSE(VB_IMPORTANT, LOC_ERR + msg +
+-                    "\n\t\t\twhile setting input (v4l v2)" + ENO);
+-
+-            ok = false;
+-        }
+-
+         v4l2_std_id vid_mode = format_to_mode(newFmt, 2);
+-        ioctlval = ioctl(videofd, VIDIOC_S_STD, &vid_mode);
+-        if (ioctlval < 0)
+-        {
+-            VERBOSE(VB_IMPORTANT, LOC_ERR + msg +
+-                    "\n\t\t\twhile setting format (v4l v2)" + ENO);
+ 
+-            ok = false;
+-        }
+-
+-        // ConvertX (wis-go7007) requires streaming to be disabled
+-        // before an input switch, here we try to re-enable streaming.
+-        if (streamingDisabled)
++        if (prev_vid_mode != vid_mode)
+         {
+-            ioctlval = ioctl(videofd, VIDIOC_STREAMON, &streamType);
++            ioctlval = ioctl(videofd, VIDIOC_S_STD, &vid_mode);
+             if (ioctlval < 0)
+             {
+                 VERBOSE(VB_IMPORTANT, LOC_ERR + msg +
+-                        "\n\t\t\twhile reenabling streaming (v4l v2)" + ENO);
++                        "\n\t\t\twhile setting format (v4l v2)" + ENO);
+ 
+                 ok = false;
+             }
++
++            // ConvertX (wis-go7007) requires streaming to be disabled
++            // before an input switch, here we try to re-enable streaming.
++            if (streamingDisabled)
++            {
++                ioctlval = ioctl(videofd, VIDIOC_STREAMON, &streamType);
++                if (ioctlval < 0)
++                {
++                    VERBOSE(VB_IMPORTANT, LOC_ERR + msg +
++                            "\n\t\t\twhile reenabling streaming (v4l v2)" +
++                            ENO);
++
++                    ok = false;
++                }
++            }
++            prev_vid_mode = vid_mode;
+         }
+     }
+ 
diff --git a/abs/core-testing/mythtv/trunk/mythtv-svn/patches/mpegrecorder-hdpvr-v1.1.patch b/abs/core-testing/mythtv/trunk/mythtv-svn/patches/mpegrecorder-hdpvr-v1.1.patch
new file mode 100644
index 0000000..f292b7f
--- /dev/null
+++ b/abs/core-testing/mythtv/trunk/mythtv-svn/patches/mpegrecorder-hdpvr-v1.1.patch
@@ -0,0 +1,658 @@
+Index: libs/libmythtv/mpegrecorder.h
+===================================================================
+--- libs/libmythtv/mpegrecorder.h	(revision 19056)
++++ libs/libmythtv/mpegrecorder.h	(working copy)
+@@ -80,11 +80,13 @@
+     uint GetFilteredAudioLayer(void) const;
+     uint GetFilteredAudioBitRate(uint audio_layer) const;
+ 
++    void RestartEncoding(void);
+     bool StartEncoding(int fd);
+     bool StopEncoding(int fd);
+ 
+     void ResetForNewFile(void);
+ 
++    bool WaitFor_HDPVR(void);
+     void HandleResolutionChanges(void);
+ 
+     inline bool CheckCC(uint pid, uint cc);
+@@ -104,7 +106,6 @@
+     // State
+     bool recording;
+     bool encoding;
+-    bool needs_resolution;
+     mutable QMutex start_stop_encoding_lock;
+     QMutex recording_wait_lock;
+     QWaitCondition recording_wait;
+@@ -113,7 +114,7 @@
+     bool cleartimeonpause;
+ 
+     // Encoding info
+-    int width, height;
++    uint width, height;
+     int bitrate, maxbitrate, streamtype, aspectratio;
+     int audtype, audsamplerate, audbitratel1, audbitratel2, audbitratel3;
+     int audvolume;
+Index: libs/libmythtv/mpegrecorder.cpp
+===================================================================
+--- libs/libmythtv/mpegrecorder.cpp	(revision 19056)
++++ libs/libmythtv/mpegrecorder.cpp	(working copy)
+@@ -19,6 +19,7 @@
+ #include <sys/stat.h>
+ #include <sys/ioctl.h>
+ #include <sys/time.h>
++#include <sys/poll.h>
+ 
+ // avlib headers
+ extern "C" {
+@@ -86,7 +87,7 @@
+     requires_special_pause(false),
+     // State
+     recording(false),         encoding(false),
+-    needs_resolution(false),  start_stop_encoding_lock(QMutex::Recursive),
++    start_stop_encoding_lock(QMutex::Recursive),
+     recording_wait_lock(),    recording_wait(),
+     // Pausing state
+     cleartimeonpause(false),
+@@ -487,13 +488,21 @@
+ 
+ bool MpegRecorder::SetFormat(int chanfd)
+ {
++    uint   idx;
+     struct v4l2_format vfmt;
+     bzero(&vfmt, sizeof(vfmt));
+ 
+     vfmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+ 
+-    if (ioctl(chanfd, VIDIOC_G_FMT, &vfmt) < 0)
++    for (idx = 0; idx < 20; ++idx)
+     {
++        if (ioctl(chanfd, VIDIOC_G_FMT, &vfmt) == 0)
++            break;
++        usleep(100 * 1000);
++    }
++
++    if (idx == 10)
++    {
+         VERBOSE(VB_IMPORTANT, LOC_ERR + "Error getting format" + ENO);
+         return false;
+     }
+@@ -501,8 +510,15 @@
+     vfmt.fmt.pix.width = width;
+     vfmt.fmt.pix.height = height;
+ 
+-    if (ioctl(chanfd, VIDIOC_S_FMT, &vfmt) < 0)
++    for (idx = 0; idx < 20; ++idx)
+     {
++        if (ioctl(chanfd, VIDIOC_S_FMT, &vfmt) == 0)
++            break;
++        usleep(100 * 1000);
++    }
++
++    if (idx == 20)
++    {
+         VERBOSE(VB_IMPORTANT, LOC_ERR + "Error setting format" + ENO);
+         return false;
+     }
+@@ -513,10 +529,19 @@
+ /// Set audio language mode
+ bool MpegRecorder::SetLanguageMode(int chanfd)
+ {
++    uint   idx;
+     struct v4l2_tuner vt;
+     bzero(&vt, sizeof(struct v4l2_tuner));
+-    if (ioctl(chanfd, VIDIOC_G_TUNER, &vt) < 0)
++
++    for (idx = 0; idx < 20; ++idx)
+     {
++        if (ioctl(chanfd, VIDIOC_G_TUNER, &vt) == 0)
++            break;
++        usleep(100 * 1000);
++    }
++
++    if (idx == 20)
++    {
+         VERBOSE(VB_IMPORTANT, LOC_WARN + "Unable to get audio mode" + ENO);
+         return false;
+     }
+@@ -549,8 +574,15 @@
+         success = false;
+     }
+ 
+-    if (ioctl(chanfd, VIDIOC_S_TUNER, &vt) < 0)
++    for (idx = 0; idx < 20; ++idx)
+     {
++        if (ioctl(chanfd, VIDIOC_S_TUNER, &vt) == 0)
++            break;
++        usleep(100 * 1000);
++    }
++
++    if (idx == 20)
++    {
+         VERBOSE(VB_IMPORTANT, LOC_WARN + "Unable to set audio mode" + ENO);
+         success = false;
+     }
+@@ -561,10 +593,19 @@
+ bool MpegRecorder::SetRecordingVolume(int chanfd)
+ {
+     // Get volume min/max values
++    uint   idx;
+     struct v4l2_queryctrl qctrl;
+     qctrl.id = V4L2_CID_AUDIO_VOLUME;
+-    if (ioctl(chanfd, VIDIOC_QUERYCTRL, &qctrl) < 0)
++
++    for (idx = 0; idx < 20; ++idx)
+     {
++        if (ioctl(chanfd, VIDIOC_QUERYCTRL, &qctrl) == 0)
++            break;
++        usleep(100 * 1000);
++    }
++
++    if (idx == 20)
++    {
+         VERBOSE(VB_IMPORTANT, LOC_WARN +
+                 "Unable to get recording volume parameters(max/min)" + ENO +
+                 "\n\t\t\tusing default range [0,65535].");
+@@ -582,8 +623,15 @@
+     ctrl.id = V4L2_CID_AUDIO_VOLUME;
+     ctrl.value = ctrl_volume;
+ 
+-    if (ioctl(chanfd, VIDIOC_S_CTRL, &ctrl) < 0)
++    for (idx = 0; idx < 20; ++idx)
+     {
++        if (ioctl(chanfd, VIDIOC_S_CTRL, &ctrl) == 0)
++            break;
++        usleep(100 * 1000);
++    }
++
++    if (idx == 20)
++    {
+         VERBOSE(VB_IMPORTANT, LOC_WARN +
+                 "Unable to set recording volume" + ENO + "\n\t\t\t" +
+                 "If you are using an AverMedia M179 card this is normal.");
+@@ -765,6 +813,7 @@
+ 
+     for (uint i = 0; i < ext_ctrls.size(); i++)
+     {
++        uint   idx;
+         struct v4l2_ext_controls ctrls;
+         bzero(&ctrls, sizeof(struct v4l2_ext_controls));
+ 
+@@ -774,8 +823,15 @@
+         ctrls.count       = 1;
+         ctrls.controls    = &ext_ctrls[i];
+             
+-        if (ioctl(fd, VIDIOC_S_EXT_CTRLS, &ctrls) < 0)
++        for (idx = 0; idx < 20; ++idx)
+         {
++            if (ioctl(fd, VIDIOC_S_EXT_CTRLS, &ctrls) == 0)
++                break;
++            usleep(100 * 1000);
++        }
++
++        if (idx == 20)
++        {
+             QMutexLocker locker(&control_description_lock);
+             VERBOSE(VB_IMPORTANT, QString("mpegrecorder.cpp:set_ctrls(): ") +
+                     QString("Could not set %1 to %2")
+@@ -814,6 +870,30 @@
+     {
+         maxbitrate = high_mpeg4peakbitrate;
+         bitrate    = high_mpeg4avgbitrate;
++
++        // query supported audio codecs and prefer AC3
++        uint   idx;
++        struct v4l2_queryctrl qctrl;
++        qctrl.id = V4L2_CID_MPEG_AUDIO_ENCODING;
++
++        for (idx = 0; idx < 20; ++idx)
++        {
++            if (ioctl(chanfd, VIDIOC_QUERYCTRL, &qctrl) == 0)
++                break;
++            usleep(100 * 1000);
++        }
++
++        if (idx == 20)
++        {
++            VERBOSE(VB_IMPORTANT, LOC_WARN +
++                    "Unable to get supported audio codecs." + ENO);
++        }
++        else
++        {
++            if (qctrl.minimum != qctrl.maximum)
++                add_ext_ctrl(ext_ctrls, V4L2_CID_MPEG_AUDIO_ENCODING,
++                             qctrl.maximum);
++        }
+     }
+     maxbitrate = std::max(maxbitrate, bitrate);
+ 
+@@ -837,19 +917,36 @@
+     int audioinput = audiodevice.toUInt(&ok);
+     if (ok)
+     {
++        uint   idx;
+         struct v4l2_audio ain;
+         bzero(&ain, sizeof(ain));
+         ain.index = audioinput;
+-        if (ioctl(chanfd, VIDIOC_ENUMAUDIO, &ain) < 0)
++
++        for (idx = 0; idx < 20; ++idx)
+         {
++            if (ioctl(chanfd, VIDIOC_ENUMAUDIO, &ain) == 0)
++                break;
++            usleep(100 * 1000);
++        }
++
++        if (idx == 20)
++        {
+             VERBOSE(VB_IMPORTANT, LOC_WARN +
+                     "Unable to get audio input.");
+         }
+         else
+         {
+             ain.index = audioinput;
+-            if (ioctl(chanfd, VIDIOC_S_AUDIO, &ain) < 0)
++
++            for (idx = 0; idx < 20; ++idx)
+             {
++                if (ioctl(chanfd, VIDIOC_S_AUDIO, &ain) == 0)
++                    break;
++                usleep(100 * 1000);
++            }
++
++            if (idx == 20)
++            {
+                 VERBOSE(VB_IMPORTANT, LOC_WARN +
+                         "Unable to set audio input.");
+             }
+@@ -1036,17 +1133,26 @@
+     if (deviceIsMpegFile)
+         elapsedTimer.start();
+     else if (_device_read_buffer)
+-        _device_read_buffer->Start();
++    {
++        VERBOSE(VB_RECORD, LOC + "Initial startup of recorder");
+ 
+-    needs_resolution = (driver == "hdpvr");
++        if (StartEncoding(readfd))
++            _device_read_buffer->Start();
++        else
++        {
++            VERBOSE(VB_IMPORTANT, LOC_ERR + "Failed to start recording");
++            recording = false;
++            QMutexLocker locker(&recording_wait_lock);
++            recording_wait.wakeAll();
++            _error = true;
++        }
++    }
+ 
+     QByteArray vdevice = videodevice.toAscii();
+     while (encoding && !_error)
+     {
+         if (PauseAndWait(100))
+             continue;
+-
+-        HandleResolutionChanges();
+         
+         if (deviceIsMpegFile)
+         {
+@@ -1090,35 +1196,7 @@
+             {
+                 VERBOSE(VB_IMPORTANT, LOC_ERR + "Device error detected");
+ 
+-                _device_read_buffer->Stop();
+-
+-                QMutexLocker locker(&start_stop_encoding_lock);
+-
+-                StopEncoding(readfd);
+-
+-                // Make sure the next things in the file are a PAT & PMT
+-                if (_stream_data->PATSingleProgram() &&
+-                    _stream_data->PMTSingleProgram())
+-                {
+-                    bool tmp = _wait_for_keyframe_option;
+-                    _wait_for_keyframe_option = false;
+-                    HandleSingleProgramPAT(_stream_data->PATSingleProgram());
+-                    HandleSingleProgramPMT(_stream_data->PMTSingleProgram());
+-                    _wait_for_keyframe_option = tmp;
+-                }
+-
+-                if (StartEncoding(readfd))
+-                {
+-                    _device_read_buffer->Start();
+-                }
+-                else
+-                {
+-                    if (0 != close(readfd))
+-                        VERBOSE(VB_IMPORTANT, LOC_ERR + "Close error" + ENO);
+-                    
+-                    // Force card to be reopened on next iteration..
+-                    readfd = -1;
+-                }
++                RestartEncoding();
+             }
+             else if (_device_read_buffer->IsEOF())
+             {
+@@ -1216,6 +1294,8 @@
+         }
+     }
+ 
++    VERBOSE(VB_RECORD, LOC + "StartRecording finishing up");
++
+     if (_device_read_buffer)
+     {
+         if (_device_read_buffer->IsRunning())
+@@ -1224,6 +1304,7 @@
+         delete _device_read_buffer;
+         _device_read_buffer = NULL;
+     }
++
+     StopEncoding(readfd);
+ 
+     FinishRecording();
+@@ -1373,52 +1454,95 @@
+ 
+         if (!paused)
+         {
++            VERBOSE(VB_RECORD, LOC + "PauseAndWait pause");
++
++            // Some drivers require streaming to be disabled before
++            // an input switch and other channel format setting.
++            if (requires_special_pause)
++                StopEncoding(readfd);
++
+             if (_device_read_buffer)
+             {
+                 QMutex drb_lock;
+                 drb_lock.lock();
+-
+                 _device_read_buffer->SetRequestPause(true);
+-
+                 pauseWait.wait(&drb_lock, timeout);
+             }
+             else
+-            {
+-                paused = true;
+                 pauseWait.wakeAll();
+-            }
+ 
+-            // Some drivers require streaming to be disabled before
+-            // an input switch and other channel format setting.
+-            if (requires_special_pause)
+-                StopEncoding(readfd);
+-
++            paused = true;
+             if (tvrec)
+                 tvrec->RecorderPaused();
+         }
+ 
+         unpauseWait.wait(&waitlock, timeout);
+     }
+-    if (!request_pause)
++
++    if (!request_pause && paused)
+     {
+-        if (paused)
++        VERBOSE(VB_RECORD, LOC + "PauseAndWait unpause");
++
++        if (driver == "hdpvr")
+         {
+-            // Some drivers require streaming to be disabled before
+-            // an input switch and other channel format setting.
+-            if (requires_special_pause)
+-                StartEncoding(readfd);
++            m_h264_parser.Reset();
++            _wait_for_keyframe_option = true;
++            _seen_sps = false;
+ 
+-            if (_device_read_buffer)
+-                _device_read_buffer->SetRequestPause(false);
++            // Sleep any less than 1.5 seconds, and the HD-PVR will
++            // return the old resolution, when the resolution is changing.
++            usleep(1500 * 1000);
++        }
+ 
+-            if (_stream_data)
+-                _stream_data->Reset(_stream_data->DesiredProgram());
+-        }
++        // Some drivers require streaming to be disabled before
++        // an input switch and other channel format setting.
++        if (requires_special_pause)
++            StartEncoding(readfd);
++        
++        if (_device_read_buffer)
++            _device_read_buffer->SetRequestPause(false);
++        
++        if (_stream_data)
++            _stream_data->Reset(_stream_data->DesiredProgram());
++
+         paused = false;
+     }
++
+     return paused;
+ }
+ 
++void MpegRecorder::RestartEncoding(void)
++{
++    VERBOSE(VB_RECORD, LOC + "RestartEncoding");
++
++    _device_read_buffer->Stop();
++    
++    QMutexLocker locker(&start_stop_encoding_lock);
++    
++    StopEncoding(readfd);
++    
++    // Make sure the next things in the file are a PAT & PMT
++    if (_stream_data->PATSingleProgram() &&
++        _stream_data->PMTSingleProgram())
++    {
++        _wait_for_keyframe_option = false;
++        HandleSingleProgramPAT(_stream_data->PATSingleProgram());
++        HandleSingleProgramPMT(_stream_data->PMTSingleProgram());
++    }
++    
++    if (StartEncoding(readfd))
++    {
++        _device_read_buffer->Start();
++    }
++    else
++    {
++        if (0 != close(readfd))
++            VERBOSE(VB_IMPORTANT, LOC_ERR + "Close error" + ENO);
++        
++        readfd = -1;
++    }
++}
++
+ bool MpegRecorder::StartEncoding(int fd)
+ {
+     QMutexLocker locker(&start_stop_encoding_lock);
+@@ -1427,13 +1551,22 @@
+     memset(&command, 0, sizeof(struct v4l2_encoder_cmd));
+     command.cmd = V4L2_ENC_CMD_START;
+ 
++    if (driver == "hdpvr")
++        HandleResolutionChanges();
++
+     VERBOSE(VB_RECORD, LOC + "StartEncoding");
+-    needs_resolution = (driver == "hdpvr");
+ 
+-    for (int idx = 0; idx < 10; ++idx)
++    for (int idx = 0; idx < 20; ++idx)
+     {
+         if (ioctl(fd, VIDIOC_ENCODER_CMD, &command) == 0)
+         {
++            if (driver == "hdpvr")
++            {
++                m_h264_parser.Reset();
++                _wait_for_keyframe_option = true;
++                _seen_sps = false;
++            }
++
+             VERBOSE(VB_RECORD, LOC + "Encoding started");
+             return true;
+         }
+@@ -1444,7 +1577,7 @@
+             return false;
+         }
+ 
+-        usleep(250 * 1000);
++        usleep(100 * 1000);
+     }
+ 
+     VERBOSE(VB_IMPORTANT, LOC_ERR + "StartEncoding - giving up" + ENO);
+@@ -1461,9 +1594,8 @@
+ 
+     VERBOSE(VB_RECORD, LOC + "StopEncoding");
+ 
+-    for (int idx = 0; idx < 10; ++idx)
++    for (int idx = 0; idx < 20; ++idx)
+     {
+-
+         if (ioctl(fd, VIDIOC_ENCODER_CMD, &command) == 0)
+         {
+             VERBOSE(VB_RECORD, LOC + "Encoding stopped");
+@@ -1476,7 +1608,7 @@
+             return false;
+         }
+ 
+-        usleep(250 * 1000);
++        usleep(100 * 1000);
+     }
+ 
+     VERBOSE(VB_IMPORTANT, LOC_ERR + "StopEncoding - giving up" + ENO);
+@@ -1544,7 +1676,7 @@
+ void MpegRecorder::HandleSingleProgramPMT(ProgramMapTable *pmt)
+ {
+     if (!pmt)
+-{
++    {
+         return;
+     }
+ 
+@@ -1564,27 +1696,89 @@
+         DTVRecorder::BufferedWrite(*(reinterpret_cast<TSPacket*>(&buf[i])));
+ }
+ 
++bool MpegRecorder::WaitFor_HDPVR(void)
++{
++    // After a resolution change, it can take the HD-PVR a few
++    // seconds before it is usable again.
++
++    // Tell it to start encoding, then wait for it to actually feed us
++    // some data.
++    QMutexLocker locker(&start_stop_encoding_lock);
++
++    struct v4l2_encoder_cmd command;
++    struct pollfd polls;
++    int    idx;
++
++    memset(&command, 0, sizeof(struct v4l2_encoder_cmd));
++    command.cmd = V4L2_ENC_CMD_START;
++
++    for (idx = 0; idx < 20; ++idx)
++    {
++        if (ioctl(readfd, VIDIOC_ENCODER_CMD, &command) == 0)
++            break;
++        usleep(100 * 1000);
++    }
++
++    if (idx == 20)
++        return false;
++
++    polls.fd      = readfd;
++    polls.events  = POLLIN;
++    polls.revents = 0;
++
++    for (idx = 0; idx < 10; ++idx)
++    {
++        if (poll(&polls, 1, 250) > 0)
++            break;
++    }
++
++    if (idx == 10)
++        return false;
++
++    // HD-PVR should now be "ready"
++    command.cmd = V4L2_ENC_CMD_STOP;
++
++    for (idx = 0; idx < 20; ++idx)
++    {
++        if (ioctl(readfd, VIDIOC_ENCODER_CMD, &command) == 0)
++            return true;
++        usleep(100 * 1000);
++    }
++
++    return false;
++}
++
+ void MpegRecorder::HandleResolutionChanges(void)
+ {
+-    if (!needs_resolution)
+-        return;
+-
+     VERBOSE(VB_RECORD, LOC + "Checking Resolution");
+     struct v4l2_format vfmt;
+     memset(&vfmt, 0, sizeof(vfmt));
+     vfmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+             
++    if (driver == "hdpvr")
++        WaitFor_HDPVR();
++
++    uint idx;
+     uint pix = 0;
++
++    for (idx = 0; idx < 20; ++idx)
++    {
+     if (0 == ioctl(chanfd, VIDIOC_G_FMT, &vfmt))
+     {
+         VERBOSE(VB_RECORD, LOC + QString("Got Resolution %1x%2")
+                 .arg(vfmt.fmt.pix.width).arg(vfmt.fmt.pix.height));
+         pix = vfmt.fmt.pix.width * vfmt.fmt.pix.height;
+-        needs_resolution = false;
++            break;
++        }
++        // Typically takes 0.9 seconds after a resolution change
++        usleep(100 * 1000);
+     }
+ 
+     if (!pix)
++    {
++        VERBOSE(VB_RECORD, LOC + "Giving up detecting resolution");
+         return; // nothing to do, we don't have a resolution yet
++    }
+ 
+     int old_max = maxbitrate, old_avg = bitrate;
+     if (pix <= 768*568)
+@@ -1609,13 +1803,14 @@
+         if (old_max == old_avg)
+         {
+             VERBOSE(VB_RECORD, LOC +
+-                    QString("Old bitrate %1 CBR").arg(old_avg));
++                    QString("Old bitrate %1 CBR for %2x%3")
++                    .arg(old_avg).arg(width).arg(height));
+         }
+         else
+         {
+             VERBOSE(VB_RECORD, LOC +
+-                    QString("Old bitrate %1/%2 VBR")
+-                    .arg(old_avg).arg(old_max));
++                    QString("Old bitrate %1/%2 VBR for %3x%4")
++                    .arg(old_avg).arg(old_max).arg(width).arg(height));
+         }
+ 
+         if (maxbitrate == bitrate)
+@@ -1642,12 +1837,6 @@
+                      maxbitrate * 1000);
+ 
+         set_ctrls(readfd, ext_ctrls);
++
+     }
+-
+-    // Restart streaming. Shouldn't be needed? seems to be with current driver.
+-    QMutexLocker locker(&start_stop_encoding_lock);
+-    StopEncoding(readfd);
+-    StartEncoding(readfd);
+-
+-    needs_resolution = false;
+ }
diff --git a/abs/core-testing/mythtv/trunk/mythtv-svn/patches/mythcommflag-avidemux.2.patch b/abs/core-testing/mythtv/trunk/mythtv-svn/patches/mythcommflag-avidemux.2.patch
new file mode 100644
index 0000000..d26645f
--- /dev/null
+++ b/abs/core-testing/mythtv/trunk/mythtv-svn/patches/mythcommflag-avidemux.2.patch
@@ -0,0 +1,179 @@
+Index: programs/mythcommflag/main.cpp
+===================================================================
+--- programs/mythcommflag/main.cpp	(revision 18596)
++++ programs/mythcommflag/main.cpp	(working copy)
+@@ -300,6 +300,132 @@
+     return COMMFLAG_EXIT_NO_ERROR_WITH_NO_BREAKS;
+ }
+ 
++int GetAviDemux(QString list, QString chanid, QString starttime, const QString &outputfilename)
++{
++    QMap<long long, int> cutlist;
++    QMap<long long, int>::Iterator it;
++    QString result;
++    int startValue = 0;
++    long long myTotalFrames;
++    long long myFrameRate;
++
++    ProgramInfo *pginfo =
++        ProgramInfo::GetProgramFromRecorded(chanid, starttime);
++
++    NuppelVideoPlayer* nvp = new NuppelVideoPlayer("avidemux_export", pginfo);
++
++    myFrameRate = (long long)(nvp->GetFrameRate() * 1000);
++    myTotalFrames = 1000000; //nvp->GetTotalFrameCount();
++
++    if (!pginfo)
++    {
++        VERBOSE(VB_IMPORTANT,
++                QString("No program data exists for channel %1 at %2")
++                .arg(chanid).arg(starttime));
++        return COMMFLAG_BUGGY_EXIT_NO_CHAN_DATA;
++    }
++
++    QString filename = pginfo->GetPlaybackURL(TRUE);
++
++    if (list == "cutlist")
++        pginfo->GetCutList(cutlist);
++    else
++        pginfo->GetCommBreakList(cutlist);
++
++// Formatting of output data
++
++    for (it = cutlist.begin(); it != cutlist.end(); ++it)
++    {
++        if ((it.key() == 0) && (startValue == 0)) // Cutlist starts on first frame,
++            {
++            ++it;
++            startValue = it.key();
++            }
++
++        if ((it.key() != 0) && (startValue == 0)) // Cutlist starts on non-first frame
++            {
++            result += QString("app.addSegment(0,0,%1);").arg(it.key());  
++            startValue = it.key();
++            }
++        else
++           {
++            if  ((*it == MARK_COMM_END) && (startValue != 0) ||
++                (*it == MARK_CUT_END) && (startValue != 0))
++                {
++                 if (result != "")
++                       result += "\n";
++                       startValue = it.key();
++                       result += QString("app.addSegment(0,%1,").arg(it.key()); // Value is a start value
++                }
++            else  
++                {
++                    result += QString("%1);").arg(it.key() - startValue); // Value is an end value
++                }
++           }
++   }
++
++if (it.key() != myTotalFrames)
++    {
++        result += QString("%1);").arg(myTotalFrames);
++    }
++
++// Governs the file output:
++
++    QString tmp = "";
++    ostream *out = &cout;
++
++    if (outputfilename != "-"){
++        QByteArray tmp = outputfilename.toLocal8Bit();
++        out = new fstream(tmp.constData(), ios::app | ios::out );
++        }
++
++    if (outputfilename == ""){
++        VERBOSE(VB_IMPORTANT,
++           QString("Error: AVIDemux output requires the use of the --outputfile option."));
++           return COMMFLAG_EXIT_INVALID_CMDLINE;
++        }
++
++        tmp = QString("//AD  <- Needed to identify//\n"
++                        "//--automatically built--\n"
++                        "//--Project:\n\n"
++                        "var app = new Avidemux();\n\n"
++                        "//** Video **\n"
++                        "// 01 videos source\n" 
++                        "app.load(\"%1\");\n\n"
++                        "app.clearSegments();\n\n"
++                        "%2\n"
++                        "app.markerA=0;\n"
++                        "app.markerB=%3;\n"
++                        "app.rebuildIndex();\n\n"
++                        "//** Postproc **\n"
++                        "app.video.setPostProc(3,3,0);\n\n"
++                        "app.video.setFps1000(%4);\n\n"
++                        "//** Filters **\n\n"
++                        "//** Video Codec conf **\n"
++                        "app.video.codec(\"Copy\",\"CQ=4\",\"0 \");\n\n"
++                        "//** Audio **\n"
++                        "app.audio.reset();\n"
++                        "app.audio.codec(\"copy\",128,0,\"\");\n"
++                        "app.audio.normalizeMode=0;\n"
++                        "app.audio.normalizeValue=0;\n"
++                        "app.audio.delay=0;\n"
++                        "app.audio.mixer(\"NONE\");\n"
++                        "app.setContainer(\"AVI\");\n"
++                        "setSuccess(1);\n"
++                        "//app.Exit();\n\n"
++                        "//End of script\n").arg(filename).arg(result).arg(myTotalFrames).arg(myFrameRate).toLocal8Bit().constData();
++
++        const QByteArray tmp2 = tmp.toLocal8Bit();
++        *out << tmp2.constData() << endl;
++
++        VERBOSE(VB_IMPORTANT,
++                QString("AVIDemux Project generated for %1 at %2 with filename %3.")
++                .arg(chanid).arg(starttime).arg(outputfilename));
++
++    return COMMFLAG_EXIT_NO_ERROR_WITH_NO_BREAKS;
++}
++
++
+ void streamOutCommercialBreakList(
+     ostream &output, const QMap<long long, int> &commercialBreakList)
+ {
+@@ -811,6 +937,8 @@
+     bool clearCutlist = false;
+     bool getCutlist = false;
+     bool getSkipList = false;
++    bool getAviDemuxCutlist = false;
++    bool getAviDemuxSkiplist = false;
+     QString newCutList = QString::null;
+     QMap<QString, QString> settingsOverride;
+ 
+@@ -960,6 +1088,10 @@
+             getCutlist = true;
+         else if (!strcmp(a.argv()[argpos], "--getskiplist"))
+             getSkipList = true;
++        else if (!strcmp(a.argv()[argpos], "--getcutlist-avidemux"))
++            getAviDemuxCutlist = true;
++        else if (!strcmp(a.argv()[argpos], "--getskiplist-avidemux"))
++            getAviDemuxSkiplist = true;
+         else if (!strcmp(a.argv()[argpos], "--setcutlist"))
+             newCutList = (a.argv()[++argpos]);
+         else if (!strcmp(a.argv()[argpos], "-j"))
+@@ -1111,6 +1243,8 @@
+                     "                             #-#[,#-#]...  (ie, 1-100,1520-3012,4091-5094\n"
+                     "--getcutlist                 Display the current cutlist\n"
+                     "--getskiplist                Display the current Commercial Skip list\n"
++                    "--getcutlist-avidemux        Export cutlist as AVIDemux Project File\n"
++                    "--getskiplist-avidemux       Export skiplist as AVIDemux Project File\n"
+                     "-v or --verbose debug-level  Use '-v help' for level info\n"
+                     "--queue                      Insert flagging job into the JobQueue rather than\n"
+                     "                             running flagging in the foreground\n"
+@@ -1223,6 +1357,12 @@
+     if (!newCutList.isNull())
+         return SetCutList(chanid, starttime, newCutList);
+ 
++    if (getAviDemuxCutlist)
++        return GetAviDemux("cutlist", chanid, starttime, outputfilename);
++
++    if (getAviDemuxSkiplist)
++        return GetAviDemux("commflag", chanid, starttime, outputfilename);
++
+     if (getCutlist)
+         return GetMarkupList("cutlist", chanid, starttime);
+