Changeset 585

Show
Ignore:
Timestamp:
08/29/07 06:16:32 (15 years ago)
Author:
ppalmers
Message:

- Implement some device-specific details

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • trunk/libffado/src/bebob/focusrite/focusrite_cmd.cpp

    r584 r585  
    3131 
    3232namespace BeBoB { 
     33namespace Focusrite { 
    3334 
    3435FocusriteVendorDependentCmd::FocusriteVendorDependentCmd(Ieee1394Service& ieee1394service) 
     
    7677 
    7778} 
     79} 
     80 
  • trunk/libffado/src/bebob/focusrite/focusrite_cmd.h

    r584 r585  
    3131#include <libavc1394/avc1394.h> 
    3232 
     33#define FOCUSRITE_CMD_ID_SAMPLERATE 84 
     34#define FOCUSRITE_CMD_ID_PHANTOM14  98 
     35#define FOCUSRITE_CMD_ID_PHANTOM58  99 
     36 
     37#define FOCUSRITE_CMD_SAMPLERATE_44K1   1 
     38#define FOCUSRITE_CMD_SAMPLERATE_48K    2 
     39#define FOCUSRITE_CMD_SAMPLERATE_88K2   3 
     40#define FOCUSRITE_CMD_SAMPLERATE_96K    4 
     41#define FOCUSRITE_CMD_SAMPLERATE_176K4  5 
     42#define FOCUSRITE_CMD_SAMPLERATE_192K   6 
     43 
    3344namespace BeBoB { 
     45namespace Focusrite { 
    3446 
    3547class FocusriteVendorDependentCmd: public AVC::VendorDependentCmd 
     
    5466 
    5567} 
     68} 
    5669 
    5770#endif // FOCUSRITEVENDORDEPENDENT_H 
  • trunk/libffado/src/bebob/focusrite/focusrite_device.cpp

    r584 r585  
    2323 
    2424#include "focusrite_device.h" 
     25#include "focusrite_cmd.h" 
    2526 
    2627namespace BeBoB { 
     
    3334    debugOutput( DEBUG_LEVEL_VERBOSE, "Created BeBoB::Focusrite::SaffireProDevice (NodeID %d)\n", 
    3435                 getConfigRom().getNodeId() ); 
     36 
     37    // create control objects for the saffire pro 
     38    m_Phantom1 = new PhantomPowerControl(*this, FOCUSRITE_CMD_ID_PHANTOM14); 
     39    if (m_Phantom1) addElement(m_Phantom1); 
     40     
     41    m_Phantom2 = new PhantomPowerControl(*this, FOCUSRITE_CMD_ID_PHANTOM58); 
     42    if (m_Phantom2) addElement(m_Phantom2); 
     43     
    3544} 
    3645 
    3746SaffireProDevice::~SaffireProDevice() 
    3847{ 
     48    // remove and delete control elements 
     49    deleteElement(m_Phantom1); 
     50    if (m_Phantom1) delete m_Phantom1; 
     51     
     52    deleteElement(m_Phantom2); 
     53    if (m_Phantom2) delete m_Phantom2; 
    3954} 
    4055 
     
    4661} 
    4762 
     63void 
     64SaffireProDevice::setVerboseLevel(int l) 
     65{ 
     66    debugOutput( DEBUG_LEVEL_VERBOSE, "Setting verbose level to %d...\n", l ); 
     67 
     68    if (m_Phantom1) m_Phantom2->setVerboseLevel(l); 
     69    if (m_Phantom2) m_Phantom2->setVerboseLevel(l); 
     70 
     71    BeBoB::AvDevice::setVerboseLevel(l); 
     72} 
     73 
     74int 
     75SaffireProDevice::getSamplingFrequency( ) { 
     76    FocusriteVendorDependentCmd cmd( get1394Service() ); 
     77    cmd.setCommandType( AVC::AVCCommand::eCT_Status ); 
     78    cmd.setNodeId( getConfigRom().getNodeId() ); 
     79    cmd.setVerbose( getDebugLevel() ); 
     80    cmd.setVerbose( DEBUG_LEVEL_VERY_VERBOSE ); 
     81    cmd.m_id=FOCUSRITE_CMD_ID_SAMPLERATE; 
     82 
     83    if ( !cmd.fire() ) { 
     84        debugError( "FocusriteVendorDependentCmd info command failed\n" ); 
     85        return 0; 
     86    } 
     87     
     88    debugOutput( DEBUG_LEVEL_NORMAL, 
     89                     "getSampleRate: %d\n", cmd.m_value ); 
     90 
     91    switch(cmd.m_value) { 
     92        case FOCUSRITE_CMD_SAMPLERATE_44K1:  return 44100; 
     93        case FOCUSRITE_CMD_SAMPLERATE_48K:   return 48000; 
     94        case FOCUSRITE_CMD_SAMPLERATE_88K2:  return 88200; 
     95        case FOCUSRITE_CMD_SAMPLERATE_96K:   return 96000; 
     96        case FOCUSRITE_CMD_SAMPLERATE_176K4: return 176400; 
     97        case FOCUSRITE_CMD_SAMPLERATE_192K:  return 192000; 
     98        default: return 0; 
     99    } 
     100} 
     101 
     102bool 
     103SaffireProDevice::setSamplingFrequency( int s ) 
     104{ 
     105    bool snoopMode=false; 
     106    if(!getOption("snoopMode", snoopMode)) { 
     107        debugWarning("Could not retrieve snoopMode parameter, defauling to false\n"); 
     108    } 
     109 
     110    if(snoopMode) { 
     111        int current_sr=getSamplingFrequency(); 
     112        if (current_sr != s ) { 
     113            debugError("In snoop mode it is impossible to set the sample rate.\n"); 
     114            debugError("Please start the client with the correct setting.\n"); 
     115            return false; 
     116        } 
     117        return true; 
     118    } else { 
     119 
     120        FocusriteVendorDependentCmd cmd( get1394Service() ); 
     121        cmd.setCommandType( AVC::AVCCommand::eCT_Status ); 
     122        cmd.setNodeId( getConfigRom().getNodeId() ); 
     123        cmd.setVerbose( getDebugLevel() ); 
     124        cmd.setVerbose( DEBUG_LEVEL_VERY_VERBOSE ); 
     125        cmd.m_id=FOCUSRITE_CMD_ID_SAMPLERATE; 
     126 
     127        switch(s) { 
     128            case 44100:  cmd.m_value=FOCUSRITE_CMD_SAMPLERATE_44K1;break; 
     129            case 48000:  cmd.m_value=FOCUSRITE_CMD_SAMPLERATE_48K;break; 
     130            case 88200:  cmd.m_value=FOCUSRITE_CMD_SAMPLERATE_88K2;break; 
     131            case 96000:  cmd.m_value=FOCUSRITE_CMD_SAMPLERATE_96K;break; 
     132            case 176400: cmd.m_value=FOCUSRITE_CMD_SAMPLERATE_176K4;break; 
     133            case 192000: cmd.m_value=FOCUSRITE_CMD_SAMPLERATE_192K;break; 
     134            default: 
     135                debugWarning("Unsupported samplerate: %d\n",s); 
     136                return false; 
     137        } 
     138 
     139     
     140        if ( !cmd.fire() ) { 
     141            debugError( "FocusriteVendorDependentCmd info command failed\n" ); 
     142            return false; 
     143        } 
     144 
     145        debugOutput( DEBUG_LEVEL_NORMAL, 
     146                     "setSampleRate: Set sample rate to %d\n", s ); 
     147        return true; 
     148    } 
     149    // not executable 
     150    return false; 
     151 
     152} 
     153 
     154 
     155// --- element implementation classes 
     156 
     157PhantomPowerControl::PhantomPowerControl(SaffireProDevice& parent, int channel) 
     158: Control::Discrete() 
     159, m_Parent(parent) 
     160, m_channel ( channel ) 
     161{ 
     162    std::ostringstream ostrm; 
     163    ostrm << "PhantomPower_"; 
     164    if(channel==FOCUSRITE_CMD_ID_PHANTOM14) ostrm << "1to4"; 
     165    if(channel==FOCUSRITE_CMD_ID_PHANTOM58) ostrm << "5to8"; 
     166    Control::Discrete::setName(ostrm.str()); 
     167     
     168    ostrm.str(""); 
     169    ostrm << "Phantom "; 
     170    if(channel==FOCUSRITE_CMD_ID_PHANTOM14) ostrm << "1-4"; 
     171    if(channel==FOCUSRITE_CMD_ID_PHANTOM58) ostrm << "5-8"; 
     172    setLabel(ostrm.str()); 
     173     
     174    ostrm.str(""); 
     175    ostrm << "Turn on/off Phantom Power on channels "; 
     176    if(channel==FOCUSRITE_CMD_ID_PHANTOM14) ostrm << "1 to 4"; 
     177    if(channel==FOCUSRITE_CMD_ID_PHANTOM58) ostrm << "5 to 8"; 
     178    setDescription(ostrm.str()); 
     179} 
     180 
     181bool 
     182PhantomPowerControl::setValue(int v) 
     183{ 
     184    if (v != 0 && v != 1) return false; 
     185     
     186    FocusriteVendorDependentCmd cmd( m_Parent.get1394Service() ); 
     187    cmd.setCommandType( AVC::AVCCommand::eCT_Control ); 
     188    cmd.setNodeId( m_Parent.getConfigRom().getNodeId() ); 
     189    cmd.setVerbose( getDebugLevel() ); 
     190    cmd.m_id=m_channel; 
     191    cmd.m_value=v; 
     192     
     193    if ( !cmd.fire() ) { 
     194        debugError( "FocusriteVendorDependentCmd info command failed\n" ); 
     195        // shouldn't this be an error situation? 
     196        return false; 
     197    } 
     198    return true; 
     199} 
     200 
     201int 
     202PhantomPowerControl::getValue() 
     203{ 
     204    FocusriteVendorDependentCmd cmd( m_Parent.get1394Service() ); 
     205    cmd.setCommandType( AVC::AVCCommand::eCT_Status ); 
     206    cmd.setNodeId( m_Parent.getConfigRom().getNodeId() ); 
     207    cmd.setVerbose( getDebugLevel() ); 
     208    cmd.m_id=m_channel; 
     209    cmd.m_value=0; 
     210 
     211    if ( !cmd.fire() ) { 
     212        debugError( "FocusriteVendorDependentCmd info command failed\n" ); 
     213        // shouldn't this be an error situation? 
     214        return 0; 
     215    } 
     216 
     217    return cmd.m_value; 
     218} 
     219 
     220 
    48221} // Focusrite 
    49222} // BeBoB 
  • trunk/libffado/src/bebob/focusrite/focusrite_device.h

    r584 r585  
    2929#include "bebob/bebob_avdevice.h" 
    3030 
     31#include "libcontrol/BasicElements.h" 
     32 
    3133namespace BeBoB { 
    3234namespace Focusrite { 
     35 
     36class SaffireProDevice; 
     37 
     38class PhantomPowerControl 
     39    : public Control::Discrete 
     40{ 
     41public: 
     42    PhantomPowerControl(SaffireProDevice& parent, int channel); 
     43     
     44    virtual bool setValue(int v); 
     45    virtual int getValue(); 
     46     
     47private: 
     48    SaffireProDevice&       m_Parent; 
     49    unsigned int            m_channel; 
     50}; 
     51 
    3352 
    3453class SaffireProDevice : public BeBoB::AvDevice { 
     
    3958 
    4059    virtual void showDevice(); 
     60    virtual void setVerboseLevel(int l); 
    4161 
     62    virtual bool setSamplingFrequency( int ); 
     63    virtual int getSamplingFrequency( ); 
     64 
     65private: 
     66    PhantomPowerControl * m_Phantom1; 
     67    PhantomPowerControl * m_Phantom2; 
    4268}; 
    4369 
  • trunk/libffado/src/bebob/terratec/terratec_cmd.cpp

    r584 r585  
    3131 
    3232namespace BeBoB { 
     33namespace Terratec { 
    3334 
    3435TerratecVendorDependentCmd::TerratecVendorDependentCmd(Ieee1394Service& ieee1394service) 
     
    216217 
    217218} 
     219} 
  • trunk/libffado/src/bebob/terratec/terratec_cmd.h

    r584 r585  
    3232 
    3333namespace BeBoB { 
     34namespace Terratec { 
    3435 
    3536class TerratecVendorDependentCmd: public AVC::VendorDependentCmd 
     
    140141 
    141142} 
     143} 
    142144 
    143145#endif // TERRATECVENDORDEPENDENT_H 
  • trunk/libffado/tests/test-ffado.cpp

    r584 r585  
    3636#include "ffadodevice.h" 
    3737 
    38 #include "bebob/focusrite/focusrite_cmd.h" 
    39  
    4038#include <dbus-c++/dbus.h> 
    4139#include "controlserver.h" 
     
    10199                    "           ListOscSpace\n" 
    102100                    "           OscServer\n" 
    103                     "           FocusriteSetPhantom [0=ch1-4, 1=ch5-8] [1=on, 0=off]\n" 
    104101                    "           DBus\n" 
    105102                    ; 
     
    297294            FFADODevice* avDevice = m_deviceManager->getAvDevice( arguments.node_id ); 
    298295            if ( avDevice ) { 
    299                 if ( avDevice->setSamplingFrequency( samplerate ) ) { 
    300                     m_deviceManager->discover(); 
    301                 } else { 
     296                avDevice->setVerboseLevel(arguments.verbose); 
     297                if ( ! avDevice->setSamplingFrequency( samplerate ) ) { 
    302298                    fprintf( stderr, "Could not set samplerate\n" ); 
    303299                } 
     
    314310                FFADODevice* avDevice = m_deviceManager->getAvDevice( node_id ); 
    315311                if ( avDevice ) { 
     312                    avDevice->setVerboseLevel(arguments.verbose); 
    316313                    if ( !avDevice->setSamplingFrequency( samplerate ) ) { 
    317314                        fprintf( stderr, "Could not set samplerate\n" ); 
     
    372369 
    373370        printf("server stopped\n"); 
    374         delete m_deviceManager; 
    375         return exitfunction(0); 
    376     } else if ( strcmp( arguments.args[0], "FocusriteSetPhantom" ) == 0 ) { 
    377         char* tail; 
    378         int inputchannels = strtol( arguments.args[1], &tail, 0 ); 
    379         if ( errno ) { 
    380             fprintf( stderr,  "Could not parse inputchannels argument\n" ); 
    381             return exitfunction(-1); 
    382         } 
    383         int onoff = strtol( arguments.args[2], &tail, 0 ); 
    384         if ( errno ) { 
    385             fprintf( stderr,  "Could not parse on/off argument\n" ); 
    386             return exitfunction(-1); 
    387         } 
    388          
    389         DeviceManager *m_deviceManager = new DeviceManager(); 
    390         if ( !m_deviceManager ) { 
    391             fprintf( stderr, "Could not allocate device manager\n" ); 
    392             return exitfunction(-1); 
    393         } 
    394         if ( arguments.verbose ) { 
    395             m_deviceManager->setVerboseLevel(arguments.verbose); 
    396         } 
    397         if ( !m_deviceManager->initialize( arguments.port ) ) { 
    398             fprintf( stderr, "Could not initialize device manager\n" ); 
    399             delete m_deviceManager; 
    400             return exitfunction(-1); 
    401         } 
    402         if ( arguments.verbose ) { 
    403             m_deviceManager->setVerboseLevel(arguments.verbose); 
    404         } 
    405         if ( !m_deviceManager->discover() ) { 
    406             fprintf( stderr, "Could not discover devices\n" ); 
    407             delete m_deviceManager; 
    408             return exitfunction(-1); 
    409         } 
    410  
    411         if(arguments.node_id_set) { 
    412             FFADODevice* avDevice = m_deviceManager->getAvDevice( arguments.node_id ); 
    413             if ( avDevice ) { 
    414                 if ( avDevice->getConfigRom().getNodeVendorId() == 0x00130e ) { 
    415                      
    416                     BeBoB::FocusriteVendorDependentCmd cmd( avDevice->get1394Service() ); 
    417                     cmd.setCommandType( AVC::AVCCommand::eCT_Control ); 
    418                     cmd.setNodeId( avDevice->getConfigRom().getNodeId() ); 
    419                     cmd.setVerbose( arguments.verbose ); 
    420                      
    421 //                         if (inputchannels) { 
    422 //                             cmd.m_id=99; 
    423 //                         } else { 
    424 //                             cmd.m_id=98; 
    425 //                         } 
    426 //                         if (onoff) { 
    427 //                             cmd.m_value=1; 
    428 //                         } else { 
    429 //                             cmd.m_value=0; 
    430 //                         } 
    431                         cmd.m_id=inputchannels; 
    432                         cmd.m_value=onoff; 
    433                      
    434                     if ( !cmd.fire() ) { 
    435                         debugError( "FocusriteVendorDependentCmd info command failed\n" ); 
    436                         // shouldn't this be an error situation? 
    437                         return exitfunction(-1); 
    438                     } 
    439  
    440                 } else { 
    441                     fprintf( stderr, "Not a Focusrite device: id=0x%06X ...\n", avDevice->getConfigRom().getNodeVendorId()); 
    442                 } 
    443             } 
    444         } else { 
    445             int i=0; 
    446  
    447             int devices_on_bus = m_deviceManager->getNbDevices(); 
    448             printf("  port = %d, devices_on_bus = %d\n", arguments.port, devices_on_bus); 
    449  
    450             for(i=0;i<devices_on_bus;i++) { 
    451                 int node_id=m_deviceManager->getDeviceNodeId(i); 
    452                 printf("  set phantom power for device = %d, node = %d\n", i, node_id); 
    453                 FFADODevice* avDevice = m_deviceManager->getAvDevice( arguments.node_id ); 
    454                 if ( avDevice ) { 
    455                     if ( avDevice->getConfigRom().getNodeVendorId() == 0x00130e ) { 
    456                          
    457                         BeBoB::FocusriteVendorDependentCmd cmd( avDevice->get1394Service() ); 
    458                         cmd.setCommandType( AVC::AVCCommand::eCT_Control ); 
    459                         cmd.setNodeId( avDevice->getConfigRom().getNodeId() ); 
    460                         cmd.setVerbose( arguments.verbose ); 
    461                          
    462 //                         if (inputchannels) { 
    463 //                             cmd.m_id=99; 
    464 //                         } else { 
    465 //                             cmd.m_id=98; 
    466 //                         } 
    467 //                         if (onoff) { 
    468 //                             cmd.m_value=1; 
    469 //                         } else { 
    470 //                             cmd.m_value=0; 
    471 //                         } 
    472                         cmd.m_id=inputchannels; 
    473                         cmd.m_value=onoff; 
    474                          
    475                         if ( !cmd.fire() ) { 
    476                             debugError( "FocusriteVendorDependentCmd info command failed\n" ); 
    477                             // shouldn't this be an error situation? 
    478                             return exitfunction(-1); 
    479                         } 
    480      
    481                     } else { 
    482                         fprintf( stderr, "Not a Focusrite device: id=0x%06X ...\n", avDevice->getConfigRom().getNodeVendorId()); 
    483                     } 
    484                 } 
    485  
    486             } 
    487         } 
    488371        delete m_deviceManager; 
    489372        return exitfunction(0);