Show
Ignore:
Timestamp:
10/20/07 08:32:47 (15 years ago)
Author:
ppalmers
Message:

- Implement more complete mixer support for the saffire pro
- fix some cleanup issues with control elements

Files:

Legend:

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

    r648 r661  
    7272AvDevice::~AvDevice() 
    7373{ 
    74     delete m_Mixer
     74    destroyMixer()
    7575} 
    7676 
     
    144144    } 
    145145 
     146    if(!buildMixer()) { 
     147        debugWarning("Could not build mixer\n"); 
     148    } 
     149    return true; 
     150} 
     151 
     152bool 
     153AvDevice::buildMixer() 
     154{ 
     155    debugOutput(DEBUG_LEVEL_VERBOSE, "Building a generic BeBoB mixer...\n"); 
    146156    // create a Mixer 
    147157    // this removes the mixer if it already exists 
     
    152162    if(getAudioSubunit(0) == NULL) { 
    153163        debugWarning("Could not find audio subunit, mixer not available.\n"); 
    154         m_Mixer = 0
     164        m_Mixer = NULL
    155165    } else { 
    156166        m_Mixer = new Mixer(*this); 
    157167    } 
     168    return m_Mixer != NULL; 
     169} 
     170 
     171bool 
     172AvDevice::destroyMixer() 
     173{ 
     174    delete m_Mixer; 
    158175    return true; 
    159176} 
  • trunk/libffado/src/bebob/bebob_avdevice.h

    r630 r661  
    8585protected: 
    8686    virtual bool propagatePlugInfo(); 
     87     
     88    virtual bool buildMixer(); 
     89    virtual bool destroyMixer(); 
    8790 
    8891public: 
  • trunk/libffado/src/bebob/focusrite/focusrite_generic.cpp

    r653 r661  
    131131// --- element implementation classes 
    132132 
    133 BinaryControl::BinaryControl(FocusriteDevice& parent, int id) 
    134 : Control::Discrete() 
    135 , m_Parent(parent) 
    136 , m_cmd_id ( id ) 
     133BinaryControl::BinaryControl(FocusriteDevice& parent, int id, int bit) 
     134: Control::Discrete() 
     135, m_Parent(parent) 
     136, m_cmd_id ( id ) 
     137, m_cmd_bit ( bit ) 
    137138{} 
    138 BinaryControl::BinaryControl(FocusriteDevice& parent, int id, 
     139BinaryControl::BinaryControl(FocusriteDevice& parent, int id, int bit, 
    139140                std::string name, std::string label, std::string descr) 
    140141: Control::Discrete() 
    141142, m_Parent(parent) 
    142143, m_cmd_id ( id ) 
     144, m_cmd_bit ( bit ) 
    143145{ 
    144146    setName(name); 
     
    150152BinaryControl::setValue(int v) 
    151153{ 
    152     uint32_t val=0; 
    153     if (v) val=1; 
     154    uint32_t reg; 
     155    uint32_t old_reg; 
     156 
     157    if ( !m_Parent.getSpecificValue(m_cmd_id, &reg) ) { 
     158        debugError( "getSpecificValue failed\n" ); 
     159        return 0; 
     160    } 
     161     
     162    old_reg=reg; 
     163    if (v) { 
     164        reg |= (1<<m_cmd_bit); 
     165    } else { 
     166        reg &= ~(1<<m_cmd_bit); 
     167    } 
     168    debugOutput(DEBUG_LEVEL_VERBOSE, "setValue for id %d to %d (reg: 0x%08X => 0x%08X)\n",  
     169                                     m_cmd_id, v, old_reg, reg); 
     170 
     171    if ( !m_Parent.setSpecificValue(m_cmd_id, reg) ) { 
     172        debugError( "setSpecificValue failed\n" ); 
     173        return false; 
     174    } else return true; 
     175
     176 
     177int 
     178BinaryControl::getValue() 
     179
     180    uint32_t reg; 
     181 
     182    if ( !m_Parent.getSpecificValue(m_cmd_id, &reg) ) { 
     183        debugError( "getSpecificValue failed\n" ); 
     184        return 0; 
     185    } else { 
     186        bool val= (reg & (1<<m_cmd_bit)) != 0; 
     187        debugOutput(DEBUG_LEVEL_VERBOSE, "getValue for %d: reg: 0x%08X, result=%d\n",  
     188                                         m_cmd_id, reg, val); 
     189        return val; 
     190    } 
     191
     192 
     193// --- element implementation classes 
     194 
     195VolumeControl::VolumeControl(FocusriteDevice& parent, int id) 
     196: Control::Discrete() 
     197, m_Parent(parent) 
     198, m_cmd_id ( id ) 
     199{} 
     200VolumeControl::VolumeControl(FocusriteDevice& parent, int id, 
     201                std::string name, std::string label, std::string descr) 
     202: Control::Discrete() 
     203, m_Parent(parent) 
     204, m_cmd_id ( id ) 
     205
     206    setName(name); 
     207    setLabel(label); 
     208    setDescription(descr); 
     209
     210 
     211 
     212bool 
     213VolumeControl::setValue(int v) 
     214
     215    if (v>0x07FFF) v=0x07FFF; 
     216    else if (v<0) v=0; 
     217 
    154218    debugOutput(DEBUG_LEVEL_VERBOSE, "setValue for id %d to %d\n",  
    155219                                     m_cmd_id, v); 
    156220 
    157     if ( !m_Parent.setSpecificValue(m_cmd_id, val) ) { 
     221    if ( !m_Parent.setSpecificValue(m_cmd_id, v) ) { 
    158222        debugError( "setSpecificValue failed\n" ); 
    159223        return false; 
     
    162226 
    163227int 
    164 BinaryControl::getValue() 
     228VolumeControl::getValue() 
    165229{ 
    166230    uint32_t val=0; 
     
    176240} 
    177241 
    178 // --- element implementation classes 
    179  
    180 VolumeControl::VolumeControl(FocusriteDevice& parent, int id) 
    181 : Control::Discrete() 
    182 , m_Parent(parent) 
    183 , m_cmd_id ( id ) 
    184 {} 
    185 VolumeControl::VolumeControl(FocusriteDevice& parent, int id, 
    186                 std::string name, std::string label, std::string descr) 
    187 : Control::Discrete() 
    188 , m_Parent(parent) 
    189 , m_cmd_id ( id ) 
    190 { 
    191     setName(name); 
    192     setLabel(label); 
    193     setDescription(descr); 
    194 } 
    195  
    196  
    197 bool 
    198 VolumeControl::setValue(int v) 
    199 { 
    200     if (v>0x07FFF) v=0x07FFF; 
    201     else if (v<0) v=0; 
    202  
    203     debugOutput(DEBUG_LEVEL_VERBOSE, "setValue for id %d to %d\n",  
    204                                      m_cmd_id, v); 
    205  
    206     if ( !m_Parent.setSpecificValue(m_cmd_id, v) ) { 
    207         debugError( "setSpecificValue failed\n" ); 
    208         return false; 
    209     } else return true; 
    210 } 
    211  
    212 int 
    213 VolumeControl::getValue() 
    214 { 
    215     uint32_t val=0; 
    216  
    217     if ( !m_Parent.getSpecificValue(m_cmd_id, &val) ) { 
    218         debugError( "getSpecificValue failed\n" ); 
    219         return 0; 
    220     } else { 
    221         debugOutput(DEBUG_LEVEL_VERBOSE, "getValue for %d = %d\n",  
    222                                          m_cmd_id, val); 
    223         return val; 
    224     } 
    225 } 
    226  
    227242} // Focusrite 
    228243} // BeBoB 
  • trunk/libffado/src/bebob/focusrite/focusrite_generic.h

    r649 r661  
    4040{ 
    4141public: 
    42     BinaryControl(FocusriteDevice& parent, int id); 
    43     BinaryControl(FocusriteDevice& parent, int id, 
     42    BinaryControl(FocusriteDevice& parent, int id, int bit); 
     43    BinaryControl(FocusriteDevice& parent, int id, int bit, 
    4444                  std::string name, std::string label, std::string descr); 
    4545     
     
    5050    FocusriteDevice&       m_Parent; 
    5151    unsigned int            m_cmd_id; 
     52    unsigned int            m_cmd_bit; 
    5253}; 
    5354 
  • trunk/libffado/src/bebob/focusrite/focusrite_saffirepro.cpp

    r653 r661  
    3131                            std::auto_ptr<ConfigRom>( configRom )) 
    3232    : FocusriteDevice( ieee1394Service, configRom) 
     33    , m_MixerContainer ( NULL ) 
    3334{ 
    3435    debugOutput( DEBUG_LEVEL_VERBOSE, "Created BeBoB::Focusrite::SaffireProDevice (NodeID %d)\n", 
    3536                 getConfigRom().getNodeId() ); 
    36  
     37     
    3738    // the saffire pro doesn't seem to like it if the commands are too fast 
    38     if (AVC::AVCCommand::getSleepAfterAVCCommand() < 200) { 
    39         AVC::AVCCommand::setSleepAfterAVCCommand( 200 ); 
     39    if (AVC::AVCCommand::getSleepAfterAVCCommand() < 500) { 
     40        AVC::AVCCommand::setSleepAfterAVCCommand( 500 ); 
     41    } 
     42
     43 
     44SaffireProDevice::~SaffireProDevice() 
     45
     46    destroyMixer(); 
     47
     48 
     49bool 
     50SaffireProDevice::buildMixer() 
     51
     52    bool result=true; 
     53    debugOutput(DEBUG_LEVEL_VERBOSE, "Building a Focusrite SaffirePro mixer...\n"); 
     54     
     55    destroyMixer(); 
     56     
     57    // create the mixer object container 
     58    m_MixerContainer = new Control::Container("Mixer"); 
     59 
     60    if (!m_MixerContainer) { 
     61        debugError("Could not create mixer container...\n"); 
     62        return false; 
    4063    } 
    4164 
    4265    // create control objects for the saffire pro 
    43     m_Phantom1 = new BinaryControl(*this, FR_SAFFIREPRO_CMD_ID_PHANTOM14, 
    44                  "Phantom_1to4", "Phantom 1-4", "Switch Phantom Power on channels 1-4"); 
    45     if (m_Phantom1) addElement(m_Phantom1); 
    46      
    47     m_Phantom2 = new BinaryControl(*this, FR_SAFFIREPRO_CMD_ID_PHANTOM58, 
    48                  "Phantom_5to8", "Phantom 5-8", "Switch Phantom Power on channels 5-8"); 
    49     if (m_Phantom2) addElement(m_Phantom2); 
    50      
    51     m_Insert1 = new BinaryControl(*this, FR_SAFFIREPRO_CMD_ID_INSERT1, 
    52                 "Insert1", "Insert 1", "Switch Insert on Channel 1"); 
    53     if (m_Insert1) addElement(m_Insert1); 
    54      
    55     m_Insert2 = new BinaryControl(*this, FR_SAFFIREPRO_CMD_ID_INSERT2, 
    56                 "Insert2", "Insert 2", "Switch Insert on Channel 2"); 
    57     if (m_Insert2) addElement(m_Insert2); 
    58      
    59     m_AC3pass = new BinaryControl(*this, FR_SAFFIREPRO_CMD_ID_AC3_PASSTHROUGH, 
    60                 "AC3pass", "AC3 Passtrough", "Enable AC3 Passthrough"); 
    61     if (m_AC3pass) addElement(m_AC3pass); 
    62      
    63     m_MidiTru = new BinaryControl(*this, FR_SAFFIREPRO_CMD_ID_MIDI_TRU, 
    64                 "MidiTru", "Midi Tru", "Enable Midi Tru"); 
    65     if (m_MidiTru) addElement(m_MidiTru); 
     66    result &= m_MixerContainer->addElement( 
     67        new BinaryControl(*this, FR_SAFFIREPRO_CMD_ID_PHANTOM14, 0, 
     68                 "Phantom_1to4", "Phantom 1-4", "Switch Phantom Power on channels 1-4")); 
     69     
     70    result &= m_MixerContainer->addElement( 
     71        new BinaryControl(*this, FR_SAFFIREPRO_CMD_ID_PHANTOM58, 0, 
     72                 "Phantom_5to8", "Phantom 5-8", "Switch Phantom Power on channels 5-8")); 
     73     
     74    result &= m_MixerContainer->addElement( 
     75        new BinaryControl(*this, FR_SAFFIREPRO_CMD_ID_INSERT1, 0, 
     76                "Insert1", "Insert 1", "Switch Insert on Channel 1")); 
     77     
     78    result &= m_MixerContainer->addElement( 
     79        new BinaryControl(*this, FR_SAFFIREPRO_CMD_ID_INSERT2, 0, 
     80                "Insert2", "Insert 2", "Switch Insert on Channel 2")); 
     81     
     82    result &= m_MixerContainer->addElement( 
     83        new BinaryControl(*this, FR_SAFFIREPRO_CMD_ID_AC3_PASSTHROUGH, 0, 
     84                "AC3pass", "AC3 Passtrough", "Enable AC3 Passthrough")); 
     85     
     86    result &= m_MixerContainer->addElement( 
     87        new BinaryControl(*this, FR_SAFFIREPRO_CMD_ID_MIDI_TRU, 0, 
     88                "MidiTru", "Midi Tru", "Enable Midi Tru")); 
     89 
     90    // output mute controls 
     91    result &= m_MixerContainer->addElement( 
     92        new BinaryControl(*this,  
     93                FR_SAFFIREPRO_CMD_ID_BITFIELD_OUT12, FR_SAFFIREPRO_CMD_ID_BITFIELD_BIT_MUTE, 
     94                "Out12Mute", "Out1/2 Mute", "Output 1/2 Mute")); 
     95    result &= m_MixerContainer->addElement( 
     96        new BinaryControl(*this,  
     97                FR_SAFFIREPRO_CMD_ID_BITFIELD_OUT34, FR_SAFFIREPRO_CMD_ID_BITFIELD_BIT_MUTE, 
     98                "Out34Mute", "Out3/4 Mute", "Output 3/4 Mute")); 
     99    result &= m_MixerContainer->addElement( 
     100        new BinaryControl(*this,  
     101                FR_SAFFIREPRO_CMD_ID_BITFIELD_OUT56, FR_SAFFIREPRO_CMD_ID_BITFIELD_BIT_MUTE, 
     102                "Out56Mute", "Out5/6 Mute", "Output 5/6 Mute")); 
     103    result &= m_MixerContainer->addElement( 
     104        new BinaryControl(*this,  
     105                FR_SAFFIREPRO_CMD_ID_BITFIELD_OUT78, FR_SAFFIREPRO_CMD_ID_BITFIELD_BIT_MUTE, 
     106                "Out78Mute", "Out7/8 Mute", "Output 7/8 Mute")); 
     107 
     108    // output front panel hw volume control 
     109    result &= m_MixerContainer->addElement( 
     110        new BinaryControl(*this,  
     111                FR_SAFFIREPRO_CMD_ID_BITFIELD_OUT12, FR_SAFFIREPRO_CMD_ID_BITFIELD_BIT_HWCTRL, 
     112                "Out12HwCtrl", "Out1/2 HwCtrl", "Output 1/2 Front Panel Hardware volume control")); 
     113    result &= m_MixerContainer->addElement( 
     114        new BinaryControl(*this,  
     115                FR_SAFFIREPRO_CMD_ID_BITFIELD_OUT34, FR_SAFFIREPRO_CMD_ID_BITFIELD_BIT_HWCTRL, 
     116                "Out34HwCtrl", "Out3/4 HwCtrl", "Output 3/4 Front Panel Hardware volume control")); 
     117    result &= m_MixerContainer->addElement( 
     118        new BinaryControl(*this,  
     119                FR_SAFFIREPRO_CMD_ID_BITFIELD_OUT56, FR_SAFFIREPRO_CMD_ID_BITFIELD_BIT_HWCTRL, 
     120                "Out56HwCtrl", "Out5/6 HwCtrl", "Output 5/6 Front Panel Hardware volume control")); 
     121    result &= m_MixerContainer->addElement( 
     122        new BinaryControl(*this,  
     123                FR_SAFFIREPRO_CMD_ID_BITFIELD_OUT78, FR_SAFFIREPRO_CMD_ID_BITFIELD_BIT_HWCTRL, 
     124                "Out78HwCtrl", "Out7/8 HwCtrl", "Output 7/8 Front Panel Hardware volume control")); 
     125 
     126    // output active monitor padding 
     127    result &= m_MixerContainer->addElement( 
     128        new BinaryControl(*this,  
     129                FR_SAFFIREPRO_CMD_ID_BITFIELD_OUT12, FR_SAFFIREPRO_CMD_ID_BITFIELD_BIT_PAD, 
     130                "Out12Pad", "Out1/2 Pad", "Output 1/2 Active Monitor Pad")); 
     131    result &= m_MixerContainer->addElement( 
     132        new BinaryControl(*this,  
     133                FR_SAFFIREPRO_CMD_ID_BITFIELD_OUT34, FR_SAFFIREPRO_CMD_ID_BITFIELD_BIT_PAD, 
     134                "Out34Pad", "Out3/4 Pad", "Output 3/4 Active Monitor Pad")); 
     135    result &= m_MixerContainer->addElement( 
     136        new BinaryControl(*this,  
     137                FR_SAFFIREPRO_CMD_ID_BITFIELD_OUT56, FR_SAFFIREPRO_CMD_ID_BITFIELD_BIT_PAD, 
     138                "Out56Pad", "Out5/6 Pad", "Output 5/6 Active Monitor Pad")); 
     139    result &= m_MixerContainer->addElement( 
     140        new BinaryControl(*this,  
     141                FR_SAFFIREPRO_CMD_ID_BITFIELD_OUT78, FR_SAFFIREPRO_CMD_ID_BITFIELD_BIT_PAD, 
     142                "Out78Pad", "Out7/8 Pad", "Output 7/8 Active Monitor Pad")); 
     143 
     144    // output level dim 
     145    result &= m_MixerContainer->addElement( 
     146        new BinaryControl(*this,  
     147                FR_SAFFIREPRO_CMD_ID_BITFIELD_OUT12, FR_SAFFIREPRO_CMD_ID_BITFIELD_BIT_PAD, 
     148                "Out12Dim", "Out1/2 Dim", "Output 1/2 Level Dim")); 
     149    result &= m_MixerContainer->addElement( 
     150        new BinaryControl(*this,  
     151                FR_SAFFIREPRO_CMD_ID_BITFIELD_OUT34, FR_SAFFIREPRO_CMD_ID_BITFIELD_BIT_PAD, 
     152                "Out34Dim", "Out3/4 Dim", "Output 3/4 Level Dim")); 
     153    result &= m_MixerContainer->addElement( 
     154        new BinaryControl(*this,  
     155                FR_SAFFIREPRO_CMD_ID_BITFIELD_OUT56, FR_SAFFIREPRO_CMD_ID_BITFIELD_BIT_PAD, 
     156                "Out56Dim", "Out5/6 Dim", "Output 5/6 Level Dim")); 
     157    result &= m_MixerContainer->addElement( 
     158        new BinaryControl(*this,  
     159                FR_SAFFIREPRO_CMD_ID_BITFIELD_OUT78, FR_SAFFIREPRO_CMD_ID_BITFIELD_BIT_PAD, 
     160                "Out78Dim", "Out7/8 Dim", "Output 7/8 Level Dim")); 
     161 
     162    // indicators 
     163    result &= m_MixerContainer->addElement( 
     164        new BinaryControl(*this,  
     165                FR_SAFFIREPRO_CMD_ID_MUTE_INDICATOR, 0, 
     166                "Out12MuteInd", "Out1/2 Mute Ind", "Output 1/2 Mute Indicator")); 
     167 
     168    result &= m_MixerContainer->addElement( 
     169        new BinaryControl(*this,  
     170                FR_SAFFIREPRO_CMD_ID_DIM_INDICATOR, 0, 
     171                "Out12DimInd", "Out1/2 Dim Ind", "Output 1/2 Level Dim Indicator")); 
    66172 
    67173    // matrix mix controls 
    68     m_InputMixer=new SaffireProMatrixMixer(*this, SaffireProMatrixMixer::eMMT_InputMix, "InputMix"); 
    69     if (m_InputMixer) addElement(m_InputMixer); 
    70      
    71     m_OutputMixer=new SaffireProMatrixMixer(*this, SaffireProMatrixMixer::eMMT_OutputMix, "OutputMix"); 
    72     if (m_OutputMixer) addElement(m_OutputMixer); 
    73 
    74  
    75 SaffireProDevice::~SaffireProDevice() 
    76 
    77     // remove and delete control elements 
    78     deleteElement(m_Phantom1); 
    79     if (m_Phantom1) delete m_Phantom1; 
    80      
    81     deleteElement(m_Phantom2); 
    82     if (m_Phantom2) delete m_Phantom2; 
    83      
    84     deleteElement(m_Insert1); 
    85     if (m_Insert1) delete m_Insert1; 
    86      
    87     deleteElement(m_Insert2); 
    88     if (m_Insert2) delete m_Insert2; 
    89      
    90     deleteElement(m_AC3pass); 
    91     if (m_AC3pass) delete m_AC3pass; 
    92      
    93     deleteElement(m_MidiTru); 
    94     if (m_MidiTru) delete m_MidiTru; 
    95      
    96     deleteElement(m_InputMixer); 
    97     if (m_InputMixer) delete m_InputMixer; 
    98      
    99     deleteElement(m_OutputMixer); 
    100     if (m_OutputMixer) delete m_OutputMixer; 
     174    result &= m_MixerContainer->addElement( 
     175        new SaffireProMatrixMixer(*this, SaffireProMatrixMixer::eMMT_InputMix, "InputMix")); 
     176 
     177    result &= m_MixerContainer->addElement( 
     178        new SaffireProMatrixMixer(*this, SaffireProMatrixMixer::eMMT_OutputMix, "OutputMix")); 
     179 
     180    if (!result) { 
     181        debugWarning("One or more control elements could not be created."); 
     182        // clean up those that couldn't be created 
     183        destroyMixer(); 
     184        return false; 
     185    } 
     186 
     187    if (!addElement(m_MixerContainer)) { 
     188        debugWarning("Could not register mixer to device\n"); 
     189        // clean up 
     190        destroyMixer(); 
     191        return false; 
     192    } 
     193 
     194    return true; 
     195
     196 
     197bool 
     198SaffireProDevice::destroyMixer() 
     199
     200    debugOutput(DEBUG_LEVEL_VERBOSE, "destroy mixer...\n"); 
     201     
     202    if (m_MixerContainer == NULL) { 
     203        debugOutput(DEBUG_LEVEL_VERBOSE, "no mixer to destroy...\n"); 
     204        return true; 
     205    } 
     206     
     207    if (!deleteElement(m_MixerContainer)) { 
     208        debugError("Mixer present but not registered to the avdevice\n"); 
     209        return false; 
     210    } 
     211     
     212    // remove and delete (as in free) child control elements 
     213    m_MixerContainer->clearElements(true); 
     214    delete m_MixerContainer; 
     215    return true; 
    101216} 
    102217 
     
    113228    debugOutput( DEBUG_LEVEL_VERBOSE, "Setting verbose level to %d...\n", l ); 
    114229 
    115     if (m_Phantom1) m_Phantom2->setVerboseLevel(l); 
    116     if (m_Phantom2) m_Phantom2->setVerboseLevel(l); 
    117     if (m_Insert1) m_Insert1->setVerboseLevel(l); 
    118     if (m_Insert2) m_Insert2->setVerboseLevel(l); 
    119     if (m_MidiTru) m_MidiTru->setVerboseLevel(l); 
    120     if (m_AC3pass) m_AC3pass->setVerboseLevel(l); 
    121     if (m_InputMixer) m_InputMixer->setVerboseLevel(l); 
    122     if (m_OutputMixer) m_OutputMixer->setVerboseLevel(l); 
     230    if (m_MixerContainer) m_MixerContainer->setVerboseLevel(l); 
    123231 
    124232    // FIXME: add the other elements here too 
     
    192300             
    193301            int timeout=10; // multiples of 1s 
    194 //             while(timeout--) { 
    195 //                 // wait for a while 
    196 //                 usleep(1000 * 1000); 
    197 //                  
    198 //                 // we should figure out how long to wait before the device 
    199 //                 // becomes available again 
    200 //                  
    201 //                 // rediscover the device 
     302            while(timeout--) { 
     303                // wait for a while 
     304                usleep(1000 * 1000); 
     305                 
     306                // we should figure out how long to wait before the device 
     307                // becomes available again 
     308                 
     309                // check device status 
    202310//                 if (discover()) break; 
    203 //  
    204 //             } 
     311                if (timeout==5) break; 
     312            } 
    205313             
    206314            if(timeout) { 
     
    210318                            "setSampleRate (try %d): requested samplerate %d, device now has %d\n",  
    211319                            max_tries-ntries, s, verify ); 
    212                              
    213                 if (s == verify) break; 
     320 
     321                if (s == verify) { 
     322                    break; 
     323                } 
    214324            } 
    215325        } 
     
    220330        } 
    221331 
     332        // rediscover the device 
     333//         return discover(); 
    222334        return true; 
    223335    } 
     
    225337    return false; 
    226338 
     339} 
     340 
     341bool 
     342SaffireProDevice::isStreaming() { 
     343    uint32_t ready; 
     344    if ( !getSpecificValue(FR_SAFFIREPRO_CMD_ID_STREAMING, &ready ) ) { 
     345        debugError( "getSpecificValue failed\n" ); 
     346        return false; 
     347    } 
     348 
     349    debugOutput( DEBUG_LEVEL_NORMAL, 
     350                     "isDeviceReady: %d\n", ready!=0 ); 
     351    return ready != 0; 
    227352} 
    228353 
  • trunk/libffado/src/bebob/focusrite/focusrite_saffirepro.h

    r653 r661  
    2929#include "focusrite_generic.h" 
    3030 
     31#include "libcontrol/BasicElements.h" 
    3132#include "libcontrol/MatrixMixer.h" 
    3233 
     
    3637#define FR_SAFFIREPRO_CMD_ID_SAMPLERATE         84 
    3738#define FR_SAFFIREPRO_CMD_ID_SAMPLERATE_MIRROR  115 
     39 
     40#define FOCUSRITE_CMD_SAMPLERATE_44K1   1 
     41#define FOCUSRITE_CMD_SAMPLERATE_48K    2 
     42#define FOCUSRITE_CMD_SAMPLERATE_88K2   3 
     43#define FOCUSRITE_CMD_SAMPLERATE_96K    4 
     44#define FOCUSRITE_CMD_SAMPLERATE_176K4  5 
     45#define FOCUSRITE_CMD_SAMPLERATE_192K   6 
     46 
     47#define FR_SAFFIREPRO_CMD_ID_STREAMING          90 
    3848 
    3949#define FR_SAFFIREPRO_CMD_ID_PHANTOM14          98 
     
    4454#define FR_SAFFIREPRO_CMD_ID_MIDI_TRU           104 
    4555 
    46 #define FOCUSRITE_CMD_SAMPLERATE_44K1   1 
    47 #define FOCUSRITE_CMD_SAMPLERATE_48K    2 
    48 #define FOCUSRITE_CMD_SAMPLERATE_88K2   3 
    49 #define FOCUSRITE_CMD_SAMPLERATE_96K    4 
    50 #define FOCUSRITE_CMD_SAMPLERATE_176K4  5 
    51 #define FOCUSRITE_CMD_SAMPLERATE_192K   6 
     56#define FR_SAFFIREPRO_CMD_ID_DIM_INDICATOR      88 
     57#define FR_SAFFIREPRO_CMD_ID_MUTE_INDICATOR      88 
     58 
     59#define FR_SAFFIREPRO_CMD_ID_BITFIELD_OUT12      80 
     60#define FR_SAFFIREPRO_CMD_ID_BITFIELD_OUT34      81 
     61#define FR_SAFFIREPRO_CMD_ID_BITFIELD_OUT56      82 
     62#define FR_SAFFIREPRO_CMD_ID_BITFIELD_OUT78      83 
     63 
     64#define FR_SAFFIREPRO_CMD_ID_BITFIELD_BIT_MUTE      24 
     65#define FR_SAFFIREPRO_CMD_ID_BITFIELD_BIT_HWCTRL    26 
     66#define FR_SAFFIREPRO_CMD_ID_BITFIELD_BIT_PAD       27 
     67#define FR_SAFFIREPRO_CMD_ID_BITFIELD_BIT_DIM       28 
     68 
    5269 
    5370#define FR_SAFFIREPRO_CMD_ID_AN1_TO_IMIXL        0 
     
    210227    virtual int getSamplingFrequency( ); 
    211228 
     229    virtual bool buildMixer(); 
     230    virtual bool destroyMixer(); 
     231 
    212232private: 
    213233    virtual bool setSamplingFrequencyDo( int ); 
    214234    virtual int getSamplingFrequencyMirror( ); 
    215235 
    216     BinaryControl * m_Phantom1; 
    217     BinaryControl * m_Phantom2; 
    218      
    219     BinaryControl * m_Insert1; 
    220     BinaryControl * m_Insert2; 
    221     BinaryControl * m_AC3pass; 
    222     BinaryControl * m_MidiTru; 
    223      
    224     VolumeControl * m_Output12[4]; 
    225     VolumeControl * m_Output34[6]; 
    226     VolumeControl * m_Output56[6]; 
    227     VolumeControl * m_Output78[6]; 
    228     VolumeControl * m_Output910[6]; 
    229      
    230     SaffireProMatrixMixer * m_InputMixer; 
    231     SaffireProMatrixMixer * m_OutputMixer; 
     236    bool isStreaming(); 
     237 
     238    Control::Container *m_MixerContainer; 
    232239}; 
    233240 
  • trunk/libffado/src/devicemanager.cpp

    r639 r661  
    9292          ++it ) 
    9393    { 
     94        if (!deleteElement(*it)) { 
     95            debugWarning("failed to remove AvDevice from Control::Container\n"); 
     96        } 
    9497        delete *it; 
    9598    } 
  • trunk/libffado/src/ffadodevice.cpp

    r644 r661  
    4848    if (!addElement(&getConfigRom())) { 
    4949        debugWarning("failed to add ConfigRom to Control::Container\n"); 
     50    } 
     51} 
     52 
     53FFADODevice::~FFADODevice() 
     54{ 
     55    if (!deleteElement(&getConfigRom())) { 
     56        debugWarning("failed to remove ConfigRom from Control::Container\n"); 
    5057    } 
    5158} 
  • trunk/libffado/src/ffadodevice.h

    r639 r661  
    5656                 std::auto_ptr< ConfigRom >( configRom ) ); 
    5757 
    58     virtual ~FFADODevice() {}
     58    virtual ~FFADODevice()
    5959 
    6060     
  • trunk/libffado/src/libcontrol/Element.cpp

    r581 r661  
    8181Container::addElement(Element *e) 
    8282{ 
    83     assert(e); 
     83    if (e==NULL) { 
     84        debugWarning("Cannot add NULL element\n"); 
     85        return false; 
     86    } 
    8487 
    8588    debugOutput( DEBUG_LEVEL_VERBOSE, "Adding Element %s to %s\n", 
     
    123126} 
    124127 
     128bool 
     129Container::clearElements(bool delete_pointers)  
     130{ 
     131    while(m_Children.size()) { 
     132        Element *e=m_Children[0]; 
     133        deleteElement(e); 
     134        if (delete_pointers) delete e; 
     135    } 
     136    return true; 
     137} 
     138 
    125139void 
    126140Container::show() 
     
    137151} 
    138152 
     153void 
     154Container::setVerboseLevel(int l) 
     155{ 
     156    debugOutput( DEBUG_LEVEL_VERBOSE, "Setting verbose level to %d...\n", l ); 
     157    for ( ElementVectorIterator it = m_Children.begin(); 
     158      it != m_Children.end(); 
     159      ++it ) 
     160    { 
     161        (*it)->setVerboseLevel(l); 
     162    } 
     163} 
     164 
    139165} // namespace Control 
  • trunk/libffado/src/libcontrol/Element.h

    r581 r661  
    101101    virtual bool deleteElement(Element *e); 
    102102    virtual bool clearElements() 
    103         {m_Children.clear(); return true;}; 
     103        {return clearElements(false);}; 
     104    virtual bool clearElements(bool delete_pointers); 
    104105 
    105106    unsigned int countElements() 
     
    110111 
    111112    virtual void show(); 
     113    virtual void setVerboseLevel(int l); 
     114 
    112115protected: 
    113116    ElementVector m_Children;