Ticket #3379: cd-speed-patch

Index: libmythtv/DVDRingBuffer.cpp
===================================================================
--- libmythtv/DVDRingBuffer.cpp (revision 13250)
+++ libmythtv/DVDRingBuffer.cpp (working copy)
@@ -1,17 +1,8 @@
 #include <unistd.h>
-#ifdef __linux__
-#include <linux/cdrom.h>
-#include <scsi/sg.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <sys/ioctl.h>
-#include <fcntl.h>
-#include <unistd.h>
-#endif
 
-
 #include "DVDRingBuffer.h"
 #include "mythcontext.h"
+#include "mythmediamonitor.h"
 #include "iso639.h"
 
 #include "NuppelVideoPlayer.h"
@@ -1150,109 +1141,22 @@
     Seek(cellStart);
 }
 
-/*
- * \brief obtained from the mplayer project
- */
 void DVDRingBufferPriv::SetDVDSpeed(const char *device, int speed)
 {
-#if defined(__linux__) && defined(SG_IO) && defined(GPCMD_SET_STREAMING)
-    int fd;
-    unsigned char buffer[28];
-    unsigned char cmd[16];
-    unsigned char sense[16];
-    struct sg_io_hdr sghdr;
-    struct stat st;
+    //
+    // If it is OK to determine and lock the MythMediaDevice in
+    // OpenFile() and unlock in CloseDVD(), this can be done
+    // more efficiently.
+    MediaMonitor *mon = MediaMonitor::GetMediaMonitor();
 
-    memset(&sghdr, 0, sizeof(sghdr));
-    memset(buffer, 0, sizeof(buffer));
-    memset(sense, 0, sizeof(sense));
-    memset(cmd, 0, sizeof(cmd));
-    memset(&st, 0, sizeof(st));
-
-    if (stat(device, &st) == -1 ) 
-    {
-        VERBOSE(VB_PLAYBACK, LOC_ERR +
-                QString("SetDVDSpeed() Failed. device %1 not found")
-                .arg(device));
-        return;
-    }
-
-    if (!S_ISBLK(st.st_mode)) 
-    {
-        VERBOSE(VB_PLAYBACK, LOC_ERR + 
-                "SetDVDSpeed() Failed. Not a block device");
-        return;
-    }
-
-    if ((fd = open(device, O_RDWR | O_NONBLOCK)) == -1)
-    {
-        VERBOSE(VB_PLAYBACK, LOC_ERR + 
-                "Changing DVD speed needs write access");
-        return;
-    }
-
-    if (speed > 0 && speed < 100)
-        speed *= 1350;
-
-    switch(speed)
-    {
-        case 0: // don't touch speed setting
-            return;
-        case -1: // restore default value
+    if (mon != NULL ) {
+        MythMediaDevice *pMedia = mon->GetMedia(device);
+        if (mon->ValidateAndLock(pMedia))
         {
-            speed = 0;
-            buffer[0] = 4;
-            VERBOSE(VB_PLAYBACK, LOC + "Restored DVD Speed");
-            break;
+            pMedia->setSpeed(speed);
+            mon->Unlock(pMedia);
         }
-        default:
-        {
-            QString msg;
-            if (speed < 0)
-                msg = "Normal";
-            else
-                msg = QString("%1Kb/s").arg(speed);
-            VERBOSE(VB_PLAYBACK, LOC + QString("Limit DVD Speed to %1")
-                    .arg(msg));
-            break;
-        }
     }
-
-    sghdr.interface_id = 'S';
-    sghdr.timeout = 5000;
-    sghdr.dxfer_direction = SG_DXFER_TO_DEV;
-    sghdr.mx_sb_len = sizeof(sense);
-    sghdr.dxfer_len = sizeof(buffer);
-    sghdr.cmd_len = sizeof(cmd);
-    sghdr.sbp = sense;
-    sghdr.dxferp = buffer;
-    sghdr.cmdp = cmd;
-
-    cmd[0] = GPCMD_SET_STREAMING;
-    cmd[10] = sizeof(buffer);
-
-    buffer[8]  = 0xff;
-    buffer[9]  = 0xff;
-    buffer[10] = 0xff;
-    buffer[11] = 0xff;
-
-    buffer[12] = buffer[20] = (speed >> 24) & 0xff;
-    buffer[13] = buffer[21] = (speed >> 16) & 0xff;
-    buffer[14] = buffer[22] = (speed >> 8)  & 0xff;
-    buffer[15] = buffer[23] = speed & 0xff;
-
-    buffer[18] = buffer[26] = 0x03;
-    buffer[19] = buffer[27] = 0xe8;
-
-    if (ioctl(fd, SG_IO, &sghdr) < 0)
-        VERBOSE(VB_PLAYBACK, LOC_ERR + "Limit DVD Speed Failed");
-   
-    close(fd);
-    VERBOSE(VB_PLAYBACK, LOC + "Limiting DVD Speed Successful");
-#else
-    (void)speed;
-    (void)device;
-#endif
 }
 
 /**
Index: libmyth/mythmediamonitor.h
===================================================================
--- libmyth/mythmediamonitor.h  (revision 13250)
+++ libmyth/mythmediamonitor.h  (working copy)
@@ -65,6 +65,7 @@
     // first validate the pointer with ValidateAndLock(), if true is returned
     // it is safe to dereference the pointer. When finished call Unlock()
     QValueList<MythMediaDevice*> GetMedias(MediaType mediatype);
+    MythMediaDevice* GetMedia(const QString &path);
 
     void MonitorRegisterExtensions(uint mediaType, const QString &extensions);
 
Index: libmyth/mythmedia.cpp
===================================================================
--- libmyth/mythmedia.cpp       (revision 13250)
+++ libmyth/mythmedia.cpp       (working copy)
@@ -273,6 +273,17 @@
     return MEDIAERR_UNSUPPORTED;
 }
 
+bool MythMediaDevice::isSameDevice(const QString &path)
+{
+    return (path == m_DevicePath);
+}
+
+void MythMediaDevice::setSpeed(int speed)
+{
+    (void)speed;
+    return;
+}
+
 MediaError MythMediaDevice::lock() 
 { 
     // We just open the device here, which may or may not do the trick,
Index: libmyth/mythmediamonitor.cpp
===================================================================
--- libmyth/mythmediamonitor.cpp        (revision 13250)
+++ libmyth/mythmediamonitor.cpp        (working copy)
@@ -379,6 +379,31 @@
     }
 }
 
+/**  \fn MediaMonitor::GetMedia(const QString& path)
+ * \brief Get media device by pathname. Must be locked with ValidateAndLock().
+ *
+ *  \sa ValidateAndLock(MythMediaDevice *pMedia)
+ *  \sa Unlock(MythMediaDevice *pMedia)
+ */
+MythMediaDevice* MediaMonitor::GetMedia(const QString& path)
+{
+    QMutexLocker locker(&m_DevicesLock);
+
+    QValueList<MythMediaDevice*>::iterator it = m_Devices.begin();
+    for (;it != m_Devices.end(); it++)
+    {
+        if ((*it)->isSameDevice(path) &&
+            (((*it)->getStatus() == MEDIASTAT_USEABLE) ||
+             ((*it)->getStatus() == MEDIASTAT_MOUNTED) ||
+             ((*it)->getStatus() == MEDIASTAT_NOTMOUNTED)))
+        {
+            return(*it);
+        }
+    }
+
+    return NULL;
+}
+
 /** \fn MediaMonitor::GetMedias(MediaType mediatype)
  *  \brief Ask for available media. Must be locked with ValidateAndLock().
  *
Index: libmyth/mythcdrom-linux.cpp
===================================================================
--- libmyth/mythcdrom-linux.cpp (revision 13250)
+++ libmyth/mythcdrom-linux.cpp (working copy)
@@ -2,11 +2,16 @@
 #include "mythcdrom-linux.h"
 #include <sys/ioctl.h>                // ioctls
 #include <linux/cdrom.h>        // old ioctls for cdrom
+#include <scsi/sg.h>
+#include <fcntl.h>
 #include <errno.h>
 #include "mythcontext.h"
 #include <linux/iso_fs.h>
 #include <unistd.h>
 
+#define LOC QString("mythcdrom-linux: ")
+#define LOC_ERR QString("mythcdrom-linux, Error: ")
+
 #define ASSUME_WANT_AUDIO 1
 
 class MythCDROMLinux: public MythCDROM
@@ -22,6 +27,8 @@
     virtual bool checkOK(void);
     virtual MediaStatus checkMedia(void);
     virtual MediaError eject(bool open_close = true);
+    virtual void setSpeed(int speed);
+    virtual bool isSameDevice(const QString &path);
     virtual MediaError lock(void);
     virtual MediaError unlock(void);
 };
@@ -309,3 +316,134 @@
 
     return MythMediaDevice::unlock();
 }
+
+bool MythCDROMLinux::isSameDevice(const QString &path)
+{
+    dev_t new_rdev;
+    struct stat sb;
+
+    if (stat(path, &sb) < 0)
+    {
+        VERBOSE(VB_IMPORTANT, "MythCDROMLinux::SameDevice() -- " +
+                QString("Failed to stat '%1'")
+                .arg(path) + ENO);
+        return false;
+    }
+    new_rdev = sb.st_rdev;
+
+    // Check against m_DevicePath...
+    if (stat(m_DevicePath, &sb) < 0)
+    {
+        VERBOSE(VB_IMPORTANT, "MythCDROMLinux::SameDevice() -- " +
+                QString("Failed to stat '%1'")
+                .arg(m_DevicePath) + ENO);
+        return false;
+    }
+    return (sb.st_rdev == new_rdev);
+}
+
+#if defined(SG_IO) && defined(GPCMD_SET_STREAMING)
+/*
+ * \brief obtained from the mplayer project
+ */
+void MythCDROMLinux::setSpeed(int speed)
+{
+    int fd;
+    unsigned char buffer[28];
+    unsigned char cmd[16];
+    unsigned char sense[16];
+    struct sg_io_hdr sghdr;
+    struct stat st;
+    int        rate = 0;
+
+    memset(&sghdr, 0, sizeof(sghdr));
+    memset(buffer, 0, sizeof(buffer));
+    memset(sense, 0, sizeof(sense));
+    memset(cmd, 0, sizeof(cmd));
+    memset(&st, 0, sizeof(st));
+
+    if (stat(m_DevicePath, &st) == -1 ) 
+    {
+        VERBOSE(VB_IMPORTANT, LOC_ERR +
+                QString("setSpeed() Failed. device %1 not found")
+                .arg(m_DevicePath));
+        return;
+    }
+
+    if (!S_ISBLK(st.st_mode)) 
+    {
+        VERBOSE(VB_IMPORTANT, LOC_ERR + 
+                "MythCDROMLinux::SetSpeed() Failed. Not a block device");
+        return;
+    }
+
+    if ((fd = open(m_DevicePath, O_RDWR | O_NONBLOCK)) == -1)
+    {
+        VERBOSE(VB_IMPORTANT, LOC_ERR + 
+                "Changing DVD speed needs write access");
+        return;
+    }
+
+    if (speed < 0)
+        speed = -1;
+
+    switch(speed)
+    {
+        case 0: // don't touch speed setting
+            return;
+        case -1: // restore default value
+        {
+            rate = 0;
+            buffer[0] = 4;
+            VERBOSE(VB_IMPORTANT, LOC + "Restored DVD Speed");
+            break;
+        }
+        default:
+        {
+            // Speed in Kilobyte/Second. 177KB/s is the maximum data rate
+            // for standard Audio CD's.
+
+            rate = (speed > 0 && speed < 100) ? speed * 177 : speed;
+
+            VERBOSE(VB_IMPORTANT, LOC + QString("Limit DVD Speed to %1KB/s")
+                    .arg(rate));
+            break;
+        }
+    }
+
+    sghdr.interface_id = 'S';
+    sghdr.timeout = 5000;
+    sghdr.dxfer_direction = SG_DXFER_TO_DEV;
+    sghdr.mx_sb_len = sizeof(sense);
+    sghdr.dxfer_len = sizeof(buffer);
+    sghdr.cmd_len = sizeof(cmd);
+    sghdr.sbp = sense;
+    sghdr.dxferp = buffer;
+    sghdr.cmdp = cmd;
+
+    cmd[0] = GPCMD_SET_STREAMING;
+    cmd[10] = sizeof(buffer);
+
+    buffer[8]  = 0xff;
+    buffer[9]  = 0xff;
+    buffer[10] = 0xff;
+    buffer[11] = 0xff;
+
+    buffer[12] = buffer[20] = (rate >> 24) & 0xff;
+    buffer[13] = buffer[21] = (rate >> 16) & 0xff;
+    buffer[14] = buffer[22] = (rate >> 8)  & 0xff;
+    buffer[15] = buffer[23] = rate & 0xff;
+
+    // Note: 0x3e8 == 1000, hence speed = data amount per 1000 milliseconds.
+    buffer[18] = buffer[26] = 0x03;
+    buffer[19] = buffer[27] = 0xe8;
+
+    // On my system (2.6.18 + ide-cd),  SG_IO succeeds without doing anything,
+    // while CDROM_SELECT_SPEED works...
+    if (ioctl(fd, CDROM_SELECT_SPEED, speed) < 0) {
+        if (ioctl(fd, SG_IO, &sghdr) < 0)
+            VERBOSE(VB_IMPORTANT, LOC_ERR + "Limit DVD Speed Failed");
+    }
+    else VERBOSE(VB_IMPORTANT, LOC + "Limiting DVD Speed Successful");
+}
+#endif
Index: libmyth/mythmedia.h
===================================================================
--- libmyth/mythmedia.h (revision 13250)
+++ libmyth/mythmedia.h (working copy)
@@ -81,6 +81,8 @@
     virtual MediaError  testMedia() { return MEDIAERR_UNSUPPORTED; }
     virtual bool openDevice();
     virtual bool closeDevice();
+    virtual bool isSameDevice(const QString &path);
+    virtual void setSpeed(int speed);
     virtual MediaStatus checkMedia() = 0; // Derived classes MUST implement this.
     virtual MediaError eject(bool open_close = true);
     virtual MediaError lock();