Ticket #5866: hdpvr-fix-channel-changes.patch

libs/libmythtv/mpegrecorder.

@@ -86 +86 @@
 
     void ResetForNewFile(void);
 
+    bool WaitFor_HDPVR(void);
     void HandleResolutionChanges(void);
 
     inline bool CheckCC(uint pid, uint cc);
 
     bool deviceIsMpegFile;
     int bufferSize;
-    useconds_t ioctl_recovery;
 
     // Driver info
     QString  card;

libs/libmythtv/mpegrecorder.

@@ -19 +19 @@
 #include <sys/stat.h>
 #include <sys/ioctl.h>
 #include <sys/time.h>
+#include <sys/poll.h>
 
 // avlib headers
 extern "C" {
@@ -389 +390 @@
             has_buggy_vbi = true;
             requires_special_pause =
                 (version >= IVTV_KERNEL_VERSION(0, 10, 0));
-            ioctl_recovery = 0;
         }
         else if (driver == "pvrusb2")
         {
@@ -398 +398 @@
             has_v4l2_vbi  = true;
             has_buggy_vbi = true;
             requires_special_pause = true;
-            ioctl_recovery = 0;
         }
         else if (driver == "hdpvr")
         {
@@ -409 +408 @@
             bzero(_stream_id,  sizeof(_stream_id));
             bzero(_pid_status, sizeof(_pid_status));
             memset(_continuity_counter, 0xff, sizeof(_continuity_counter));
-            ioctl_recovery = 1000;
         }
         else
         {
@@ -417 +415 @@
             bufferSize    = 4096;
             usingv4l2     = has_v4l2_vbi = true;
             has_buggy_vbi = requires_special_pause = false;
-            ioctl_recovery = 0;
         }
     }
 
@@ -491 +488 @@
 
 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;
     }
-    usleep(ioctl_recovery);
 
     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;
     }
-    usleep(ioctl_recovery);
 
     return true;
 }
@@ -519 +529 @@
 /// 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;
     }
-    usleep(ioctl_recovery);
 
     switch (language)
     {
@@ -556 +574 @@
         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;
     }
-    usleep(ioctl_recovery);
 
     return success;
 }
@@ -569 +593 @@
 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 +
@@ -579 +612 @@
         qctrl.maximum = 65535;
         qctrl.minimum = 0;
     }
-    usleep(ioctl_recovery);
 
     // calculate volume in card units.
     int range = qctrl.maximum - qctrl.minimum;
@@ -591 +623 @@
     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.");
         return false;
     }
-    usleep(ioctl_recovery);
 
     return true;
 }
@@ -746 +784 @@
     ctrl_list.push_back(tmp_ctrl);
 }
 
-static void set_ctrls(int fd, vector<struct v4l2_ext_control> &ext_ctrls,
-                      useconds_t ioctl_recovery)
+static void set_ctrls(int fd, vector<struct v4l2_ext_control> &ext_ctrls)
 {
     static QMutex control_description_lock;
     static QMap<uint32_t,QString> control_description;
@@ -776 +813 @@
 
     for (uint i = 0; i < ext_ctrls.size(); i++)
     {
+        uint   idx;
         struct v4l2_ext_controls ctrls;
         bzero(&ctrls, sizeof(struct v4l2_ext_controls));
 
@@ -785 +823 @@
         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(): ") +
@@ -793 +838 @@
                     .arg(control_description[ext_ctrls[i].id]).arg(value) +
                     ENO);
         }
-        usleep(ioctl_recovery);
     }
 }
 
@@ -828 +872 @@
         bitrate    = high_mpeg4avgbitrate;
 
         // query supported audio codecs and prefer AC3
+        uint   idx;
         struct v4l2_queryctrl qctrl;
         qctrl.id = V4L2_CID_MPEG_AUDIO_ENCODING;
-        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 supported audio codecs." + ENO);
         }
         else
         {
-            usleep(ioctl_recovery);
             if (qctrl.minimum != qctrl.maximum)
                 add_ext_ctrl(ext_ctrls, V4L2_CID_MPEG_AUDIO_ENCODING,
                              qctrl.maximum);
@@ -859 +911 @@
     add_ext_ctrl(ext_ctrls, V4L2_CID_MPEG_VIDEO_BITRATE_PEAK,
                  maxbitrate * 1000);
 
-    set_ctrls(chanfd, ext_ctrls, ioctl_recovery);
+    set_ctrls(chanfd, ext_ctrls);
 
     bool ok;
     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
         {
-            usleep(ioctl_recovery);
             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.");
             }
-            usleep(ioctl_recovery);
         }
     }
 
@@ -1415 +1482 @@
     if (!request_pause && paused)
     {
         VERBOSE(VB_RECORD, LOC + "PauseAndWait unpause");
+
+        if (driver == "hdpvr")
+        {
+            h264_parser.Reset();
+            _wait_for_keyframe_option = true;
+            _seen_sps = 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);
+        }
+
         // Some drivers require streaming to be disabled before
         // an input switch and other channel format setting.
         if (requires_special_pause)
@@ -1451 +1530 @@
         HandleSingleProgramPMT(_stream_data->PMTSingleProgram());
     }
     
-    _wait_for_keyframe_option = true;
     if (StartEncoding(readfd))
     {
         _device_read_buffer->Start();
@@ -1478 +1556 @@
 
     VERBOSE(VB_RECORD, LOC + "StartEncoding");
 
-    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")
+            {
+                h264_parser.Reset();
+                _wait_for_keyframe_option = true;
+                _seen_sps = false;
+            }
+
             VERBOSE(VB_RECORD, LOC + "Encoding started");
-            usleep(ioctl_recovery);
             return true;
         }
 
@@ -1493 +1577 @@
             return false;
         }
 
-        usleep(250 * 1000);
+        usleep(100 * 1000);
     }
 
     VERBOSE(VB_IMPORTANT, LOC_ERR + "StartEncoding - giving up" + ENO);
@@ -1510 +1594 @@
 
     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)
         {
-            usleep(ioctl_recovery);
             VERBOSE(VB_RECORD, LOC + "Encoding stopped");
             return true;
         }
@@ -1525 +1608 @@
             return false;
         }
 
-        usleep(250 * 1000);
+        usleep(100 * 1000);
     }
 
     VERBOSE(VB_IMPORTANT, LOC_ERR + "StopEncoding - giving up" + ENO);
@@ -1593 +1676 @@
 void MpegRecorder::HandleSingleProgramPMT(ProgramMapTable *pmt)
 {
     if (!pmt)
-{
+    {
         return;
     }
 
@@ -1613 +1696 @@
         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)
 {
     VERBOSE(VB_RECORD, LOC + "Checking Resolution");
@@ -1620 +1755 @@
     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;
+            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)
@@ -1687 +1836 @@
         add_ext_ctrl(ext_ctrls, V4L2_CID_MPEG_VIDEO_BITRATE_PEAK,
                      maxbitrate * 1000);
 
-        set_ctrls(readfd, ext_ctrls, ioctl_recovery);
+        set_ctrls(readfd, ext_ctrls);
+
     }
 }