Changeset 426

Show
Ignore:
Timestamp:
02/28/07 05:15:40 (14 years ago)
Author:
pieterpalmers
Message:

- changed the IAvDevice from an interface to a base class,

since there is some code duplication starting to
appear.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • branches/streaming-rework/src/bebob/bebob_avdevice.cpp

    r424 r426  
    3939namespace BeBoB { 
    4040 
    41 IMPL_DEBUG_MODULE( AvDevice, AvDevice, DEBUG_LEVEL_NORMAL ); 
    42  
    4341static VendorModelEntry supportedDeviceList[] = 
    4442{ 
     
    6462}; 
    6563 
    66  
    6764AvDevice::AvDevice( std::auto_ptr< ConfigRom >( configRom ), 
    6865                    Ieee1394Service& ieee1394service, 
    69                     int nodeId, 
    70                     int verboseLevel ) 
    71     : m_pConfigRom( configRom ) 
    72     , m_p1394Service( &ieee1394service ) 
    73     , m_verboseLevel( verboseLevel ) 
    74     , m_pPlugManager( new AvPlugManager( verboseLevel ) ) 
     66                    int nodeId ) 
     67    : IAvDevice( configRom, ieee1394service, nodeId ) 
     68    , m_pPlugManager( new AvPlugManager( DEBUG_LEVEL_NORMAL ) ) 
    7569    , m_activeSyncInfo( 0 ) 
    7670    , m_model ( NULL ) 
    77     , m_nodeId ( nodeId ) 
    78 
    79     setDebugLevel( verboseLevel ); 
     71
    8072    debugOutput( DEBUG_LEVEL_VERBOSE, "Created BeBoB::AvDevice (NodeID %d)\n", 
    8173                 nodeId ); 
    8274    addOption(Util::OptionContainer::Option("snoopMode",false)); 
    83     addOption(Util::OptionContainer::Option("id",std::string("dev?"))); 
    84 } 
    85  
    86 AvDevice::AvDevice() 
    87     : m_pConfigRom( 0 ) 
    88     , m_p1394Service( 0 ) 
    89     , m_verboseLevel( 0 ) 
    90     , m_pPlugManager( 0 ) 
    91     , m_activeSyncInfo( 0 ) 
    92     , m_model ( NULL ) 
    93     , m_nodeId ( -1 ) 
    94 { 
    95     addOption(Util::OptionContainer::Option("snoopMode",false)); 
    96     addOption(Util::OptionContainer::Option("id",std::string("dev?"))); 
    9775} 
    9876 
     
    126104} 
    127105 
    128 ConfigRom& 
    129 AvDevice::getConfigRom() const 
    130 
    131     return *m_pConfigRom; 
     106void 
     107AvDevice::setVerboseLevel(int l)  
     108
     109//     m_pPlugManager->setVerboseLevel(l); 
     110     
     111    IAvDevice::setVerboseLevel(l); 
    132112} 
    133113 
     
    954934{ 
    955935    return syncInfo.m_source->setConnection( *syncInfo.m_destination ); 
    956 } 
    957  
    958 bool AvDevice::setId( unsigned int id) 
    959 { 
    960     // FIXME: decent ID system nescessary 
    961     std::ostringstream idstr; 
    962  
    963     idstr << "dev" << id; 
    964      
    965     debugOutput( DEBUG_LEVEL_VERBOSE, "Set id to %s...\n", idstr.str().c_str()); 
    966      
    967     return setOption("id",idstr.str()); 
    968936} 
    969937 
     
    14801448                       Ieee1394Service& ieee1394Service ) 
    14811449{ 
    1482     AvDevice* pDev = new AvDevice; 
     1450 
     1451    ConfigRom *configRom = 
     1452        ConfigRom::deserialize( basePath + "m_pConfigRom/", deser, ieee1394Service ); 
     1453         
     1454    if ( !configRom ) { 
     1455        return NULL; 
     1456    } 
     1457 
     1458    AvDevice* pDev = new AvDevice( 
     1459        std::auto_ptr<ConfigRom>(configRom),  
     1460        ieee1394Service, configRom->getNodeId()); 
    14831461 
    14841462    if ( pDev ) { 
    1485         pDev->m_pConfigRom = std::auto_ptr<ConfigRom> ( 
    1486             ConfigRom::deserialize( basePath + "m_pConfigRom/", deser, ieee1394Service ) 
    1487             ); 
    1488         if ( !pDev->m_pConfigRom.get() ) { 
    1489             delete pDev; 
    1490             return 0; 
    1491         } 
    1492  
    1493         pDev->m_p1394Service = &ieee1394Service; 
    14941463        bool result; 
    14951464        result  = deser.read( basePath + "m_verboseLevel", pDev->m_verboseLevel ); 
     1465         
     1466        if (pDev->m_pPlugManager) delete pDev->m_pPlugManager; 
    14961467        pDev->m_pPlugManager = AvPlugManager::deserialize( basePath + "AvPlug", deser, *pDev ); 
    14971468        if ( !pDev->m_pPlugManager ) { 
     
    15151486         
    15161487        result &= deserializeOptions( basePath + "Options", deser, *pDev ); 
    1517  
    15181488    } 
    15191489 
  • branches/streaming-rework/src/bebob/bebob_avdevice.h

    r420 r426  
    5959    AvDevice( std::auto_ptr<ConfigRom>( configRom ), 
    6060              Ieee1394Service& ieee1394Service, 
    61               int nodeId, 
    62               int verboseLevel ); 
     61              int nodeId ); 
    6362    virtual ~AvDevice(); 
     63     
     64    void setVerboseLevel(int l); 
    6465 
    6566    static bool probe( ConfigRom& configRom ); 
    6667    virtual bool discover(); 
    67     virtual ConfigRom& getConfigRom() const; 
    6868 
    6969    virtual bool setSamplingFrequency( ESamplingFrequency samplingFrequency ); 
     
    8080    bool stopStreamByIndex(int i); 
    8181 
    82     virtual bool addXmlDescription( xmlNodePtr deviceNode ); 
    8382    virtual void showDevice() const; 
    84     virtual bool setId(unsigned int id); 
    8583 
    8684    Ieee1394Service& get1394Service() 
     
    119117                                  Util::IODeserialize& deser, 
    120118                                  Ieee1394Service& ieee1394Service ); 
    121  
    122119protected: 
    123     AvDevice(); 
    124120 
    125121    bool enumerateSubUnits(); 
     
    170166                                           SyncInfoVector& vec ); 
    171167protected: 
    172     std::auto_ptr<ConfigRom>( m_pConfigRom ); 
    173     Ieee1394Service*          m_p1394Service; 
    174     int                       m_verboseLevel; 
    175168    AvPlugVector              m_pcrPlugs; 
    176169    AvPlugVector              m_externalPlugs; 
     
    181174    SyncInfo*                 m_activeSyncInfo; 
    182175    struct VendorModelEntry*  m_model; 
    183     int                       m_nodeId; 
    184176 
    185177    // streaming stuff 
     
    187179    StreamProcessorVector m_receiveProcessors; 
    188180    StreamProcessorVector m_transmitProcessors; 
    189  
    190     DECLARE_DEBUG_MODULE; 
    191181}; 
    192182 
  • branches/streaming-rework/src/bebob/bebob_avdevice_xml.cpp

    r413 r426  
    2727namespace BeBoB { 
    2828 
    29 bool 
    30 AvDevice::addXmlDescription( xmlNodePtr deviceNode ) 
    31 { 
    32     // connection set 
    33     //  direction 
    34     //  connection 
    35     //    id 
    36     //    port 
    37     //    node 
    38     //    plug 
    39     //    dimension 
    40     //    samplerate 
    41     //    streams 
    42     //      stream 
    43  
    44  
    45     /////////// 
    46     // get plugs 
    47  
    48     AvPlug* inputPlug = getPlugById( m_pcrPlugs, AvPlug::eAPD_Input, 0 ); 
    49     if ( !inputPlug ) { 
    50         debugError( "addXmlDescription: No iso input plug found with id 0\n" ); 
    51         return false; 
    52     } 
    53     AvPlug* outputPlug = getPlugById( m_pcrPlugs, AvPlug::eAPD_Output, 0 ); 
    54     if ( !outputPlug ) { 
    55         debugError( "addXmlDescription: No iso output plug found with id 0\n" ); 
    56         return false; 
    57     } 
    58  
    59     /////////// 
    60     // add connection set output 
    61  
    62     xmlNodePtr connectionSet = xmlNewChild( deviceNode, 0, 
    63                                             BAD_CAST "ConnectionSet", 0 ); 
    64     if ( !connectionSet ) { 
    65         debugError( "addXmlDescription:: Could not create 'ConnnectionSet' node for " 
    66                     "direction 1 (playback)\n" ); 
    67         return false; 
    68     } 
    69  
    70     if ( !inputPlug->addXmlDescription( connectionSet ) ) { 
    71         debugError( "addXmlDescription: Could not add iso input plug 0 to XML description\n" ); 
    72         return false; 
    73     } 
    74  
    75     // add connection set input 
    76  
    77     connectionSet = xmlNewChild( deviceNode, 0, 
    78                                  BAD_CAST "ConnectionSet", 0 ); 
    79     if ( !connectionSet ) { 
    80         debugError( "addXmlDescription: Couldn't create 'ConnectionSet' node for " 
    81                     "direction 0 (recorder)\n" ); 
    82         return false; 
    83     } 
    84  
    85     if ( !outputPlug->addXmlDescription( connectionSet ) ) { 
    86         debugError( "addXmlDescription: Could not add iso output plug 0 to XML description\n" ); 
    87         return false; 
    88     } 
    89  
    90     //////////// 
    91     // add stream format 
    92  
    93     xmlNodePtr streamFormatNode = xmlNewChild( deviceNode, 0, 
    94                                                BAD_CAST "StreamFormats", 0 ); 
    95     if ( !streamFormatNode ) { 
    96         debugError( "addXmlDescription: Could not create 'StreamFormats' node\n" ); 
    97         return false; 
    98     } 
    99  
    100     if ( !inputPlug->addXmlDescriptionStreamFormats( streamFormatNode ) ) { 
    101         debugError( "addXmlDescription:: Could not add stream format info\n" ); 
    102         return false; 
    103     } 
    104  
    105     streamFormatNode= xmlNewChild( deviceNode, 0, 
    106                                  BAD_CAST "StreamFormats", 0 ); 
    107     if ( !streamFormatNode ) { 
    108         debugError( "addXmlDescription: Could not create 'StreamFormat' node\n" ); 
    109         return false; 
    110     } 
    111  
    112     if ( !outputPlug->addXmlDescriptionStreamFormats( streamFormatNode ) ) { 
    113         debugError( "addXmlDescription:: Could not add stream format info\n" ); 
    114         return false; 
    115     } 
    116  
    117     return true; 
    118 } 
    11929 
    12030} 
  • branches/streaming-rework/src/bounce/bounce_avdevice.cpp

    r424 r426  
    4848}; 
    4949 
    50 IMPL_DEBUG_MODULE( BounceDevice, BounceDevice, DEBUG_LEVEL_VERBOSE ); 
    51  
    52  
    5350BounceDevice::BounceDevice( std::auto_ptr< ConfigRom >( configRom ), 
    5451                            Ieee1394Service& ieee1394service, 
    55                             int nodeId, 
    56                             int verboseLevel ) 
    57     : m_configRom( configRom ) 
    58     , m_p1394Service( &ieee1394service ) 
    59     , m_nodeId( nodeId ) 
    60 //     , m_verboseLevel( verboseLevel ) 
    61     , m_verboseLevel( DEBUG_LEVEL_VERBOSE ) 
     52                            int nodeId ) 
     53    : IAvDevice( configRom, ieee1394service, nodeId ) 
    6254    , m_samplerate (44100) 
    6355    , m_model( NULL ) 
    6456    , m_Notifier ( NULL ) 
    6557{ 
    66     setDebugLevel( verboseLevel ); 
    67  
    6858    debugOutput( DEBUG_LEVEL_VERBOSE, "Created Bounce::BounceDevice (NodeID %d)\n", 
    6959                 nodeId ); 
    7060    addOption(Util::OptionContainer::Option("snoopMode",false)); 
    71     addOption(Util::OptionContainer::Option("id",std::string("dev?"))); 
    7261} 
    7362 
     
    7564{ 
    7665 
    77 } 
    78  
    79 ConfigRom& 
    80 BounceDevice::getConfigRom() const 
    81 { 
    82     return *m_configRom; 
    8366} 
    8467 
     
    11699                 m_nodeId ); 
    117100                  
    118 //     unsigned int vendorId = m_configRom->getNodeVendorId(); 
    119     unsigned int modelId = m_configRom->getModelId(); 
    120     unsigned int unitSpecifierId = m_configRom->getUnitSpecifierId(); 
     101//     unsigned int vendorId = m_pConfigRom->getNodeVendorId(); 
     102    unsigned int modelId = m_pConfigRom->getModelId(); 
     103    unsigned int unitSpecifierId = m_pConfigRom->getUnitSpecifierId(); 
    121104 
    122105    for ( unsigned int i = 0; 
     
    153136} 
    154137 
    155 bool BounceDevice::setId( unsigned int id) { 
    156     // FIXME: decent ID system nescessary 
    157     std::ostringstream idstr; 
    158  
    159     idstr << "dev" << id; 
    160      
    161     debugOutput( DEBUG_LEVEL_VERBOSE, "Set id to %s...\n", idstr.str().c_str()); 
    162      
    163     return setOption("id",idstr.str()); 
    164 } 
    165  
    166138bool 
    167139BounceDevice::lock() { 
     
    181153{ 
    182154    debugOutput(DEBUG_LEVEL_NORMAL, "\nI am the bouncedevice, the bouncedevice I am...\n" ); 
    183     debugOutput(DEBUG_LEVEL_NORMAL, "Vendor            :  %s\n", m_configRom->getVendorName().c_str()); 
    184     debugOutput(DEBUG_LEVEL_NORMAL, "Model             :  %s\n", m_configRom->getModelName().c_str()); 
     155    debugOutput(DEBUG_LEVEL_NORMAL, "Vendor            :  %s\n", m_pConfigRom->getVendorName().c_str()); 
     156    debugOutput(DEBUG_LEVEL_NORMAL, "Model             :  %s\n", m_pConfigRom->getModelName().c_str()); 
    185157    debugOutput(DEBUG_LEVEL_NORMAL, "Vendor Name       :  %s\n", m_model->vendor_name); 
    186158    debugOutput(DEBUG_LEVEL_NORMAL, "Model Name        :  %s\n", m_model->model_name); 
    187159    debugOutput(DEBUG_LEVEL_NORMAL, "Node              :  %d\n", m_nodeId); 
    188     debugOutput(DEBUG_LEVEL_NORMAL, "GUID              :  0x%016llX\n", m_configRom->getGuid()); 
     160    debugOutput(DEBUG_LEVEL_NORMAL, "GUID              :  0x%016llX\n", m_pConfigRom->getGuid()); 
    189161    debugOutput(DEBUG_LEVEL_NORMAL, "\n" ); 
    190 } 
    191  
    192 bool 
    193 BounceDevice::addXmlDescription( xmlNodePtr deviceNode ) 
    194 { 
    195  
    196     return false; 
    197  
    198162} 
    199163 
  • branches/streaming-rework/src/bounce/bounce_avdevice.h

    r424 r426  
    6464    BounceDevice( std::auto_ptr<ConfigRom>( configRom ), 
    6565                  Ieee1394Service& ieee1394Service, 
    66                   int nodeId, 
    67                   int verboseLevel ); 
     66                  int nodeId ); 
    6867    virtual ~BounceDevice(); 
    6968 
    7069    static bool probe( ConfigRom& configRom ); 
    7170    bool discover(); 
    72     ConfigRom& getConfigRom() const; 
    73      
    74     bool addXmlDescription( xmlNodePtr deviceNode ); 
    7571     
    7672    bool setSamplingFrequency( ESamplingFrequency samplingFrequency ); 
     
    8985     
    9086    void showDevice() const; 
    91     bool setId(unsigned int id); 
    9287 
    9388protected: 
    94     std::auto_ptr<ConfigRom>( m_configRom ); 
    95     Ieee1394Service* m_p1394Service; 
    96     int              m_nodeId; 
    97     int              m_verboseLevel; 
    98  
    99         std::string xmlDescription; 
    100  
    10189    unsigned int m_samplerate; 
    10290    struct VendorModelEntry* m_model; 
     
    11098       Streaming::StreamProcessor *processor,  
    11199       Streaming::Port::E_Direction direction); 
    112  
    113     DECLARE_DEBUG_MODULE; 
    114100     
    115101private: // generic helpers 
     
    127113    BounceNotifier *m_Notifier; 
    128114    /** 
    129      * this class reacts on the ohter side writing to the  
     115     * this class reacts on the other side writing to the  
    130116     * hosts address space 
    131117     */ 
  • branches/streaming-rework/src/bounce/bounce_slave_avdevice.cpp

    r424 r426  
    4343}; 
    4444 
    45 IMPL_DEBUG_MODULE( BounceSlaveDevice, BounceSlaveDevice, DEBUG_LEVEL_VERBOSE ); 
    46  
    4745BounceSlaveDevice::BounceSlaveDevice( std::auto_ptr< ConfigRom >( configRom ), 
    48                             Ieee1394Service& ieee1394service, 
    49                             int verboseLevel ) 
     46                            Ieee1394Service& ieee1394service ) 
    5047    : BounceDevice( configRom, 
    5148                    ieee1394service, 
    52                     ieee1394service.getLocalNodeId(), 
    53 //                     verboseLevel ) 
    54                     DEBUG_LEVEL_VERBOSE ) 
     49                    ieee1394service.getLocalNodeId() ) 
    5550{ 
    5651    addOption(Util::OptionContainer::Option("isoTimeoutSecs",(int64_t)120)); 
     
    10499     
    105100    // refresh our config rom cache 
    106     if ( !m_configRom->initialize() ) { 
     101    if ( !m_pConfigRom->initialize() ) { 
    107102        // \todo If a PHY on the bus is in power safe mode then 
    108103        // the config rom is missing. So this might be just 
  • branches/streaming-rework/src/bounce/bounce_slave_avdevice.h

    r424 r426  
    3939 
    4040    BounceSlaveDevice( std::auto_ptr<ConfigRom>( configRom ), 
    41           Ieee1394Service& ieee1394Service, 
    42           int verboseLevel ); 
     41          Ieee1394Service& ieee1394Service ); 
    4342    virtual ~BounceSlaveDevice(); 
    4443     
     
    5150    bool startStreamByIndex(int i); 
    5251    bool stopStreamByIndex(int i); 
    53      
    5452 
    55 protected: 
    56     DECLARE_DEBUG_MODULE; 
    5753private: 
    5854    bool waitForRegisterNotEqualTo(nodeaddr_t offset, fb_quadlet_t v); 
  • branches/streaming-rework/src/devicemanager.cpp

    r424 r426  
    156156     
    157157            IAvDevice* avDevice = getDriverForDevice( configRom, 
    158                                                       nodeId, 
    159                                                       verboseLevel ); 
     158                                                      nodeId ); 
    160159            if ( avDevice ) { 
    161160                debugOutput( DEBUG_LEVEL_NORMAL, 
     
    163162                             nodeId ); 
    164163 
     164                avDevice->setVerboseLevel( verboseLevel ); 
     165                 
    165166                if ( !avDevice->discover() ) { 
    166167                    debugError( "discover: could not discover device\n" ); 
     
    178179 
    179180                    if(!avDevice->setOption("snoopMode", snoopMode)) { 
    180                         debugWarning("Could not set snoop mode for device on node %d\n",nodeId); 
     181                        debugWarning("Could not set snoop mode for device on node %d\n", nodeId); 
    181182                        delete avDevice; 
    182183                        continue; 
    183184                    } 
    184185                } 
    185                  
    186                 avDevice->setVerboseLevel( verboseLevel ); 
    187186                 
    188187                if ( verboseLevel ) { 
     
    215214        } 
    216215 
    217         IAvDevice* avDevice = getSlaveDriver( configRom, verboseLevel ); 
     216        IAvDevice* avDevice = getSlaveDriver( configRom ); 
    218217        if ( avDevice ) { 
    219218            debugOutput( DEBUG_LEVEL_NORMAL, 
    220219                         "discover: driver found for device %d\n", 
    221220                         nodeId ); 
     221             
     222            avDevice->setVerboseLevel( verboseLevel ); 
    222223 
    223224            if ( !avDevice->discover() ) { 
     
    233234                avDevice->showDevice(); 
    234235            } 
     236             
    235237 
    236238            m_avDevices.push_back( avDevice ); 
     
    244246IAvDevice* 
    245247DeviceManager::getDriverForDevice( std::auto_ptr<ConfigRom>( configRom ), 
    246                                    int id,  int level
     248                                   int id
    247249{ 
    248250#ifdef ENABLE_BEBOB 
    249251    debugOutput( DEBUG_LEVEL_VERBOSE, "Trying BeBoB...\n" ); 
    250252    if ( BeBoB::AvDevice::probe( *configRom.get() ) ) { 
    251         return new BeBoB::AvDevice( configRom, *m_1394Service, id, level ); 
     253        return new BeBoB::AvDevice( configRom, *m_1394Service, id ); 
    252254    } 
    253255#endif 
     
    256258    debugOutput( DEBUG_LEVEL_VERBOSE, "Trying M-Audio...\n" ); 
    257259    if ( MAudio::AvDevice::probe( *configRom.get() ) ) { 
    258         return new MAudio::AvDevice( configRom, *m_1394Service, id, level ); 
     260        return new MAudio::AvDevice( configRom, *m_1394Service, id ); 
    259261    } 
    260262#endif 
     
    263265    debugOutput( DEBUG_LEVEL_VERBOSE, "Trying Motu...\n" ); 
    264266    if ( Motu::MotuDevice::probe( *configRom.get() ) ) { 
    265         return new Motu::MotuDevice( configRom, *m_1394Service, id, level ); 
     267        return new Motu::MotuDevice( configRom, *m_1394Service, id ); 
    266268    } 
    267269#endif 
     
    270272    debugOutput( DEBUG_LEVEL_VERBOSE, "Trying Dice...\n" ); 
    271273    if ( Dice::DiceAvDevice::probe( *configRom.get() ) ) { 
    272         return new Dice::DiceAvDevice( configRom, *m_1394Service, id, level ); 
     274        return new Dice::DiceAvDevice( configRom, *m_1394Service, id ); 
    273275    } 
    274276#endif 
     
    277279    debugOutput( DEBUG_LEVEL_VERBOSE, "Trying Metric Halo...\n" ); 
    278280    if ( MetricHalo::MHAvDevice::probe( *configRom.get() ) ) { 
    279         return new MetricHalo::MHAvDevice( configRom, *m_1394Service, id, level ); 
     281        return new MetricHalo::MHAvDevice( configRom, *m_1394Service, id ); 
    280282    } 
    281283#endif 
     
    284286    debugOutput( DEBUG_LEVEL_VERBOSE, "Trying RME...\n" ); 
    285287    if ( Rme::RmeDevice::probe( *configRom.get() ) ) { 
    286         return new Rme::RmeDevice( configRom, *m_1394Service, id, level ); 
     288        return new Rme::RmeDevice( configRom, *m_1394Service, id ); 
    287289    } 
    288290#endif 
     
    291293    debugOutput( DEBUG_LEVEL_VERBOSE, "Trying Bounce...\n" ); 
    292294    if ( Bounce::BounceDevice::probe( *configRom.get() ) ) { 
    293         return new Bounce::BounceDevice( configRom, *m_1394Service, id, level ); 
     295        return new Bounce::BounceDevice( configRom, *m_1394Service, id ); 
    294296    } 
    295297#endif 
     
    299301 
    300302IAvDevice* 
    301 DeviceManager::getSlaveDriver( std::auto_ptr<ConfigRom>( configRom ), int level
     303DeviceManager::getSlaveDriver( std::auto_ptr<ConfigRom>( configRom )
    302304{ 
    303305 
    304306#ifdef ENABLE_BOUNCE 
    305307    if ( Bounce::BounceSlaveDevice::probe( *configRom.get() ) ) { 
    306         return new Bounce::BounceSlaveDevice( configRom, *m_1394Service, level ); 
     308        return new Bounce::BounceSlaveDevice( configRom, *m_1394Service ); 
    307309    } 
    308310#endif 
  • branches/streaming-rework/src/devicemanager.h

    r424 r426  
    7070protected: 
    7171    IAvDevice* getDriverForDevice( std::auto_ptr<ConfigRom>( configRom ), 
    72                                    int id, 
    73                                    int level ); 
    74     IAvDevice* getSlaveDriver( std::auto_ptr<ConfigRom>( configRom ), 
    75                                    int level ); 
     72                                   int id ); 
     73    IAvDevice* getSlaveDriver( std::auto_ptr<ConfigRom>( configRom ) ); 
    7674 
    7775protected: 
  • branches/streaming-rework/src/dice/dice_avdevice.cpp

    r419 r426  
    3939namespace Dice { 
    4040 
    41 IMPL_DEBUG_MODULE( DiceAvDevice, DiceAvDevice, DEBUG_LEVEL_VERBOSE ); 
    42  
    4341// to define the supported devices 
    4442static VendorModelEntry supportedDeviceList[] = 
     
    4947DiceAvDevice::DiceAvDevice( std::auto_ptr< ConfigRom >( configRom ), 
    5048                    Ieee1394Service& ieee1394service, 
    51                     int nodeId, 
    52                     int verboseLevel ) 
    53     : m_configRom( configRom ) 
    54     , m_1394Service( &ieee1394service ) 
     49                    int nodeId ) 
     50    :  IAvDevice( configRom, ieee1394service, nodeId ) 
    5551    , m_model( NULL ) 
    56     , m_nodeId( nodeId ) 
    57     , m_verboseLevel( verboseLevel ) 
    58     , m_id(0) 
    5952    , m_iso_recv_channel ( -1 ) 
    6053    , m_iso_send_channel ( -1 ) 
    6154{ 
    62     setDebugLevel( verboseLevel ); 
    63      
    6455    debugOutput( DEBUG_LEVEL_VERBOSE, "Created Dice::DiceAvDevice (NodeID %d)\n", 
    6556                 nodeId ); 
     
    7061{ 
    7162 
    72 } 
    73  
    74 ConfigRom& 
    75 DiceAvDevice::getConfigRom() const 
    76 { 
    77     return *m_configRom; 
    7863} 
    7964 
     
    10287DiceAvDevice::discover() 
    10388{ 
    104     unsigned int vendorId = m_configRom->getNodeVendorId(); 
    105     unsigned int modelId = m_configRom->getModelId(); 
     89    unsigned int vendorId = m_pConfigRom->getNodeVendorId(); 
     90    unsigned int modelId = m_pConfigRom->getModelId(); 
    10691 
    10792    for ( unsigned int i = 0; 
     
    138123} 
    139124 
    140 bool DiceAvDevice::setId( unsigned int id) { 
    141     debugOutput( DEBUG_LEVEL_VERBOSE, "Set id to %d...\n", id); 
    142     m_id=id; 
    143     return true; 
    144 } 
    145  
    146125void 
    147126DiceAvDevice::showDevice() const 
  • branches/streaming-rework/src/dice/dice_avdevice.h

    r420 r426  
    4646    DiceAvDevice( std::auto_ptr<ConfigRom>( configRom ), 
    4747              Ieee1394Service& ieee1394Service, 
    48                   int nodeId, 
    49                   int verboseLevel ); 
     48                  int nodeId); 
    5049    ~DiceAvDevice(); 
    5150 
    5251    static bool probe( ConfigRom& configRom ); 
    5352    bool discover(); 
    54     ConfigRom& getConfigRom() const; 
    55  
    56     // obsolete, will be removed soon, unused 
    57     bool addXmlDescription( xmlNodePtr deviceNode ) {return true;}; 
    5853 
    5954    void showDevice() const; 
     
    6156    bool setSamplingFrequency( ESamplingFrequency samplingFrequency ); 
    6257    int getSamplingFrequency( ); 
    63  
    64     bool setId(unsigned int id); 
    6558 
    6659    int getStreamCount(); 
     
    7972   
    8073protected: 
    81     std::auto_ptr<ConfigRom>( m_configRom ); 
    82     Ieee1394Service* m_1394Service; 
    83      
    8474    struct VendorModelEntry *m_model; 
    8575     
    86     int              m_nodeId; 
    87     int              m_verboseLevel; 
    88     signed int m_id; 
    8976    signed int m_iso_recv_channel, m_iso_send_channel; 
    9077     
     
    9279        Streaming::AmdtpTransmitStreamProcessor *m_transmitProcessor; 
    9380 
    94 private: 
    95     // debug support 
    96     DECLARE_DEBUG_MODULE; 
    9781}; 
    9882 
  • branches/streaming-rework/src/iavdevice.h

    r424 r426  
    3333} 
    3434/*! 
    35 @brief Interface that is to be implemented to support a device. 
    36  
    37  This interface should be used to implement freebob support  
     35@brief Base class for device support 
     36 
     37 This class should be subclassed to implement freebob support  
    3838 for a specific device. 
    3939 
     
    4141class IAvDevice : public Util::OptionContainer { 
    4242public: 
    43         virtual ~IAvDevice() {} 
     43        IAvDevice( std::auto_ptr< ConfigRom >( configRom ), 
     44                    Ieee1394Service& ieee1394service, 
     45                    int nodeId ); 
     46         
     47        virtual ~IAvDevice() {}; 
    4448         
    4549        /// Returns the ConfigRom object of the device node. 
    46         virtual ConfigRom& getConfigRom() const = 0
     50        ConfigRom& getConfigRom() const
    4751         
    4852        /** 
     
    9397     * @return true if successful 
    9498     */ 
    95     virtual bool setId(unsigned int id) = 0
     99    bool setId(unsigned int id)
    96100         
    97101        /** 
     
    105109         * @return true if successful, false if not 
    106110         */ 
    107         virtual bool addXmlDescription( xmlNodePtr deviceNode ) = 0
     111        bool addXmlDescription( xmlNodePtr deviceNode ) {return true;}
    108112         
    109113        /** 
     
    219223     * set verbosity level 
    220224     */ 
    221     virtual void setVerboseLevel(int l) {setDebugLevel(l);}; 
     225    virtual void setVerboseLevel(int l); 
     226 
     227protected: 
     228    std::auto_ptr<ConfigRom>( m_pConfigRom ); 
     229    Ieee1394Service*          m_p1394Service; 
     230    int                       m_verboseLevel; 
     231    int                       m_nodeId; 
     232 
     233    DECLARE_DEBUG_MODULE; 
    222234}; 
    223235 
  • branches/streaming-rework/src/Makefile.am

    r424 r426  
    6565        freebob.cpp \ 
    6666        freebob_streaming.cpp \ 
     67        iavdevice.cpp \ 
    6768        xmlparser.c \ 
    6869        debugmodule/debugmodule.cpp \ 
  • branches/streaming-rework/src/maudio/maudio_avdevice.cpp

    r420 r426  
    3636namespace MAudio { 
    3737 
    38 IMPL_DEBUG_MODULE( AvDevice, AvDevice, DEBUG_LEVEL_NORMAL ); 
    39  
    4038AvDevice::AvDevice( std::auto_ptr< ConfigRom >( configRom ), 
    4139                    Ieee1394Service& ieee1394service, 
    42                     int iNodeId, 
    43                     int iVerboseLevel ) 
     40                    int iNodeId ) 
    4441    : BeBoB::AvDevice( configRom, 
    4542                    ieee1394service, 
    46                     iNodeId, 
    47                     iVerboseLevel ) 
     43                    iNodeId ) 
    4844    , m_model ( NULL ) 
    4945{ 
     
    128124 
    129125bool 
    130 AvDevice::addXmlDescription( xmlNodePtr pDeviceNode ) 
    131 { 
    132     char* pFilename; 
    133     if ( asprintf( &pFilename, "%s/libfreebob/maudio/%s", DATADIR, m_model->filename ) < 0 ) { 
    134         debugError( "addXmlDescription: Could not create filename string\n" ); 
    135         return false; 
    136     } 
    137  
    138     xmlDocPtr pDoc = xmlParseFile( pFilename ); 
    139  
    140     if ( !pDoc ) { 
    141         debugError( "addXmlDescription: No file '%s' found'\n", pFilename ); 
    142         free( pFilename ); 
    143         return false;; 
    144     } 
    145  
    146     xmlNodePtr pCur = xmlDocGetRootElement( pDoc ); 
    147     if ( !pCur ) { 
    148         debugError( "addXmlDescription: Document '%s' has not root element\n", pFilename ); 
    149         xmlFreeDoc( pDoc ); 
    150         free( pFilename ); 
    151         return false; 
    152     } 
    153  
    154     if ( xmlStrcmp( pCur->name, ( const xmlChar * ) "FreeBoBConnectionInfo" ) ) { 
    155         debugError( "addXmlDescription: No node 'FreeBoBConnectionInfo' found\n" ); 
    156         xmlFreeDoc( pDoc ); 
    157         free( pFilename ); 
    158         return false; 
    159     } 
    160  
    161     pCur = pCur->xmlChildrenNode; 
    162     while ( pCur ) { 
    163         if ( !xmlStrcmp( pCur->name, ( const xmlChar * ) "Device" ) ) { 
    164             break; 
    165         } 
    166         pCur = pCur->next; 
    167     } 
    168  
    169     if ( pCur ) { 
    170         pCur = pCur->xmlChildrenNode; 
    171         while ( pCur ) { 
    172             if ( ( !xmlStrcmp( pCur->name, ( const xmlChar * ) "ConnectionSet" ) ) ) { 
    173                 xmlNodePtr pDevDesc = xmlCopyNode( pCur, 1 ); 
    174                 if ( !pDevDesc ) { 
    175                     debugError( "addXmlDescription: Could not copy node 'ConnectionSet'\n" ); 
    176                     xmlFreeDoc( pDoc ); 
    177                     free( pFilename ); 
    178                     return false; 
    179                 } 
    180  
    181                 // set correct node id 
    182                 for ( xmlNodePtr pNode = pDevDesc->xmlChildrenNode; pNode; pNode = pNode->next ) { 
    183                     if ( ( !xmlStrcmp( pNode->name,  ( const xmlChar * ) "Connection" ) ) ) { 
    184                         for ( xmlNodePtr pSubNode = pNode->xmlChildrenNode; pSubNode; pSubNode = pSubNode->next ) { 
    185                             if ( ( !xmlStrcmp( pSubNode->name,  ( const xmlChar * ) "Node" ) ) ) { 
    186                                 char* result; 
    187                                 asprintf( &result, "%d", m_nodeId ); 
    188                                 xmlNodeSetContent( pSubNode, BAD_CAST result ); 
    189                                 free( result ); 
    190                             } 
    191                         } 
    192                     } 
    193                 } 
    194  
    195                 xmlAddChild( pDeviceNode, pDevDesc ); 
    196             } 
    197             if ( ( !xmlStrcmp( pCur->name, ( const xmlChar * ) "StreamFormats" ) ) ) { 
    198                 xmlNodePtr pDevDesc = xmlCopyNode( pCur, 1 ); 
    199                 if ( !pDevDesc ) { 
    200                     debugError( "addXmlDescription: Could not copy node 'StreamFormats'\n" ); 
    201                     xmlFreeDoc( pDoc ); 
    202                     free( pFilename ); 
    203                     return false; 
    204                 } 
    205                 xmlAddChild( pDeviceNode, pDevDesc ); 
    206             } 
    207  
    208             pCur = pCur->next; 
    209         } 
    210     } 
    211  
    212     xmlFreeDoc( pDoc ); 
    213     free( pFilename ); 
    214  
    215     return true; 
    216 } 
    217  
    218 bool 
    219126AvDevice::prepare() { 
    220127 
  • branches/streaming-rework/src/maudio/maudio_avdevice.h

    r420 r426  
    5252    AvDevice( std::auto_ptr<ConfigRom>( configRom ), 
    5353              Ieee1394Service& ieee1394Service, 
    54               int nodeId, 
    55               int verboseLevel ); 
     54              int nodeId ); 
    5655    virtual ~AvDevice(); 
    5756 
     
    5958    bool discover(); 
    6059     
    61     bool addXmlDescription( xmlNodePtr pDeviceNode ); 
    6260    void showDevice() const; 
    6361     
     
    6967protected: 
    7068    struct VendorModelEntry*  m_model; 
    71      
    72     DECLARE_DEBUG_MODULE; 
     69 
    7370}; 
    7471 
  • branches/streaming-rework/src/metrichalo/mh_avdevice.cpp

    r420 r426  
    4141namespace MetricHalo { 
    4242 
    43 IMPL_DEBUG_MODULE( MHAvDevice, MHAvDevice, DEBUG_LEVEL_NORMAL ); 
    44  
    4543// to define the supported devices 
    4644static VendorModelEntry supportedDeviceList[] = 
     
    5149MHAvDevice::MHAvDevice( std::auto_ptr< ConfigRom >( configRom ), 
    5250                    Ieee1394Service& ieee1394service, 
    53                     int nodeId, 
    54                     int verboseLevel ) 
    55     : m_configRom( configRom ) 
    56     , m_p1394Service( &ieee1394service ) 
     51                    int nodeId ) 
     52    :  IAvDevice( configRom, ieee1394service, nodeId ) 
    5753    , m_model( NULL ) 
    58     , m_nodeId( nodeId ) 
    59     , m_verboseLevel( verboseLevel ) 
    6054     
    6155{ 
    62     setDebugLevel( verboseLevel ); 
    63      
    6456    debugOutput( DEBUG_LEVEL_VERBOSE, "Created MetricHalo::MHAvDevice (NodeID %d)\n", 
    6557                 nodeId ); 
    66     addOption(Util::OptionContainer::Option("id",std::string("dev?"))); 
    67  
    6858} 
    6959 
     
    7161{ 
    7262 
    73 } 
    74  
    75 ConfigRom& 
    76 MHAvDevice::getConfigRom() const 
    77 { 
    78     return *m_configRom; 
    7963} 
    8064 
     
    10387MHAvDevice::discover() 
    10488{ 
    105     unsigned int vendorId = m_configRom->getNodeVendorId(); 
    106     unsigned int modelId = m_configRom->getModelId(); 
     89    unsigned int vendorId = m_pConfigRom->getNodeVendorId(); 
     90    unsigned int modelId = m_pConfigRom->getModelId(); 
    10791 
    10892    for ( unsigned int i = 0; 
     
    137121 
    138122    return false; 
    139 } 
    140  
    141 bool MHAvDevice::setId( unsigned int id) { 
    142     // FIXME: decent ID system nescessary 
    143     std::ostringstream idstr; 
    144  
    145     idstr << "dev" << id; 
    146      
    147     debugOutput( DEBUG_LEVEL_VERBOSE, "Set id to %s...\n", idstr.str().c_str()); 
    148      
    149     return setOption("id",idstr.str()); 
    150123} 
    151124 
  • branches/streaming-rework/src/metrichalo/mh_avdevice.h

    r420 r426  
    4747    MHAvDevice( std::auto_ptr<ConfigRom>( configRom ), 
    4848              Ieee1394Service& ieee1394Service, 
    49                   int nodeId, 
    50                   int verboseLevel ); 
     49                  int nodeId ); 
    5150    virtual ~MHAvDevice(); 
    5251 
    5352    static bool probe( ConfigRom& configRom ); 
    54     virtual bool discover(); 
    55     virtual ConfigRom& getConfigRom() const; 
     53    bool discover(); 
    5654 
    57     // obsolete, will be removed soon, unused 
    58     virtual bool addXmlDescription( xmlNodePtr deviceNode ) {return true;}; 
     55    void showDevice() const; 
    5956 
    60     virtual void showDevice() const; 
     57    bool setSamplingFrequency( ESamplingFrequency samplingFrequency ); 
     58    int getSamplingFrequency( ); 
    6159 
    62     virtual bool setSamplingFrequency( ESamplingFrequency samplingFrequency ); 
    63     virtual int getSamplingFrequency( ); 
     60    int getStreamCount(); 
     61    Streaming::StreamProcessor *getStreamProcessorByIndex(int i); 
    6462 
    65     virtual bool setId(unsigned int id); 
    66  
    67     virtual int getStreamCount(); 
    68     virtual Streaming::StreamProcessor *getStreamProcessorByIndex(int i); 
    69  
    70     virtual bool prepare(); 
     63    bool prepare(); 
    7164    bool lock(); 
    7265    bool unlock(); 
     
    7972   
    8073protected: 
    81     std::auto_ptr<ConfigRom>( m_configRom ); 
    82     Ieee1394Service* m_p1394Service; 
    83      
    8474    struct VendorModelEntry *m_model; 
    85      
    86     int              m_nodeId; 
    87     int              m_verboseLevel; 
    8875 
    89 private: 
    90     // debug support 
    91     DECLARE_DEBUG_MODULE; 
    9276}; 
    9377 
  • branches/streaming-rework/src/motu/motu_avdevice.cpp

    r420 r426  
    4444namespace Motu { 
    4545 
    46 IMPL_DEBUG_MODULE( MotuDevice, MotuDevice, DEBUG_LEVEL_NORMAL ); 
    47  
    4846// to define the supported devices 
    4947static VendorModelEntry supportedDeviceList[] = 
     
    5654MotuDevice::MotuDevice( std::auto_ptr< ConfigRom >( configRom ), 
    5755                    Ieee1394Service& ieee1394service, 
    58                     int nodeId, 
    59                     int verboseLevel ) 
    60     : m_configRom( configRom ) 
    61     , m_p1394Service( &ieee1394service ) 
     56                    int nodeId) 
     57    : IAvDevice( configRom, ieee1394service, nodeId ) 
    6258    , m_motu_model( MOTUFW_MODEL_NONE ) 
    63     , m_nodeId( nodeId ) 
    64     , m_verboseLevel( verboseLevel ) 
    6559    , m_iso_recv_channel ( -1 ) 
    6660    , m_iso_send_channel ( -1 ) 
     
    7064     
    7165{ 
    72     setDebugLevel( verboseLevel ); 
    73      
    7466    debugOutput( DEBUG_LEVEL_VERBOSE, "Created Motu::MotuDevice (NodeID %d)\n", 
    7567                 nodeId ); 
     
    9284} 
    9385 
    94 ConfigRom& 
    95 MotuDevice::getConfigRom() const 
    96 { 
    97     return *m_configRom; 
    98 } 
    99  
    10086bool 
    10187MotuDevice::probe( ConfigRom& configRom ) 
     
    126112MotuDevice::discover() 
    127113{ 
    128     unsigned int vendorId = m_configRom->getNodeVendorId(); 
    129 //     unsigned int modelId = m_configRom->getModelId(); 
    130     unsigned int unitVersion = m_configRom->getUnitVersion(); 
    131     unsigned int unitSpecifierId = m_configRom->getUnitSpecifierId(); 
     114    unsigned int vendorId = m_pConfigRom->getNodeVendorId(); 
     115//     unsigned int modelId = m_pConfigRom->getModelId(); 
     116    unsigned int unitVersion = m_pConfigRom->getUnitVersion(); 
     117    unsigned int unitSpecifierId = m_pConfigRom->getUnitSpecifierId(); 
    132118 
    133119    for ( unsigned int i = 0; 
     
    304290} 
    305291 
    306 bool MotuDevice::setId( unsigned int id) { 
    307     // FIXME: decent ID system nescessary 
    308     std::ostringstream idstr; 
    309  
    310     idstr << "dev" << id; 
    311      
    312     debugOutput( DEBUG_LEVEL_VERBOSE, "Set id to %s...\n", idstr.str().c_str()); 
    313      
    314     return setOption("id",idstr.str()); 
    315 } 
    316  
    317292bool 
    318293MotuDevice::lock() { 
  • branches/streaming-rework/src/motu/motu_avdevice.h

    r420 r426  
    9494    MotuDevice( std::auto_ptr<ConfigRom>( configRom ), 
    9595          Ieee1394Service& ieee1394Service, 
    96                   int nodeId, 
    97                   int verboseLevel ); 
     96                  int nodeId ); 
    9897    virtual ~MotuDevice(); 
    9998 
    10099    static bool probe( ConfigRom& configRom ); 
    101100    virtual bool discover(); 
    102     virtual ConfigRom& getConfigRom() const; 
    103  
    104     // obsolete, will be removed soon, unused 
    105     virtual bool addXmlDescription( xmlNodePtr deviceNode ) {return true;}; 
    106101 
    107102    virtual void showDevice() const; 
     
    109104    virtual bool setSamplingFrequency( ESamplingFrequency samplingFrequency ); 
    110105    virtual int getSamplingFrequency( ); 
    111  
    112     virtual bool setId(unsigned int id); 
    113106 
    114107    virtual int getStreamCount(); 
     
    130123   
    131124protected: 
    132     std::auto_ptr<ConfigRom>( m_configRom ); 
    133     Ieee1394Service* m_p1394Service; 
    134      
    135125    signed int       m_motu_model; 
    136126    struct VendorModelEntry * m_model; 
    137     int              m_nodeId; 
    138     int              m_verboseLevel; 
    139127    signed int m_iso_recv_channel, m_iso_send_channel; 
    140128    signed int m_bandwidth; 
     
    155143        signed int WriteRegister(unsigned int reg, quadlet_t data); 
    156144 
    157     // debug support 
    158     DECLARE_DEBUG_MODULE; 
    159145}; 
    160146 
  • branches/streaming-rework/src/rme/rme_avdevice.cpp

    r419 r426  
    4040namespace Rme { 
    4141 
    42 IMPL_DEBUG_MODULE( RmeDevice, RmeDevice, DEBUG_LEVEL_NORMAL ); 
    43  
    4442// to define the supported devices 
    4543static VendorModelEntry supportedDeviceList[] = 
     
    5048RmeDevice::RmeDevice( std::auto_ptr< ConfigRom >( configRom ), 
    5149                    Ieee1394Service& ieee1394service, 
    52                     int nodeId, 
    53                     int verboseLevel ) 
    54     : m_configRom( configRom ) 
    55     , m_p1394Service( &ieee1394service ) 
     50                    int nodeId ) 
     51    : IAvDevice( configRom, ieee1394service, nodeId ) 
    5652    , m_model( NULL ) 
    57     , m_nodeId( nodeId ) 
    58     , m_verboseLevel( verboseLevel ) 
    59      
    6053{ 
    61     setDebugLevel( verboseLevel ); 
    62      
    6354    debugOutput( DEBUG_LEVEL_VERBOSE, "Created Rme::RmeDevice (NodeID %d)\n", 
    6455                 nodeId ); 
    65  
    6656} 
    6757 
     
    6959{ 
    7060 
    71 } 
    72  
    73 ConfigRom& 
    74 RmeDevice::getConfigRom() const 
    75 { 
    76     return *m_configRom; 
    7761} 
    7862 
     
    10185RmeDevice::discover() 
    10286{ 
    103     unsigned int vendorId = m_configRom->getNodeVendorId(); 
    104     unsigned int modelId = m_configRom->getModelId(); 
     87    unsigned int vendorId = m_pConfigRom->getNodeVendorId(); 
     88    unsigned int modelId = m_pConfigRom->getModelId(); 
    10589 
    10690    for ( unsigned int i = 0; 
     
    142126                return true; 
    143127        return false; 
    144 } 
    145  
    146 bool RmeDevice::setId( unsigned int id) { 
    147     // FIXME: decent ID system nescessary 
    148     std::ostringstream idstr; 
    149  
    150     idstr << "dev" << id; 
    151      
    152     debugOutput( DEBUG_LEVEL_VERBOSE, "Set id to %s...\n", idstr.str().c_str()); 
    153      
    154     return setOption("id",idstr.str()); 
    155128} 
    156129 
  • branches/streaming-rework/src/rme/rme_avdevice.h

    r420 r426  
    4848    RmeDevice( std::auto_ptr<ConfigRom>( configRom ), 
    4949              Ieee1394Service& ieee1394Service, 
    50                   int nodeId, 
    51                   int verboseLevel ); 
     50                  int nodeId ); 
    5251    virtual ~RmeDevice(); 
    5352 
    5453    static bool probe( ConfigRom& configRom ); 
    55     virtual bool discover(); 
    56     virtual ConfigRom& getConfigRom() const; 
     54    bool discover(); 
    5755 
    58     // obsolete, will be removed soon, unused 
    59     virtual bool addXmlDescription( xmlNodePtr deviceNode ) {return true;}; 
     56    void showDevice() const; 
    6057 
    61     virtual void showDevice() const; 
     58    bool setSamplingFrequency( ESamplingFrequency samplingFrequency ); 
     59    int getSamplingFrequency( ); 
    6260 
    63     virtual bool setSamplingFrequency( ESamplingFrequency samplingFrequency ); 
    64     virtual int getSamplingFrequency( ); 
     61    int getStreamCount(); 
     62    Streaming::StreamProcessor *getStreamProcessorByIndex(int i); 
    6563 
    66     virtual bool setId(unsigned int id); 
    67  
    68     virtual int getStreamCount(); 
    69     virtual Streaming::StreamProcessor *getStreamProcessorByIndex(int i); 
    70  
    71     virtual bool prepare(); 
     64    bool prepare(); 
    7265    bool lock(); 
    7366    bool unlock(); 
     
    7568    bool startStreamByIndex(int i); 
    7669    bool stopStreamByIndex(int i); 
    77    
     70 
    7871protected: 
    79     std::auto_ptr<ConfigRom>( m_configRom ); 
    80     Ieee1394Service* m_p1394Service; 
    81      
    8272    struct VendorModelEntry *m_model; 
    83      
    84     int              m_nodeId; 
    85     int              m_verboseLevel; 
    86  
    87 private: 
    88  
    89     // debug support 
    90     DECLARE_DEBUG_MODULE; 
    9173}; 
    9274