/[svn]/qsampler/trunk/src/qsamplerDevice.cpp
ViewVC logotype

Diff of /qsampler/trunk/src/qsamplerDevice.cpp

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 462 by capela, Tue Mar 15 11:39:12 2005 UTC revision 468 by capela, Wed Mar 16 09:49:37 2005 UTC
# Line 107  void qsamplerDeviceParam::setParam ( lsc Line 107  void qsamplerDeviceParam::setParam ( lsc
107  qsamplerDevice::qsamplerDevice ( lscp_client_t *pClient,  qsamplerDevice::qsamplerDevice ( lscp_client_t *pClient,
108          qsamplerDeviceType deviceType, int iDeviceID )          qsamplerDeviceType deviceType, int iDeviceID )
109  {  {
110            m_ports.setAutoDelete(true);
111            
112          setDevice(pClient, deviceType, iDeviceID);          setDevice(pClient, deviceType, iDeviceID);
113  }  }
114    
# Line 123  void qsamplerDevice::setDevice ( lscp_cl Line 125  void qsamplerDevice::setDevice ( lscp_cl
125          // Device id and type should be always set.          // Device id and type should be always set.
126          m_iDeviceID  = iDeviceID;          m_iDeviceID  = iDeviceID;
127          m_deviceType = deviceType;          m_deviceType = deviceType;
128            
129            // Reset device parameters and ports anyway.
130            m_params.clear();
131            m_ports.clear();
132    
133          // Retrieve device info, if any.          // Retrieve device info, if any.
134          lscp_device_info_t *pDeviceInfo = NULL;          lscp_device_info_t *pDeviceInfo = NULL;
# Line 153  void qsamplerDevice::setDevice ( lscp_cl Line 159  void qsamplerDevice::setDevice ( lscp_cl
159                  + QObject::tr("Device %1").arg(m_iDeviceID);                  + QObject::tr("Device %1").arg(m_iDeviceID);
160    
161          // Grab device parameters...          // Grab device parameters...
         m_params.clear();  
