Changeset 1158

Show
Ignore:
Timestamp:
05/10/08 12:38:38 (13 years ago)
Author:
ppalmers
Message:

make control more thread safe (unfinished)

Files:

Legend:

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

    r1156 r1158  
    5757 
    5858Mixer::Mixer(AvDevice &d) 
    59     : Control::Container(
     59    : Control::Container(&d
    6060    , m_device(d) 
    6161{ 
     
    197197 
    198198MixerFBFeature::MixerFBFeature(Mixer& parent, FunctionBlockFeature& s) 
    199 : Control::Continuous(
     199: Control::Continuous(&parent
    200200, m_Parent(parent)  
    201201, m_Slave(s) 
     
    248248 
    249249EnhancedMixerFBFeature::EnhancedMixerFBFeature(Mixer& parent, FunctionBlockEnhancedMixer& s) 
    250 : Control::Continuous(
     250: Control::Continuous(&parent
    251251, m_Parent(parent)  
    252252, m_Slave(s) 
     
    287287 
    288288MixerFBSelector::MixerFBSelector(Mixer& parent, FunctionBlockSelector& s) 
    289 : Control::Discrete(
     289: Control::Discrete(&parent
    290290, m_Parent(parent)  
    291291, m_Slave(s) 
  • trunk/libffado/src/bebob/bebob_mixer.h

    r973 r1158  
    7979    virtual bool setValue(int idx, double v); 
    8080    virtual double getValue(int idx); 
     81    virtual double getMinimum() {return 0.0;}; 
     82    virtual double getMaximum() {return 0.0;}; 
    8183 
    8284private: 
     
    9395    virtual bool setValue(double v); 
    9496    virtual double getValue(); 
     97    virtual bool setValue(int idx, double v) 
     98        {return setValue(v);}; 
     99    virtual double getValue(int idx) 
     100        {return getValue();}; 
     101 
     102    virtual double getMinimum() {return 0.0;}; 
     103    virtual double getMaximum() {return 0.0;}; 
    95104 
    96105private: 
     
    107116    virtual bool setValue(int v); 
    108117    virtual int getValue(); 
     118    virtual bool setValue(int idx, int v) 
     119        {return setValue(v);}; 
     120    virtual int getValue(int idx) 
     121        {return getValue();}; 
     122 
     123    virtual int getMinimum() {return 0;}; 
     124    virtual int getMaximum() {return 0;}; 
    109125 
    110126private: 
  • trunk/libffado/src/bebob/focusrite/focusrite_generic.cpp

    r1136 r1158  
    201201 
    202202BinaryControl::BinaryControl(FocusriteDevice& parent, int id, int bit) 
    203 : Control::Discrete(
     203: Control::Discrete(&parent
    204204, m_Parent(parent) 
    205205, m_cmd_id ( id ) 
     
    208208BinaryControl::BinaryControl(FocusriteDevice& parent, int id, int bit, 
    209209                std::string name, std::string label, std::string descr) 
    210 : Control::Discrete(
     210: Control::Discrete(&parent
    211211, m_Parent(parent) 
    212212, m_cmd_id ( id ) 
     
    263263 
    264264VolumeControl::VolumeControl(FocusriteDevice& parent, int id) 
    265 : Control::Discrete(
     265: Control::Discrete(&parent
    266266, m_Parent(parent) 
    267267, m_cmd_id ( id ) 
     
    269269VolumeControl::VolumeControl(FocusriteDevice& parent, int id, 
    270270                std::string name, std::string label, std::string descr) 
    271 : Control::Discrete(
     271: Control::Discrete(&parent
    272272, m_Parent(parent) 
    273273, m_cmd_id ( id ) 
     
    310310// reg control 
    311311RegisterControl::RegisterControl(FocusriteDevice& parent) 
    312 : Control::Register(
     312: Control::Register(&parent
    313313, m_Parent(parent) 
    314314{} 
    315315RegisterControl::RegisterControl(FocusriteDevice& parent, 
    316316                 std::string name, std::string label, std::string descr) 
    317 : Control::Register(
     317: Control::Register(&parent
    318318, m_Parent(parent) 
    319319{ 
     
    352352// low resolution volume control 
    353353VolumeControlLowRes::VolumeControlLowRes(FocusriteDevice& parent, int id, int shift) 
    354 : Control::Discrete(
     354: Control::Discrete(&parent
    355355, m_Parent(parent) 
    356356, m_cmd_id ( id ) 
     
    359359VolumeControlLowRes::VolumeControlLowRes(FocusriteDevice& parent, int id, int shift, 
    360360                std::string name, std::string label, std::string descr) 
    361 : Control::Discrete(
     361: Control::Discrete(&parent
    362362, m_Parent(parent) 
    363363, m_cmd_id ( id ) 
     
    415415// Saffire pro matrix mixer element 
    416416FocusriteMatrixMixer::FocusriteMatrixMixer(FocusriteDevice& p) 
    417 : Control::MatrixMixer("MatrixMixer") 
     417: Control::MatrixMixer(&p, "MatrixMixer") 
    418418, m_Parent(p) 
    419419{ 
     
    421421 
    422422FocusriteMatrixMixer::FocusriteMatrixMixer(FocusriteDevice& p,std::string n) 
    423 : Control::MatrixMixer(n) 
     423: Control::MatrixMixer(&p, n) 
    424424, m_Parent(p) 
    425425{ 
  • trunk/libffado/src/bebob/focusrite/focusrite_generic.h

    r965 r1158  
    4949    virtual bool setValue(int v); 
    5050    virtual int getValue(); 
    51      
     51    virtual bool setValue(int idx, int v) 
     52        {return setValue(v);}; 
     53    virtual int getValue(int idx) 
     54        {return getValue();}; 
     55 
     56    virtual int getMinimum() {return 0;}; 
     57    virtual int getMaximum() {return 1;}; 
     58 
    5259private: 
    5360    FocusriteDevice&        m_Parent; 
     
    6370    VolumeControl(FocusriteDevice& parent, int id, 
    6471                  std::string name, std::string label, std::string descr); 
    65      
     72 
    6673    virtual bool setValue(int v); 
    6774    virtual int getValue(); 
    68      
     75    virtual bool setValue(int idx, int v) 
     76        {return setValue(v);}; 
     77    virtual int getValue(int idx) 
     78        {return getValue();}; 
     79 
     80    virtual int getMinimum() {return 0;}; 
     81    virtual int getMaximum() {return 0x07FFF;}; 
     82 
    6983private: 
    7084    FocusriteDevice&        m_Parent; 
     
    97111    virtual bool setValue(int v); 
    98112    virtual int getValue(); 
    99      
     113    virtual bool setValue(int idx, int v) 
     114        {return setValue(v);}; 
     115    virtual int getValue(int idx) 
     116        {return getValue();}; 
     117 
     118    virtual int getMinimum() {return 0;}; 
     119    virtual int getMaximum() {return 0x0FF;}; 
    100120private: 
    101121    FocusriteDevice&        m_Parent; 
  • trunk/libffado/src/bebob/focusrite/focusrite_saffire.cpp

    r1072 r1158  
    5656 
    5757    // create the mixer object container 
    58     m_MixerContainer = new Control::Container("Mixer"); 
     58    m_MixerContainer = new Control::Container(this, "Mixer"); 
    5959 
    6060    if (!m_MixerContainer) { 
  • trunk/libffado/src/bebob/focusrite/focusrite_saffirepro.cpp

    r1136 r1158  
    6363     
    6464    // create the mixer object container 
    65     m_MixerContainer = new Control::Container("Mixer"); 
     65    m_MixerContainer = new Control::Container(this, "Mixer"); 
    6666 
    6767    if (!m_MixerContainer) { 
     
    226226 
    227227    // special controls 
    228     m_ControlContainer = new Control::Container("Control"); 
     228    m_ControlContainer = new Control::Container(this, "Control"); 
    229229    if (!m_ControlContainer) { 
    230230        debugError("Could not create mixer container...\n"); 
     
    307307        return false; 
    308308    } 
    309  
    310309 
    311310    return true; 
     
    791790// swiss army knife control element 
    792791SaffireProMultiControl::SaffireProMultiControl(SaffireProDevice& parent, enum eMultiControlType t) 
    793 : Control::Discrete(
     792: Control::Discrete(&parent
    794793, m_Parent(parent) 
    795794, m_type ( t ) 
     
    797796SaffireProMultiControl::SaffireProMultiControl(SaffireProDevice& parent, enum eMultiControlType t, 
    798797                std::string name, std::string label, std::string descr) 
    799 : Control::Discrete(
     798: Control::Discrete(&parent
    800799, m_Parent(parent) 
    801800, m_type ( t ) 
     
    843842 
    844843SaffireProDeviceNameControl::SaffireProDeviceNameControl(SaffireProDevice& parent) 
    845 : Control::Text(
     844: Control::Text(&parent
    846845, m_Parent(parent) 
    847846{} 
    848847SaffireProDeviceNameControl::SaffireProDeviceNameControl(SaffireProDevice& parent, 
    849848                std::string name, std::string label, std::string descr) 
    850 : Control::Text(
     849: Control::Text(&parent
    851850, m_Parent(parent) 
    852851{ 
  • trunk/libffado/src/bebob/focusrite/focusrite_saffirepro.h

    r1107 r1158  
    279279    virtual bool setValue(int v); 
    280280    virtual int getValue(); 
    281  
     281    virtual bool setValue(int idx, int v) 
     282        {return setValue(v);}; 
     283    virtual int getValue(int idx) 
     284        {return getValue();}; 
     285 
     286    virtual int getMinimum() {return 0;}; 
     287    virtual int getMaximum() {return 0;}; 
    282288private: 
    283289    SaffireProDevice&          m_Parent; 
  • trunk/libffado/src/devicemanager.cpp

    r1092 r1158  
    8181 
    8282DeviceManager::DeviceManager() 
    83     : Control::Container("devicemanager") 
     83    : Control::Container(NULL, "devicemanager") // this is the control root node 
    8484    , m_processorManager( new Streaming::StreamProcessorManager() ) 
    8585    , m_deviceStringParser( new DeviceStringParser() ) 
     
    251251        ( *func )(); 
    252252    } 
     253    // display the new state 
     254    showDeviceInfo(); 
    253255} 
    254256 
  • trunk/libffado/src/ffadodevice.cpp

    r1132 r1158  
    2424 
    2525#include "ffadodevice.h" 
     26#include "devicemanager.h" 
    2627 
    2728#include "libieee1394/configrom.h" 
     
    4041 
    4142FFADODevice::FFADODevice( DeviceManager& d, std::auto_ptr<ConfigRom>( configRom ) ) 
    42     : Control::Container(
     43    : Control::Container(&d
    4344    , m_pConfigRom( configRom ) 
    4445    , m_pDeviceManager( d ) 
     
    5354    } 
    5455 
    55     m_genericContainer = new Control::Container("Generic"); 
     56    m_genericContainer = new Control::Container(this, "Generic"); 
    5657    if(m_genericContainer == NULL) { 
    5758        debugError("Could not create Control::Container for generic controls\n"); 
  • trunk/libffado/src/fireworks/fireworks_control.cpp

    r864 r1158  
    3838 
    3939MonitorControl::MonitorControl(FireWorks::Device& p, enum eMonitorControl c) 
    40 : Control::MatrixMixer("MonitorControl") 
     40: Control::MatrixMixer(&p, "MonitorControl") 
    4141, m_control(c) 
    4242, m_Parent(p) 
     
    4545 
    4646MonitorControl::MonitorControl(FireWorks::Device& p, enum eMonitorControl c, std::string n) 
    47 : Control::MatrixMixer(n) 
     47: Control::MatrixMixer(&p, n) 
    4848, m_control(c) 
    4949, m_Parent(p) 
     
    241241                             enum eMixerCommand c, 
    242242                             int channel) 
    243 : Control::Continuous("SimpleControl") 
     243: Control::Continuous(&p, "SimpleControl") 
    244244, m_Slave(new EfcGenericMixerCmd(t, c, channel)) 
    245245, m_Parent(p) 
     
    252252                             int channel, 
    253253                             std::string n) 
    254 : Control::Continuous(n) 
     254: Control::Continuous(&p, n) 
    255255, m_Slave(new EfcGenericMixerCmd(t, c, channel)) 
    256256, m_Parent(p) 
     
    312312                             enum eMixerCommand c, 
    313313                             int channel, int bit) 
    314 : Control::Discrete("BinaryControl") 
     314: Control::Discrete(&p, "BinaryControl") 
    315315, m_bit(bit) 
    316316, m_Slave(new EfcGenericMixerCmd(t, c, channel)) 
     
    324324                             int channel, int bit, 
    325325                             std::string n) 
    326 : Control::Discrete(n) 
     326: Control::Discrete(&p, n) 
    327327, m_bit(bit) 
    328328, m_Slave(new EfcGenericMixerCmd(t, c, channel)) 
     
    398398IOConfigControl::IOConfigControl(FireWorks::Device& parent, 
    399399                                 enum eIOConfigRegister r) 
    400 : Control::Discrete("IOConfigControl") 
     400: Control::Discrete(&parent, "IOConfigControl") 
    401401, m_Slave(new EfcGenericIOConfigCmd(r)) 
    402402, m_Parent(parent) 
     
    407407                                 enum eIOConfigRegister r, 
    408408                                 std::string n) 
    409 : Control::Discrete(n) 
     409: Control::Discrete(&parent, n) 
    410410, m_Slave(new EfcGenericIOConfigCmd(r)) 
    411411, m_Parent(parent) 
  • trunk/libffado/src/fireworks/fireworks_control.h

    r864 r1158  
    9191    virtual bool setValue( const double ); 
    9292    virtual double getValue( ); 
     93    virtual bool setValue(int idx, double v) 
     94        {return setValue(v);}; 
     95    virtual double getValue(int idx) 
     96        {return getValue();}; 
     97 
     98    virtual double getMinimum() {return 0.0;}; 
     99    virtual double getMaximum() {return 0.0;}; 
    93100 
    94101protected: 
     
    115122    virtual bool setValue( const int ); 
    116123    virtual int getValue( ); 
     124    virtual bool setValue(int idx, int v) 
     125        {return setValue(v);}; 
     126    virtual int getValue(int idx) 
     127        {return getValue();}; 
    117128 
     129    virtual int getMinimum() {return 0;}; 
     130    virtual int getMaximum() {return 1;}; 
    118131protected: 
    119132    int                         m_bit; 
     
    139152    virtual bool setValue( const int ); 
    140153    virtual int getValue( ); 
     154    virtual bool setValue(int idx, int v) 
     155        {return setValue(v);}; 
     156    virtual int getValue(int idx) 
     157        {return getValue();}; 
     158 
     159    virtual int getMinimum() {return 0;}; 
     160    virtual int getMaximum() {return 0;}; 
    141161 
    142162protected: 
  • trunk/libffado/src/fireworks/fireworks_device.cpp

    r1133 r1158  
    200200     
    201201    // create the mixer object container 
    202     m_MixerContainer = new Control::Container("Mixer"); 
     202    m_MixerContainer = new Control::Container(this, "Mixer"); 
    203203 
    204204    if (!m_MixerContainer) { 
  • trunk/libffado/src/libavc/general/avc_plug.cpp

    r1154 r1158  
    648648    signalSourceCmd.setCommandType( AVCCommand::eCT_Control ); 
    649649    signalSourceCmd.setVerbose( getDebugLevel() ); 
     650    signalSourceCmd.setVerbose( DEBUG_LEVEL_VERY_VERBOSE ); 
    650651 
    651652    if ( !signalSourceCmd.fire() ) { 
  • trunk/libffado/src/libavc/general/avc_unit.cpp

    r1154 r1158  
    820820} 
    821821 
    822  
    823822void 
    824823Unit::show() 
  • trunk/libffado/src/libcontrol/BasicElements.cpp

    r998 r1158  
    2525 
    2626namespace Control { 
    27  
    28 Continuous::Continuous() 
    29 : Element() 
    30 , m_Value( 0.0 ) 
    31 
     27// no implementations 
    3228} 
    33  
    34 Continuous::Continuous(std::string n) 
    35 : Element(n) 
    36 , m_Value( 0.0 ) 
    37 { 
    38 } 
    39  
    40 void 
    41 Continuous::show() 
    42 { 
    43     debugOutput( DEBUG_LEVEL_NORMAL, "Continuous Element %s, value=%lf\n", 
    44         getName().c_str(), m_Value); 
    45 } 
    46  
    47 bool 
    48 Continuous::setValue(double v) 
    49 { 
    50     debugOutput( DEBUG_LEVEL_VERBOSE, "%s setValue(%lf)\n", 
    51         getName().c_str(), v); 
    52     m_Value=v; 
    53     return true; 
    54 } 
    55  
    56 double 
    57 Continuous::getValue() 
    58 { 
    59     debugOutput( DEBUG_LEVEL_VERBOSE, "%s getValue()=%lf\n", 
    60         getName().c_str(), m_Value); 
    61     return m_Value; 
    62 } 
    63  
    64 double 
    65 Continuous::getMinimum() 
    66 { 
    67     debugOutput( DEBUG_LEVEL_VERBOSE, "%s getMinimum()=%lf\n", 
    68         getName().c_str(), m_Value); 
    69     return m_Value; 
    70 } 
    71  
    72 double 
    73 Continuous::getMaximum() 
    74 { 
    75     debugOutput( DEBUG_LEVEL_VERBOSE, "%s getMaximum()=%lf\n", 
    76         getName().c_str(), m_Value); 
    77     return m_Value; 
    78 } 
    79  
    80 bool 
    81 Continuous::setValue(int idx, double v) 
    82 { 
    83     debugOutput( DEBUG_LEVEL_VERBOSE, "%s setValue(%d, %lf)\n", 
    84         getName().c_str(), idx, v); 
    85     return setValue(v); 
    86 } 
    87  
    88 double 
    89 Continuous::getValue(int idx) 
    90 { 
    91     double retval = getValue(); 
    92     debugOutput( DEBUG_LEVEL_VERBOSE, "%s getValue()=%lf\n", 
    93         getName().c_str(), retval); 
    94     return retval; 
    95 } 
    96  
    97 //// --- 
    98  
    99 Discrete::Discrete() 
    100 : Element() 
    101 , m_Value( 0 ) 
    102 { 
    103 } 
    104  
    105 Discrete::Discrete(std::string n) 
    106 : Element(n) 
    107 , m_Value( 0 ) 
    108 { 
    109 } 
    110  
    111 void 
    112 Discrete::show() 
    113 { 
    114     debugOutput( DEBUG_LEVEL_NORMAL, "Discrete Element %s, value=%d\n", 
    115         getName().c_str(), m_Value); 
    116 } 
    117  
    118 bool 
    119 Discrete::setValue(int v) 
    120 { 
    121     debugOutput( DEBUG_LEVEL_VERBOSE, "%s setValue(%d)\n", 
    122         getName().c_str(), v); 
    123     m_Value=v; 
    124     return true; 
    125 } 
    126  
    127 int 
    128 Discrete::getValue() 
    129 { 
    130     debugOutput( DEBUG_LEVEL_VERBOSE, "%s getValue()=%d\n", 
    131         getName().c_str(), m_Value); 
    132     return m_Value; 
    133 } 
    134 bool 
    135 Discrete::setValue(int idx, int v) 
    136 { 
    137     debugOutput( DEBUG_LEVEL_VERBOSE, "%s setValue(%d, %d)\n", 
    138         getName().c_str(), idx, v); 
    139     return setValue(v); 
    140 } 
    141  
    142 int 
    143 Discrete::getValue(int idx) 
    144 { 
    145     int retval = getValue(); 
    146     debugOutput( DEBUG_LEVEL_VERBOSE, "%s getValue()=%d\n", 
    147         getName().c_str(), retval); 
    148     return retval; 
    149 } 
    150  
    151 //// --- 
    152  
    153 Text::Text() 
    154 : Element() 
    155 , m_Value( "" ) 
    156 { 
    157 } 
    158  
    159 Text::Text(std::string n) 
    160 : Element(n) 
    161 , m_Value( "" ) 
    162 { 
    163 } 
    164  
    165 void 
    166 Text::show() 
    167 { 
    168     debugOutput( DEBUG_LEVEL_NORMAL, "Text Element %s, value=%s\n", 
    169                  getName().c_str(), m_Value.c_str()); 
    170 } 
    171  
    172 bool 
    173 Text::setValue(std::string v) 
    174 { 
    175     debugOutput( DEBUG_LEVEL_VERBOSE, "%s setValue(%s)\n", 
    176                  getName().c_str(), v.c_str()); 
    177     m_Value=v; 
    178     return true; 
    179 } 
    180  
    181 std::string 
    182 Text::getValue() 
    183 { 
    184     debugOutput( DEBUG_LEVEL_VERBOSE, "%s getValue()=%s\n", 
    185                  getName().c_str(), m_Value.c_str()); 
    186     return m_Value; 
    187 } 
    188  
    189 //// --- 
    190  
    191 Enum::Enum() 
    192 : Element() 
    193 , m_selected( -1 ) 
    194 { 
    195 } 
    196  
    197 Enum::Enum(std::string n) 
    198 : Element(n) 
    199 , m_selected( -1 ) 
    200 { 
    201 } 
    202  
    203 void 
    204 Enum::show() 
    205 { 
    206     debugOutput( DEBUG_LEVEL_NORMAL, "Enum Element %s, selected=%d\n", 
    207                  getName().c_str(), m_selected); 
    208 } 
    209  
    210 // NOTE: dummy implementation for tests 
    211 bool 
    212 Enum::select(int idx) 
    213 { 
    214     if(idx <3) { 
    215         m_selected=idx; 
    216         return true; 
    217     } else { 
    218         return false; 
    219     } 
    220 } 
    221  
    222 int 
    223 Enum::selected() 
    224 { 
    225     return m_selected; 
    226 } 
    227  
    228 int 
    229 Enum::count() 
    230 { 
    231     return 3; 
    232 } 
    233  
    234 std::string 
    235 Enum::getEnumLabel(int idx) 
    236 { 
    237     switch(idx) { 
    238         case 0: return "enum val 1"; 
    239         case 1: return "enum val 2"; 
    240         case 2: return "enum val 3"; 
    241         default: return "bad index"; 
    242     } 
    243 } 
    244  
    245  
    246 //// --- 
    247  
    248 AttributeEnum::AttributeEnum() 
    249 : Enum() 
    250 { 
    251 } 
    252  
    253 AttributeEnum::AttributeEnum(std::string n) 
    254 : Enum(n) 
    255 { 
    256 } 
    257  
    258 void 
    259 AttributeEnum::show() 
    260 { 
    261     debugOutput( DEBUG_LEVEL_NORMAL, "AttributeEnum Element %s\n", 
    262                  getName().c_str()); 
    263     Enum::show(); 
    264 } 
    265  
    266 // NOTE: dummy implementation for tests 
    267 int 
    268 AttributeEnum::attributeCount() 
    269 { 
    270     return 2; 
    271 } 
    272  
    273 std::string 
    274 AttributeEnum::getAttributeValue(int attridx) 
    275 { 
    276     switch(attridx) { 
    277         case 0: return "attr val 1"; 
    278         case 1: return "attr val 2"; 
    279         default: return "bad attr index"; 
    280     } 
    281 } 
    282  
    283 std::string 
    284 AttributeEnum::getAttributeName(int attridx) 
    285 { 
    286     switch(attridx) { 
    287         case 0: return "attr 1"; 
    288         case 1: return "attr 2"; 
    289         default: return "bad attr index"; 
    290     } 
    291 } 
    292  
    293 } // namespace Control 
  • trunk/libffado/src/libcontrol/BasicElements.h

    r998 r1158  
    4141{ 
    4242public: 
    43     Continuous()
    44     Continuous(std::string n)
     43    Continuous(Element *p) : Element(p) {}
     44    Continuous(Element *p, std::string n) : Element(p, n) {}
    4545    virtual ~Continuous() {}; 
    46      
    47     virtual bool setValue(double v); 
    48     virtual double getValue(); 
    49     virtual double getMinimum(); 
    50     virtual double getMaximum(); 
    51     virtual bool setValue(int idx, double v); 
    52     virtual double getValue(int idx); 
    5346 
    54     virtual void show(); 
     47    virtual bool setValue(double v) = 0; 
     48    virtual double getValue() = 0; 
     49    virtual bool setValue(int idx, double v) = 0; 
     50    virtual double getValue(int idx) = 0; 
    5551 
    56 private: 
    57     double m_Value
     52    virtual double getMinimum() = 0; 
     53    virtual double getMaximum() = 0
    5854}; 
    5955 
     
    6561{ 
    6662public: 
    67     Discrete()
    68     Discrete(std::string n)
     63    Discrete(Element *p) : Element(p) {}
     64    Discrete(Element *p, std::string n) : Element(p, n) {}
    6965    virtual ~Discrete() {}; 
    70      
    71     virtual bool setValue(int v); 
    72     virtual int getValue(); 
    73     virtual bool setValue(int idx, int v); 
    74     virtual int getValue(int idx); 
    7566 
    76     virtual void show(); 
     67    virtual bool setValue(int v) = 0; 
     68    virtual int getValue() = 0; 
     69    virtual bool setValue(int idx, int v) = 0; 
     70    virtual int getValue(int idx) = 0; 
    7771 
    78 private: 
    79     int m_Value; 
     72    virtual int getMinimum() = 0; 
     73    virtual int getMaximum() = 0; 
     74 
    8075}; 
    8176 
     
    8782{ 
    8883public: 
    89     Text()
    90     Text(std::string n)
     84    Text(Element *p) : Element(p) {}
     85    Text(Element *p, std::string n) : Element(p, n) {}
    9186    virtual ~Text() {}; 
    9287 
    93     virtual bool setValue(std::string v); 
    94     virtual std::string getValue(); 
    95  
    96     virtual void show(); 
    97  
    98 private: 
    99     std::string m_Value; 
     88    virtual bool setValue(std::string v) = 0; 
     89    virtual std::string getValue() = 0; 
    10090}; 
    10191 
     
    10797{ 
    10898public: 
    109     Register() : Element() {}; 
    110     Register(std::string n) : Element(n) {}; 
     99    Register(Element *p) : Element(p) {}; 
     100    Register(Element *p, std::string n) : Element(p, n) {}; 
    111101    virtual ~Register() {}; 
    112102 
    113103    virtual bool setValue(uint64_t addr, uint64_t value) = 0; 
    114104    virtual uint64_t getValue(uint64_t addr) = 0; 
    115 private: 
    116105}; 
    117106 
     
    123112{ 
    124113public: 
    125     Enum()
    126     Enum(std::string n)
     114    Enum(Element *p) : Element(p) {}
     115    Enum(Element *p, std::string n) : Element(p, n) {}
    127116    virtual ~Enum() {}; 
    128117 
    129     virtual bool select(int idx); 
    130     virtual int selected(); 
    131     virtual int count(); 
    132     virtual std::string getEnumLabel(int idx); 
    133  
    134     virtual void show(); 
    135 //private: // HACK 
    136     int m_selected; 
     118    virtual bool select(int idx) = 0; 
     119    virtual int selected() = 0; 
     120    virtual int count() = 0; 
     121    virtual std::string getEnumLabel(int idx) = 0; 
    137122}; 
    138123 
     
    159144{ 
    160145public: 
    161     AttributeEnum()
    162     AttributeEnum(std::string n)
     146    AttributeEnum(Element *p) : Enum(p) {}
     147    AttributeEnum(Element *p, std::string n) : Enum(p, n) {}
    163148    virtual ~AttributeEnum() {}; 
    164149 
    165     virtual int attributeCount()
     150    virtual int attributeCount() = 0
    166151    ///> get a specific attribute value for the selected enum  
    167     virtual std::string getAttributeValue(int attridx)
     152    virtual std::string getAttributeValue(int attridx) = 0
    168153    ///> get the name of the attribute with a certain index 
    169     virtual std::string getAttributeName(int attridx); 
    170  
    171     virtual void show(); 
    172 private: 
     154    virtual std::string getAttributeName(int attridx) = 0; 
    173155}; 
    174156 
  • trunk/libffado/src/libcontrol/ClockSelect.cpp

    r997 r1158  
    2929//// --- ClockSelect --- //// 
    3030ClockSelect::ClockSelect(FFADODevice &d) 
    31 : AttributeEnum(
     31: AttributeEnum(&d
    3232, m_Device( d ) 
    3333{ 
  • trunk/libffado/src/libcontrol/Element.cpp

    r864 r1158  
    2323 
    2424#include "Element.h" 
     25 
     26#include "libutil/PosixMutex.h" 
    2527 
    2628namespace Control { 
     
    3739static uint64_t GlobalElementCounter=0; 
    3840 
    39 Element::Element() 
    40 : m_Name ( "NoName" ) 
     41Element::Element(Element *parent) 
     42: m_element_lock ( NULL ) 
     43, m_parent( parent ) 
     44, m_Name ( "NoName" ) 
    4145, m_Label ( "No Label" ) 
    4246, m_Description ( "No Description" ) 
    4347, m_id(GlobalElementCounter++) 
    4448{ 
    45 
    46  
    47 Element::Element(std::string n) 
    48 : m_Name( n ) 
     49    // no parent, we are the root of an independent control tree 
     50    // this means we have to create a lock 
     51    if(parent == NULL) { 
     52        m_element_lock = new Util::PosixMutex(); 
     53    } 
     54
     55 
     56Element::Element(Element *parent, std::string n) 
     57: m_element_lock ( NULL ) 
     58, m_parent( parent ) 
     59, m_Name( n ) 
    4960, m_Label ( "No Label" ) 
    5061, m_Description ( "No Description" ) 
    5162, m_id(GlobalElementCounter++) 
    5263{ 
     64    // no parent, we are the root of an independent control tree 
     65    // this means we have to create a lock 
     66    if(parent == NULL) { 
     67        m_element_lock = new Util::PosixMutex(); 
     68    } 
     69} 
     70 
     71Element::~Element() 
     72{ 
     73    if(m_element_lock) delete m_element_lock; 
     74} 
     75 
     76void 
     77Element::lockControl() 
     78{ 
     79    getLock().Lock(); 
     80} 
     81 
     82void 
     83Element::unlockControl() 
     84{ 
     85    getLock().Unlock(); 
     86} 
     87 
     88Util::Mutex& 
     89Element::getLock() 
     90{ 
     91    assert(m_parent != NULL || m_element_lock != NULL); 
     92    if(m_parent) { 
     93        return m_parent->getLock(); 
     94    } else { 
     95        return *m_element_lock; 
     96    } 
    5397} 
    5498 
     
    64108{ 
    65109    setDebugLevel(l); 
     110    if(m_element_lock) m_element_lock->setVerboseLevel(l); 
     111    if(m_element_lock) m_element_lock->setVerboseLevel(DEBUG_LEVEL_VERY_VERBOSE); 
    66112    debugOutput( DEBUG_LEVEL_VERBOSE, "Setting verbose level to %d...\n", l ); 
    67113} 
    68114 
    69115//// --- Container --- //// 
    70 Container::Container() 
    71 : Element() 
    72 
    73 
    74  
    75 Container::Container(std::string n) 
    76 : Element(n) 
    77 
     116Container::Container(Element *p) 
     117: Element(p) 
     118
     119
     120 
     121Container::Container(Element *p, std::string n) 
     122: Element(p, n) 
     123
     124
     125 
     126unsigned int 
     127Container::countElements() 
     128
     129    lockControl(); 
     130    unsigned int s = m_Children.size(); 
     131    unlockControl(); 
     132    return s; 
     133
     134 
     135const ElementVector & 
     136Container::getElementVector() 
     137
     138    lockControl(); 
     139    return m_Children; 
     140
     141 
     142void 
     143Container::releaseElementVector() 
     144
     145    unlockControl(); 
    78146} 
    79147 
     
    81149Container::addElement(Element *e) 
    82150{ 
     151    Util::MutexLockHelper lock(getLock()); 
    83152    if (e==NULL) { 
    84153        debugWarning("Cannot add NULL element\n"); 
     
    108177Container::deleteElement(Element *e) 
    109178{ 
    110     assert(e); 
     179    Util::MutexLockHelper lock(getLock()); 
     180    if(e == NULL) return false; 
    111181    debugOutput( DEBUG_LEVEL_VERBOSE, "Deleting Element %s from %s\n", 
    112182        e->getName().c_str(), getName().c_str()); 
     
    129199Container::clearElements(bool delete_pointers)  
    130200{ 
     201    Util::MutexLockHelper lock(getLock()); 
    131202    while(m_Children.size()) { 
    132203        Element *e=m_Children[0]; 
     
    140211Container::show() 
    141212{ 
     213    Util::MutexLockHelper lock(getLock()); 
    142214    debugOutput( DEBUG_LEVEL_NORMAL, "Container %s (%d Elements)\n", 
    143215        getName().c_str(), m_Children.size()); 
     
    154226Container::setVerboseLevel(int l) 
    155227{ 
     228    Util::MutexLockHelper lock(getLock()); 
    156229    setDebugLevel(l); 
    157230    for ( ElementVectorIterator it = m_Children.begin(); 
  • trunk/libffado/src/libcontrol/Element.h

    r864 r1158  
    3030#include <string> 
    3131 
     32#include "libutil/Mutex.h" 
     33 
    3234namespace Control { 
    3335 
     
    4042{ 
    4143public: 
    42     Element(); 
    43     Element(std::string n); 
    44     virtual ~Element() {}
     44    Element(Element *); 
     45    Element(Element *, std::string n); 
     46    virtual ~Element()
    4547 
    4648    virtual std::string getName() {return m_Name;}; 
     
    5860    uint64_t getId() 
    5961        {return m_id;}; 
    60      
     62 
     63    // these allow to prevent external access to the control elements 
     64    // e.g. when the config tree is rebuilt 
     65    virtual void lockControl(); 
     66    virtual void unlockControl(); 
     67 
    6168    virtual void show(); 
    6269 
     
    6572     */ 
    6673    virtual void setVerboseLevel(int l); 
     74    virtual int getVerboseLevel() {return getDebugLevel();}; 
     75 
     76protected: 
     77    Util::Mutex&    getLock(); 
    6778 
    6879private: 
     80    Util::Mutex*    m_element_lock; 
     81    Element*        m_parent; 
    6982    std::string m_Name; 
    7083    std::string m_Label; 
     
    94107{ 
    95108public: 
    96     Container(); 
    97     Container(std::string n); 
     109    Container(Element *); 
     110    Container(Element *, std::string n); 
    98111    virtual ~Container() {}; 
    99112     
     
    104117    virtual bool clearElements(bool delete_pointers); 
    105118 
    106     unsigned int countElements() 
    107         {return m_Children.size();}; 
     119    unsigned int countElements(); 
    108120 
    109     const ElementVector & getElements() 
    110         {return m_Children;}; 
     121 
     122    /** 
     123     * Returns and locks the element vector. No changes will be made to the vector 
     124     * until releaseElementVector is called. 
     125     * @return  
     126     */ 
     127    const ElementVector & getElementVector(); 
     128 
     129    /** 
     130     * Releases the lock on the element vector. 
     131     */ 
     132    void releaseElementVector(); 
    111133 
    112134    virtual void show(); 
  • trunk/libffado/src/libcontrol/MatrixMixer.cpp

    r864 r1158  
    2525 
    2626namespace Control { 
    27  
    28 //// --- MatrixMixer --- //// 
    29 MatrixMixer::MatrixMixer() 
    30 : Element() 
    31 
    32 
    33  
    34 MatrixMixer::MatrixMixer(std::string n) 
    35 : Element(n) 
    36 
    37 
    38  
     27// no implementation 
    3928} // namespace Control 
  • trunk/libffado/src/libcontrol/MatrixMixer.h

    r864 r1158  
    4141{ 
    4242public: 
    43     MatrixMixer()
    44     MatrixMixer(std::string n)
     43    MatrixMixer(Element *p) : Element(p) {}
     44    MatrixMixer(Element *p, std::string n) : Element(p, n) {}
    4545    virtual ~MatrixMixer() {}; 
    4646 
  • trunk/libffado/src/libcontrol/Nickname.cpp

    r1063 r1158  
    2929//// --- Nickname --- //// 
    3030Nickname::Nickname(FFADODevice &d) 
    31 : Text(
     31: Text(&d
    3232, m_Device( d ) 
    3333{ 
  • trunk/libffado/src/libieee1394/configrom.cpp

    r1154 r1158  
    6363 
    6464ConfigRom::ConfigRom( Ieee1394Service& ieee1394service, fb_nodeid_t nodeId ) 
    65     : Control::Element("ConfigRom") 
     65    : Control::Element(NULL, "ConfigRom") 
    6666    , m_1394Service( ieee1394service ) 
    6767    , m_nodeId( nodeId ) 
     
    9090 
    9191ConfigRom::ConfigRom() 
    92     : Control::Element("ConfigRom") 
     92    : Control::Element(NULL, "ConfigRom") 
    9393    , m_1394Service( *(new Ieee1394Service()) ) 
    9494    , m_nodeId( -1 ) 
  • trunk/libffado/src/motu/motu_avdevice.cpp

    r1141 r1158  
    349349         
    350350    // create the mixer object container 
    351     m_MixerContainer = new Control::Container("Mixer"); 
     351    m_MixerContainer = new Control::Container(this, "Mixer"); 
    352352    if (!m_MixerContainer) { 
    353353        debugError("Could not create mixer container...\n"); 
     
    524524 
    525525    // Special controls 
    526     m_ControlContainer = new Control::Container("Control"); 
     526    m_ControlContainer = new Control::Container(this, "Control"); 
    527527    if (!m_ControlContainer) { 
    528528        debugError("Could not create control container...\n"); 
  • trunk/libffado/src/motu/motu_controls.cpp

    r1064 r1158  
    2929 
    3030MotuDiscreteCtrl::MotuDiscreteCtrl(MotuDevice &parent, unsigned int dev_reg) 
    31 : Control::Discrete(
     31: Control::Discrete(&parent
    3232, m_parent(parent) 
    3333, m_register(dev_reg) 
     
    3737MotuDiscreteCtrl::MotuDiscreteCtrl(MotuDevice &parent, unsigned int dev_reg, 
    3838             std::string name, std::string label, std::string descr) 
    39 : Control::Discrete(
     39: Control::Discrete(&parent
    4040, m_parent(parent) 
    4141, m_register(dev_reg) 
  • trunk/libffado/src/motu/motu_controls.h

    r1064 r1158  
    9191          std::string name, std::string label, std::string descr); 
    9292 
     93    virtual bool setValue(int v) = 0; 
     94    virtual int getValue() = 0; 
     95 
     96    // default implementations 
     97    virtual bool setValue(int idx, int v) 
     98        {return setValue(v);}; 
     99    virtual int getValue(int idx) 
     100        {return getValue();}; 
     101 
     102    virtual int getMinimum() {return 0;}; 
     103    virtual int getMaximum() {return 0;}; 
     104 
    93105protected: 
    94106    MotuDevice    &m_parent; 
  • trunk/libffado/support/dbus/controlserver.cpp

    r998 r1158  
    3030namespace DBusControl { 
    3131 
    32 IMPL_DEBUG_MODULE( Element, Element, DEBUG_LEVEL_VERBOSE ); 
     32IMPL_DEBUG_MODULE( Element, Element, DEBUG_LEVEL_NORMAL ); 
    3333 
    3434// --- Element 
     
    3939    debugOutput( DEBUG_LEVEL_VERBOSE, "Created Element on '%s'\n", 
    4040                 path().c_str() ); 
     41    setVerboseLevel(m_Slave.getVerboseLevel()); 
    4142} 
    4243 
     
    7475 
    7576    // add children for the slave container 
    76     for ( Control::ConstElementVectorIterator it = slave.getElements().begin(); 
    77       it != slave.getElements().end(); 
     77    const Control::ElementVector elements = slave.getElementVector(); 
     78    for ( Control::ConstElementVectorIterator it = elements.begin(); 
     79      it != elements.end(); 
    7880      ++it ) 
    7981    { 
     
    8688        } 
    8789    } 
     90    slave.releaseElementVector(); 
    8891} 
    8992 
     
    106109    int nbElements=m_Slave.countElements(); 
    107110    if (i<nbElements) { 
    108         return m_Slave.getElements().at(i)->getName(); 
     111        const Control::ElementVector elements = m_Slave.getElementVector(); 
     112        Control::Element *e = elements.at(i); 
     113        std::string name; 
     114        if(e) name = e->getName(); 
     115        m_Slave.releaseElementVector(); 
     116        return name; 
    109117    } else return ""; 
    110118} 
  • trunk/libffado/support/dbus/controlserver.h

    r998 r1158  
    5656    DBus::String getDescription( ); 
    5757 
     58    void setVerboseLevel(int i) {setDebugLevel(i);}; 
    5859private: 
    5960    Control::Element &m_Slave; 
  • trunk/libffado/support/dbus/ffado-dbus-server.cpp

    r962 r1158  
    123123    char* tail; 
    124124 
     125    errno = 0; 
    125126    switch (key) { 
    126127    case 'q': case 's': 
     
    205206busresetHandler() 
    206207{ 
     208    // this is a race condition: the control tree becomes invalid since we 
     209    // are redetecting the devices, but the dispatcher still allows access. 
     210    // at this point. This has to be split up in two. 
    207211    debugOutput( DEBUG_LEVEL_NORMAL, "notified of bus reset...\n" ); 
    208212    dispatcher.leave(); 
  • trunk/libffado/support/dbus/test-dbus-server.cpp

    r958 r1158  
    108108    conn.request_name(SERVER_NAME); 
    109109     
    110     Control::Continuous c0("test0"); 
    111     c0.setVerboseLevel(DEBUG_LEVEL_VERBOSE); 
    112     DBusControl::Continuous fader(conn, "/org/ffado/Control/Test/Fader", c0); 
    113  
    114     Control::Container cont("container1"); 
     110//     Control::Continuous c0("test0"); 
     111//     c0.setVerboseLevel(DEBUG_LEVEL_VERBOSE); 
     112//     DBusControl::Continuous fader(conn, "/org/ffado/Control/Test/Fader", c0); 
     113//  
     114    Control::Container cont(NULL, "container1"); 
    115115    cont.setVerboseLevel(DEBUG_LEVEL_VERBOSE); 
    116      
    117     Control::Container cont1("container2"); 
    118     cont1.setVerboseLevel(DEBUG_LEVEL_VERBOSE); 
    119      
    120     cont.addElement(&cont1); 
    121  
    122     Control::Continuous c1("test1"); 
    123     c1.setVerboseLevel(DEBUG_LEVEL_VERBOSE); 
    124     cont.addElement(&c1); 
    125      
    126     Control::Continuous c2("test2"); 
    127     c2.setVerboseLevel(DEBUG_LEVEL_VERBOSE); 
    128     cont.addElement(&c2); 
    129      
    130     Control::Continuous c3("test3"); 
    131     c3.setVerboseLevel(DEBUG_LEVEL_VERBOSE); 
    132     cont.addElement(&c3); 
    133  
    134     Control::Continuous c4("test4"); 
    135     c4.setVerboseLevel(DEBUG_LEVEL_VERBOSE); 
    136     cont1.addElement(&c4); 
    137  
    138     Control::Continuous c5("test5"); 
    139     c5.setVerboseLevel(DEBUG_LEVEL_VERBOSE); 
    140     cont1.addElement(&c5); 
    141      
    142     Control::Discrete d1("test_discr1"); 
    143     d1.setVerboseLevel(DEBUG_LEVEL_VERBOSE); 
    144     cont1.addElement(&d1); 
    145      
    146     Control::Enum e1("test_enum"); 
    147     e1.setVerboseLevel(DEBUG_LEVEL_VERBOSE); 
    148     cont1.addElement(&e1); 
    149  
    150     Control::AttributeEnum a1("test_attrenum"); 
    151     a1.setVerboseLevel(DEBUG_LEVEL_VERBOSE); 
    152     cont1.addElement(&a1); 
    153      
    154     Control::Text t1("test_text"); 
    155     t1.setVerboseLevel(DEBUG_LEVEL_VERBOSE); 
    156     cont1.addElement(&t1); 
     116//      
     117//     Control::Container cont1("container2"); 
     118//     cont1.setVerboseLevel(DEBUG_LEVEL_VERBOSE); 
     119//      
     120//     cont.addElement(&cont1); 
     121//  
     122//     Control::Continuous c1("test1"); 
     123//     c1.setVerboseLevel(DEBUG_LEVEL_VERBOSE); 
     124//     cont.addElement(&c1); 
     125//      
     126//     Control::Continuous c2("test2"); 
     127//     c2.setVerboseLevel(DEBUG_LEVEL_VERBOSE); 
     128//     cont.addElement(&c2); 
     129//      
     130//     Control::Continuous c3("test3"); 
     131//     c3.setVerboseLevel(DEBUG_LEVEL_VERBOSE); 
     132//     cont.addElement(&c3); 
     133//  
     134//     Control::Continuous c4("test4"); 
     135//     c4.setVerboseLevel(DEBUG_LEVEL_VERBOSE); 
     136//     cont1.addElement(&c4); 
     137//  
     138//     Control::Continuous c5("test5"); 
     139//     c5.setVerboseLevel(DEBUG_LEVEL_VERBOSE); 
     140//     cont1.addElement(&c5); 
     141//      
     142//     Control::Discrete d1("test_discr1"); 
     143//     d1.setVerboseLevel(DEBUG_LEVEL_VERBOSE); 
     144//     cont1.addElement(&d1); 
     145//      
     146//     Control::Enum e1("test_enum"); 
     147//     e1.setVerboseLevel(DEBUG_LEVEL_VERBOSE); 
     148//     cont1.addElement(&e1); 
     149//  
     150//     Control::AttributeEnum a1("test_attrenum"); 
     151//     a1.setVerboseLevel(DEBUG_LEVEL_VERBOSE); 
     152//     cont1.addElement(&a1); 
     153//      
     154//     Control::Text t1("test_text"); 
     155//     t1.setVerboseLevel(DEBUG_LEVEL_VERBOSE); 
     156//     cont1.addElement(&t1); 
    157157 
    158158    // Note: create handlers AFTER all children are added