kmix/mixer_backend.cpp

   1 /*
   2  * KMix -- KDE's full featured mini mixer
   3  *
   4  * Copyright 2006-2007 Christian Esken <esken@kde.org>
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Library General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Library General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Library General Public
  17  * License along with this program; if not, write to the Free
  18  * Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  19  */
  20
  21 #include <klocale.h>
  22
  23 #include "mixer_backend.h"
  24 // for the "ERR_" declartions, #include mixer.h
  25 #include "mixer.h"
  26 #include <QTimer>
  27 Mixer_Backend::Mixer_Backend(Mixer *mixer, int device) :
  28         m_devnum (device) , m_isOpen(false), m_recommendedMaster(0), _mixer(mixer), _pollingTimer(0)
  29
  30 {
  31    // In all cases create a QTimer. We will use it once as a singleShot(), even if something smart
  32    // like ::select() is possible (as in ALSA).
  33    _pollingTimer = new QTimer(); // will be started on open() and stopped on close()
  34    connect( _pollingTimer, SIGNAL(timeout()), this, SLOT(readSetFromHW()));
  35 }
  36
  37 Mixer_Backend::~Mixer_Backend()
  38 {
  39     delete _pollingTimer;
  40     qDeleteAll(m_mixDevices);
  41     m_mixDevices.clear();
  42 }
  43
  44
  45 bool Mixer_Backend::openIfValid() {
  46     bool valid = false;
  47     int ret = open();
  48     if ( ret == 0  && m_mixDevices.count() > 0) {
  49         valid = true;
  50         // A better ID is now calculated in mixertoolbox.cpp, and set via setID(),
  51         // but we want a somehow usable fallback just in case.
  52
  53         if ( needsPolling() ) {
  54             _pollingTimer->start(50);
  55         }
  56         else {
  57             // The initial state must be read manually
  58             QTimer::singleShot( 50, this, SLOT( readSetFromHW() ) );
  59         }
  60     } // cold be opened
  61     else {
  62         close();
  63     }
  64     return valid;
  65 }
  66
  67 bool Mixer_Backend::isOpen() {
  68   return m_isOpen;
  69 }
  70
  71 /**
  72  * Queries the backend driver whether there are new changes in any of the controls.
  73  * If you cannot find out for a backend, return "true" - this is also the default implementation.
  74  * @return true, if there are changes. Otherwise false is returned.
  75  */
  76 bool Mixer_Backend::prepareUpdateFromHW() {
  77   return true;
  78 }
  79
  80
  81 /**
  82  * After calling this, readSetFromHW() will do a complete update. This will
  83  * trigger emitting the appropriate signals like controlChanged().
  84  *
  85  * This method is useful, if you need to get a "refresh signal" - used at:
  86  * 1) Start of KMix - so that we can be sure an initial signal is emitted
  87  * 2) When reconstructing any MixerWidget (e.g. DockIcon after applying preferences)
  88  */
  89 void Mixer_Backend::readSetFromHWforceUpdate() const {
  90    _readSetFromHWforceUpdate = true;
  91 }
  92
  93
  94 /**
  95    You can call this to retrieve the freshest information from the mixer HW.
  96    This method is also called regulary by the mixer timer.
  97 */
  98 void Mixer_Backend::readSetFromHW()
  99 {
 100     bool updated = prepareUpdateFromHW();
 101     if ( (! updated) && (! _readSetFromHWforceUpdate) ) {
 102         // Some drivers (ALSA) are smart. We don't need to run the following
 103         // time-consuming update loop if there was no change
 104         kDebug(67100) << "Mixer::readSetFromHW(): smart-update-tick";
 105         return;
 106     }
 107     _readSetFromHWforceUpdate = false;
 108
 109     int mdCount = m_mixDevices.count();
 110     for(int i=0; i<mdCount  ; ++i )
 111     {
 112         MixDevice *md = m_mixDevices[i];
 113         readVolumeFromHW( md->id(), md );
 114         if (md->isEnum() ) {
 115             /*
 116              * This could be reworked:
 117              * Plan: Read everything (incuding enum's) in readVolumeFromHW().
 118              * readVolumeFromHW() should then be renamed to readHW().
 119              */
 120             md->setEnumId( enumIdHW(md->id()) );
 121         }
 122     }
 123     emit controlChanged();
 124 }
 125
 126 /**
 127  * Return the MixDevice, that would qualify best as MasterDevice. The default is to return the
 128  * first device in the device list. Backends can override this (i.e. the ALSA Backend does so).
 129  * The users preference is NOT returned by this method - see the Mixer class for that.
 130  */
 131 MixDevice* Mixer_Backend::recommendedMaster() {
 132    if ( m_recommendedMaster != 0 ) {
 133       return m_recommendedMaster;   // Backend has set a recommended master. Thats fine.
 134    } // recommendation from Backend
 135    else if ( m_mixDevices.count() > 0 ) {
 136       return m_mixDevices.at(0);  // Backend has NOT set a recommended master. Evil backend => lets help out.
 137    } //first device (if exists)
 138    else {
 139       // This should never ever happen, as KMix doe NOT accept soundcards without controls
 140       kError(67100) << "Mixer_Backend::recommendedMaster(): returning invalid master. This is a bug in KMix. Please file a bug report stating how you produced this." << endl;
 141       return (MixDevice*)0;
 142    }
 143 }
 144
 145 /**
 146  * Sets the ID of the currently selected Enum entry.
 147  * This is a dummy implementation - if the Mixer backend
 148  * wants to support it, it must implement the driver specific
 149  * code in its subclass (see Mixer_ALSA.cpp for an example).
 150  */
 151 void Mixer_Backend::setEnumIdHW(const QString& , unsigned int) {
 152   return;
 153 }
 154
 155 /**
 156  * Return the ID of the currently selected Enum entry.
 157  * This is a dummy implementation - if the Mixer backend
 158  * wants to support it, it must implement the driver specific
 159  * code in its subclass (see Mixer_ALSA.cpp for an example).
 160  */
 161 unsigned int Mixer_Backend::enumIdHW(const QString& ) {
 162   return 0;
 163 }
 164
 165 void Mixer_Backend::errormsg(int mixer_error)
 166 {
 167   QString l_s_errText;
 168   l_s_errText = errorText(mixer_error);
 169   kError() << l_s_errText << "\n";
 170 }
 171
 172 int Mixer_Backend::id2num(const QString& id)
 173 {
 174    return id.toInt();
 175 }
 176
 177 QString Mixer_Backend::errorText(int mixer_error)
 178 {
 179   QString l_s_errmsg;
 180   switch (mixer_error)
 181   {
 182     case Mixer::ERR_PERM:
 183       l_s_errmsg = i18n("kmix:You do not have permission to access the mixer device.\n" \
 184           "Please check your operating systems manual to allow the access.");
 185       break;
 186     case Mixer::ERR_WRITE:
 187       l_s_errmsg = i18n("kmix: Could not write to mixer.");
 188       break;
 189     case Mixer::ERR_READ:
 190       l_s_errmsg = i18n("kmix: Could not read from mixer.");
 191       break;
 192     case Mixer::ERR_OPEN:
 193       l_s_errmsg = i18n("kmix: Mixer cannot be found.\n" \
 194           "Please check that the soundcard is installed and that\n" \
 195           "the soundcard driver is loaded.\n");
 196       break;
 197     default:
 198       l_s_errmsg = i18n("kmix: Unknown error. Please report how you produced this error.");
 199       break;
 200   }
 201   return l_s_errmsg;
 202 }
 203
 204 #include "mixer_backend.moc"