162          for (int i = 0; pDeviceInfo->params && pDeviceInfo->params[i].key; i++) {          for (int i = 0; pDeviceInfo->params && pDeviceInfo->params[i].key; i++) {
163                  const char *pszParam = pDeviceInfo->params[i].key;                  const QString sParam = pDeviceInfo->params[i].key;
164                  lscp_param_info_t *pParamInfo = NULL;                  lscp_param_info_t *pParamInfo = NULL;
165                  switch (deviceType) {                  switch (deviceType) {
166                  case qsamplerDevice::Audio:                  case qsamplerDevice::Audio:
167                          pParamInfo = ::lscp_get_audio_driver_param_info(pClient,                          pParamInfo = ::lscp_get_audio_driver_param_info(pClient,
168                                  m_sDriverName.latin1(), pszParam, NULL);                                  m_sDriverName.latin1(), sParam.latin1(), NULL);
169                          break;                          break;
170                  case qsamplerDevice::Midi:                  case qsamplerDevice::Midi:
171                          pParamInfo = ::lscp_get_midi_driver_param_info(pClient,                          pParamInfo = ::lscp_get_midi_driver_param_info(pClient,
172                                  m_sDriverName.latin1(), pszParam, NULL);                                  m_sDriverName.latin1(), sParam.latin1(), NULL);
173                          break;                          break;
174                  case qsamplerDevice::None:                  case qsamplerDevice::None:
175                          break;                          break;
176                  }                  }
177                  if (pParamInfo) {                  if (pParamInfo) {
178                          m_params[pszParam] = qsamplerDeviceParam(pParamInfo,                          m_params[sParam.upper()] = qsamplerDeviceParam(pParamInfo,
179                                  pDeviceInfo->params[i].value);                                  pDeviceInfo->params[i].value);
180                  }                  }
181          }          }
182    
183            // Refresh parameter dependencies...
184            refreshParams(pClient);
185            // Set port/channel list...
186            refreshPorts(pClient);
187  }  }
188    
189    
# Line 185  void qsamplerDevice::setDriver ( lscp_cl Line 195  void qsamplerDevice::setDriver ( lscp_cl
195          if (m_sDriverName == sDriverName)          if (m_sDriverName == sDriverName)
196                  return;                  return;
197    
198            // Reset device parameters and ports anyway.
199            m_params.clear();
200            m_ports.clear();
201    
202          // Retrieve driver info, if any.          // Retrieve driver info, if any.
203          lscp_driver_info_t *pDriverInfo = NULL;          lscp_driver_info_t *pDriverInfo = NULL;
204          switch (m_deviceType) {          switch (m_deviceType) {
# Line 208  void qsamplerDevice::setDriver ( lscp_cl Line 222  void qsamplerDevice::setDriver ( lscp_cl
222          m_sDriverName = sDriverName;          m_sDriverName = sDriverName;
223    
224          // Grab driver parameters...          // Grab driver parameters...
         m_params.clear();  
225          for (int i = 0; pDriverInfo->parameters && pDriverInfo->parameters[i]; i++) {          for (int i = 0; pDriverInfo->parameters && pDriverInfo->parameters[i]; i++) {
226                  const char *pszParam = pDriverInfo->parameters[i];                  const QString sParam = pDriverInfo->parameters[i];
227                  lscp_param_info_t *pParamInfo = NULL;                  lscp_param_info_t *pParamInfo = NULL;
228                  switch (m_deviceType) {                  switch (m_deviceType) {
229                  case qsamplerDevice::Audio:                  case qsamplerDevice::Audio:
230                          pParamInfo = ::lscp_get_audio_driver_param_info(pClient,                          pParamInfo = ::lscp_get_audio_driver_param_info(pClient,
231                                  sDriverName.latin1(), pszParam, NULL);                                  sDriverName.latin1(), sParam.latin1(), NULL);
232                          break;                          break;
233                  case qsamplerDevice::Midi:                  case qsamplerDevice::Midi:
234                          pParamInfo = ::lscp_get_midi_driver_param_info(pClient,                          pParamInfo = ::lscp_get_midi_driver_param_info(pClient,
235                                  sDriverName.latin1(), pszParam, NULL);                                  sDriverName.latin1(), sParam.latin1(), NULL);
236                          break;                          break;
237                  case qsamplerDevice::None:                  case qsamplerDevice::None:
238                          break;                          break;
239                  }                  }
240                  if (pParamInfo)                  if (pParamInfo) {
241                          m_params[pszParam] = qsamplerDeviceParam(pParamInfo, pParamInfo->defaultv);                          m_params[sParam.upper()] = qsamplerDeviceParam(pParamInfo,
242                                    pParamInfo->defaultv);
243                    }
244          }          }
245    
246            // Refresh parameter dependencies...
247            refreshParams(pClient);
248            // Set port/channel list...
249            refreshPorts(pClient);
250  }  }
251    
252    
# Line 256  const QString& qsamplerDevice::deviceNam Line 276  const QString& qsamplerDevice::deviceNam
276          return m_sDeviceName;          return m_sDeviceName;
277  }  }
278    
279    
280    // Set the proper device parameter value.
281    void qsamplerDevice::setParam ( const QString& sParam,
282            const QString& sValue )
283    {
284            m_params[sParam.upper()].value = sValue;
285    }
286    
287    
288  // Device parameter accessor.  // Device parameter accessor.
289  const qsamplerDeviceParamMap& qsamplerDevice::params (void) const  const qsamplerDeviceParamMap& qsamplerDevice::params (void) const
290  {  {
# Line 263  const qsamplerDeviceParamMap& qsamplerDe Line 292  const qsamplerDeviceParamMap& qsamplerDe
292  }  }
293    
294    
295  // Set the proper device parameter value.  // Device port/channel list accessor.
296  void qsamplerDevice::setParam ( const QString& sParam,  qsamplerDevicePortList& qsamplerDevice::ports (void)
297          const QString& sValue )  {
298            return m_ports;
299    }
300    
301    
302    // Device parameter dependencies refreshner.
303    int qsamplerDevice::refreshParams ( lscp_client_t *pClient )
304    {
305            // This should only make sense for scratch devices...
306            if (m_iDeviceID >= 0)
307                return 0;
308            // Refresh all parameters that have dependencies...
309            int iParams = 0;
310            qsamplerDeviceParamMap::ConstIterator iter;
311            for (iter = m_params.begin(); iter != m_params.end(); ++iter)
312                    iParams += refreshParam(pClient, iter.key());
313            // Return how many parameters have been refreshed...
314            return iParams;
315    }
316    
317    
318    // Device port/channel list refreshner.
319    int qsamplerDevice::refreshPorts ( lscp_client_t *pClient )
320  {  {
321          m_params[sParam].value = sValue;          // This should only make sense for actual devices...
322            if (m_iDeviceID < 0)
323                return 0;
324            // Port/channel count determination...
325            int iPorts = 0;
326            switch (m_deviceType) {
327            case qsamplerDevice::Audio:
328                    iPorts = m_params["CHANNELS"].value.toInt();
329                    break;
330            case qsamplerDevice::Midi:
331                    iPorts = m_params["PORTS"].value.toInt();
332                    break;
333            case qsamplerDevice::None:
334                    break;
335            }
336            // Retrieve port/channel information...
337            m_ports.clear();
338            for (int iPort = 0; iPort < iPorts; iPort++)
339                    m_ports.append(new qsamplerDevicePort(pClient, *this, iPort));
340            // Return how many ports have been refreshed...
341            return iPorts;
342    }
343    
344    
345    // Refresh/set dependencies given that some parameter has changed.
346    int qsamplerDevice::refreshDepends ( lscp_client_t *pClient,
347            const QString& sParam )
348    {
349            // This should only make sense for scratch devices...
350            if (m_iDeviceID >= 0)
351                return 0;
352            // Refresh all parameters that depend on this one...
353            int iDepends = 0;
354            qsamplerDeviceParamMap::ConstIterator iter;
355            for (iter = m_params.begin(); iter != m_params.end(); ++iter) {
356                    const QStringList& depends = iter.data().depends;
357                    if (depends.find(sParam) != depends.end())
358                            iDepends += refreshParam(pClient, iter.key());
359            }
360            // Return how many dependencies have been refreshed...
361            return iDepends;
362    }
363    
364    
365    // Refresh/set given parameter based on driver supplied dependencies.
366    int qsamplerDevice::refreshParam ( lscp_client_t *pClient,
367            const QString& sParam )
368    {
369            // Check if we have dependencies...
370            qsamplerDeviceParam& param = m_params[sParam.upper()];
371            if (param.depends.isEmpty())
372                    return 0;
373    
374            int iRefresh = 0;
375    
376            // Build dependency list...
377            lscp_param_t *pDepends = new lscp_param_t [param.depends.count() + 1];
378            int iDepend = 0;
379            QStringList::ConstIterator iter;
380            for (iter = param.depends.begin(); iter != param.depends.end(); ++iter) {
381                    const QString& sDepend = *iter;
382                    pDepends[iDepend].key   = (char *) sDepend.latin1();
383                    pDepends[iDepend].value = (char *) m_params[sDepend.upper()].value.latin1();
384                    ++iDepend;
385            }
386            // Null terminated.
387            pDepends[iDepend].key   = NULL;
388            pDepends[iDepend].value = NULL;
389    
390            // FIXME: Some parameter dependencies (e.g.ALSA CARD)
391            // are blocking for no reason, causing potential timeout-crashes.
392            // hopefully this gets mitigated if this dependency hell is only
393            // carried out for scratch devices...
394    
395            // Retrieve some modern parameters...
396            lscp_param_info_t *pParamInfo = NULL;
397            switch (m_deviceType) {
398            case qsamplerDevice::Audio:
399                    pParamInfo = ::lscp_get_audio_driver_param_info(pClient,
400                            m_sDriverName.latin1(), sParam.latin1(), pDepends);
401                    break;
402            case qsamplerDevice::Midi:
403                    pParamInfo = ::lscp_get_midi_driver_param_info(pClient,
404                            m_sDriverName.latin1(), sParam.latin1(), pDepends);
405                    break;
406            case qsamplerDevice::None:
407                    break;
408            }
409            if (pParamInfo) {
410                    param = qsamplerDeviceParam(pParamInfo, QString(param.value));
411                    iRefresh++;
412            }
413    
414            // Free used parameter array.
415            delete pDepends;
416    
417            // Return whether the parameters has been changed...
418            return iRefresh;
419  }  }
420    
421    
# Line 339  void qsamplerDevicePort::setDevicePort ( Line 487  void qsamplerDevicePort::setDevicePort (
487          // Device port id should be always set.          // Device port id should be always set.
488          m_iPortID = iPortID;          m_iPortID = iPortID;
489    
490            // Reset port parameters anyway.
491            m_params.clear();
492    
493          // Retrieve device port/channel info, if any.          // Retrieve device port/channel info, if any.
494            QString sPrefix = device.driverName() + ' ';
495          lscp_device_port_info_t *pPortInfo = NULL;          lscp_device_port_info_t *pPortInfo = NULL;
496          switch (device.deviceType()) {          switch (device.deviceType()) {
497          case qsamplerDevice::Audio:          case qsamplerDevice::Audio:
498                    sPrefix += QObject::tr("Channel");
499                  pPortInfo = ::lscp_get_audio_channel_info(pClient, device.deviceID(), iPortID);                  pPortInfo = ::lscp_get_audio_channel_info(pClient, device.deviceID(), iPortID);
500                  break;                  break;
501          case qsamplerDevice::Midi:          case qsamplerDevice::Midi:
502                    sPrefix += QObject::tr("Port");
503                  pPortInfo = ::lscp_get_midi_port_info(pClient, device.deviceID(), iPortID);                  pPortInfo = ::lscp_get_midi_port_info(pClient, device.deviceID(), iPortID);
504                  break;                  break;
505          case qsamplerDevice::None:          case qsamplerDevice::None:
# Line 359  void qsamplerDevicePort::setDevicePort ( Line 513  void qsamplerDevicePort::setDevicePort (
513          }          }
514    
515          // Set device port/channel properties...          // Set device port/channel properties...
516          m_sPortName = pPortInfo->name;          sPrefix += " %1:";
517            m_sPortName = sPrefix.arg(m_iPortID)  + ' ' + pPortInfo->name;
518    
519          // Grab device port/channel parameters...          // Grab device port/channel parameters...
520          m_params.clear();          m_params.clear();
521          for (int i = 0; pPortInfo->params && pPortInfo->params[i].key; i++) {          for (int i = 0; pPortInfo->params && pPortInfo->params[i].key; i++) {
522                  const char *pszParam = pPortInfo->params[i].key;                  const QString sParam = pPortInfo->params[i].key;
523                  lscp_param_info_t *pParamInfo = NULL;                  lscp_param_info_t *pParamInfo = NULL;
524                  switch (device.deviceType()) {                  switch (device.deviceType()) {
525                  case qsamplerDevice::Audio:                  case qsamplerDevice::Audio:
526                          pParamInfo = ::lscp_get_audio_channel_param_info(pClient,                          pParamInfo = ::lscp_get_audio_channel_param_info(pClient,
527                                  device.deviceID(), iPortID, pszParam);                                  device.deviceID(), iPortID, sParam.latin1());
528                          break;                          break;
529                  case qsamplerDevice::Midi:                  case qsamplerDevice::Midi:
530                          pParamInfo = ::lscp_get_midi_port_param_info(pClient,                          pParamInfo = ::lscp_get_midi_port_param_info(pClient,
531                                  device.deviceID(), iPortID, pszParam);                                  device.deviceID(), iPortID, sParam.latin1());
532                          break;                          break;
533                  case qsamplerDevice::None:                  case qsamplerDevice::None:
534                          break;                          break;
535                  }                  }
536                  if (pParamInfo) {                  if (pParamInfo) {
537                          m_params[pszParam] = qsamplerDeviceParam(pParamInfo,                          m_params[sParam.upper()] = qsamplerDeviceParam(pParamInfo,
538                                  pPortInfo->params[i].value);                                  pPortInfo->params[i].value);
539                  }                  }
540          }          }
# Line 408  const qsamplerDeviceParamMap& qsamplerDe Line 563  const qsamplerDeviceParamMap& qsamplerDe
563  void qsamplerDevicePort::setParam ( const QString& sParam,  void qsamplerDevicePort::setParam ( const QString& sParam,
564          const QString& sValue )          const QString& sValue )
565  {  {
566          m_params[sParam].value = sValue;          m_params[sParam.upper()].value = sValue;
567  }  }
568    
569    
# Line 499  qsamplerDeviceParamTable::qsamplerDevice Line 654  qsamplerDeviceParamTable::qsamplerDevice
654          // Set read-onlyness of each column          // Set read-onlyness of each column
655          QTable::setColumnReadOnly(0, true);          QTable::setColumnReadOnly(0, true);
656          QTable::setColumnReadOnly(1, true);          QTable::setColumnReadOnly(1, true);
657  //  QTable::setColumnReadOnly(2, true); -- of course not.  //  QTable::setColumnReadOnly(2, false); -- of course not.
658          QTable::setColumnStretchable(1, true);          QTable::setColumnStretchable(1, true);
659  }  }
660    
# Line 528  void qsamplerDeviceParamTable::refresh ( Line 683  void qsamplerDeviceParamTable::refresh (
683                  QTable::setText(iRow, 1, param.description);                  QTable::setText(iRow, 1, param.description);
684                  if (param.type == LSCP_TYPE_BOOL) {                  if (param.type == LSCP_TYPE_BOOL) {
685                          QStringList opts;                          QStringList opts;
686                          opts.append(tr("False"));                          opts.append(tr("false"));
687                          opts.append(tr("True"));                          opts.append(tr("true"));
688                          QComboTableItem *pComboItem = new QComboTableItem(this, opts);                          QComboTableItem *pComboItem = new QComboTableItem(this, opts);
689                          pComboItem->setCurrentItem(param.value.lower() == "true" ? 1 : 0);                          pComboItem->setCurrentItem(param.value.lower() == "true" ? 1 : 0);
690                          pComboItem->setEnabled(bEnabled);                          pComboItem->setEnabled(bEnabled);
Legend:
Removed from v.462  
changed lines
  Added in v.468
  ViewVC Help
Powered by ViewVC