Changeset 158

Show
Ignore:
Timestamp:
02/26/06 08:58:04 (18 years ago)
Author:
wagi
Message:

* src/avdevice.cpp: Some more refactoring (m_isoInputPlugs and m_isoOutputPlugs
unified into m_isoPlugs). Discovering of unit external plugs.
* src/avdevice.h: Likewise.
* src/avdevicexml.cpp: Likewise.
* src/avdevicesubunit.cpp: Likewise.
* src/avdevicesubunit.h: Likewise.
* src/avplug.cpp: Likewise.
* src/avplug.h: Likewise.

* src/libfreebobavc/avc_extended_cmd_generic.h (class UnitPlugAddress?):
ePT_Unknown enum added.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • trunk/libfreebob/ChangeLog

    r157 r158  
     12006-02-26  Daniel Wagner  <wagi@monom.org> 
     2 
     3        * src/avdevice.cpp: Some more refactoring (m_isoInputPlugs and m_isoOutputPlugs 
     4        unified into m_isoPlugs). Discovering of unit external plugs. 
     5        * src/avdevice.h: Likewise. 
     6        * src/avdevicexml.cpp: Likewise. 
     7        * src/avdevicesubunit.cpp: Likewise. 
     8        * src/avdevicesubunit.h: Likewise. 
     9        * src/avplug.cpp: Likewise. 
     10        * src/avplug.h: Likewise. 
     11 
     12        * src/libfreebobavc/avc_extended_cmd_generic.h (class UnitPlugAddress):  
     13        ePT_Unknown enum added. 
     14 
    1152006-02-22  Daniel Wagner  <wagi@monom.org> 
    216 
  • trunk/libfreebob/src/avdevice.cpp

    r157 r158  
    6565        delete *it; 
    6666    } 
    67     for ( AvPlugVector::iterator it = m_isoInputPlugs.begin(); 
    68           it != m_isoInputPlugs.end(); 
     67    for ( AvPlugVector::iterator it = m_isoPlugs.begin(); 
     68          it != m_isoPlugs.end(); 
    6969          ++it ) 
    7070    { 
    7171        delete *it; 
    7272    } 
    73     for ( AvPlugVector::iterator it = m_isoOutputPlugs.begin(); 
    74           it != m_isoOutputPlugs.end(); 
     73    for ( AvPlugVector::iterator it = m_externalPlugs.begin(); 
     74          it != m_externalPlugs.end(); 
     75          ++it ) 
     76    { 
     77        delete *it; 
     78    } 
     79    for ( AvPlugVector::iterator it = m_syncPlugs.begin(); 
     80          it != m_syncPlugs.end(); 
    7581          ++it ) 
    7682    { 
     
    8692        return false; 
    8793    } 
    88  
    8994    if ( !discoverPlugs() ) { 
    9095        debugError( "discover: detecting plugs failed\n" ); 
    9196        return false; 
    9297    } 
    93     if ( !discoverPlugConnectionsInput() ) { 
    94         debugError( "discover: detecting input plug connections failed\n" ); 
    95         return false; 
    96     } 
    97     if ( !discoverPlugConnectionsOutput() ) { 
    98         debugError( "discover: detecting output plug connecions failed\n" ); 
     98    if ( !discoverPlugConnections() ) { 
     99        debugError( "discover: detecting plug connections failed\n" ); 
    99100        return false; 
    100101    } 
     
    119120 
    120121    if ( !plugInfoCmd.fire() ) { 
    121         debugError( "discoverPlugs: plug info command failed (step 1)\n" ); 
    122         return false; 
    123     } 
    124  
     122        debugError( "discoverPlugs: plug info command failed\n" ); 
     123        return false; 
     124    } 
     125 
     126    debugOutput( DEBUG_LEVEL_NORMAL, "\n" 
     127                 "\tnumber of iso input plugs = %d\n" 
     128                 "\tnumber of iso output plugs = %d\n" 
     129                 "\tnumber of external input plugs = %d\n " 
     130                 "\tnumber of external output plugs = %d\n", 
     131                 plugInfoCmd.m_serialBusIsochronousInputPlugs, 
     132                 plugInfoCmd.m_serialBusIsochronousOutputPlugs, 
     133                 plugInfoCmd.m_externalInputPlugs, 
     134                 plugInfoCmd.m_externalOutputPlugs ); 
     135 
     136 
     137    if ( !discoverPlugsIso( PlugAddress::ePD_Input, 
     138                            plugInfoCmd.m_serialBusIsochronousInputPlugs ) ) 
     139    { 
     140        debugError( "discoverPlugs: iso input plug discovering failed\n" ); 
     141        return false; 
     142    } 
     143 
     144    if ( !discoverPlugsIso( PlugAddress::ePD_Output, 
     145                            plugInfoCmd.m_serialBusIsochronousOutputPlugs ) ) 
     146    { 
     147        debugError( "discoverPlugs: iso output plug discovering failed\n" ); 
     148        return false; 
     149    } 
     150 
     151    if ( !discoverPlugsExternal( PlugAddress::ePD_Input, 
     152                                 plugInfoCmd.m_externalInputPlugs ) ) 
     153    { 
     154        debugError( "discoverPlugs: external input plug discovering failed\n" ); 
     155        return false; 
     156    } 
     157 
     158    if ( !discoverPlugsExternal( PlugAddress::ePD_Output, 
     159                                 plugInfoCmd.m_externalOutputPlugs ) ) 
     160    { 
     161        debugError( "discoverPlugs: external output plug discovering failed\n" ); 
     162        return false; 
     163    } 
     164 
     165    return true; 
     166
     167 
     168bool 
     169AvDevice::discoverPlugsIso( PlugAddress::EPlugDirection plugDirection, 
     170                            plug_id_t plugMaxId ) 
     171
    125172    for ( int plugId = 0; 
    126           plugId < plugInfoCmd.m_serialBusIsochronousInputPlugs
     173          plugId < plugMaxId
    127174          ++plugId ) 
    128175    { 
     
    131178                                    AVCCommand::eST_Unit, 
    132179                                    0xff, 
    133                                     PlugAddress::ePD_Input, 
     180                                    AvPlug::eAP_PCR, 
     181                                    plugDirection, 
    134182                                    plugId ); 
    135183        if ( !plug || !plug->discover() ) { 
    136             debugError( "discoverPlugs: plug discovering failed\n" ); 
     184            debugError( "discoverPlugsIso: plug discovering failed\n" ); 
    137185            return false; 
    138186        } 
    139187 
    140         m_isoInputPlugs.push_back( plug ); 
    141     } 
    142  
     188        debugOutput( DEBUG_LEVEL_NORMAL, "discoverPlugsIso: plug '%s' found\n", 
     189                     plug->getName() ); 
     190        m_isoPlugs.push_back( plug ); 
     191    } 
     192 
     193    return true; 
     194
     195 
     196bool 
     197AvDevice::discoverPlugsExternal( PlugAddress::EPlugDirection plugDirection, 
     198                                 plug_id_t plugMaxId ) 
     199
    143200    for ( int plugId = 0; 
    144           plugId < plugInfoCmd.m_serialBusIsochronousOutputPlugs
     201          plugId < plugMaxId
    145202          ++plugId ) 
    146203    { 
     
    149206                                    AVCCommand::eST_Unit, 
    150207                                    0xff, 
    151                                     PlugAddress::ePD_Output, 
     208                                    AvPlug::eAP_ExternalPlug, 
     209                                    plugDirection, 
    152210                                    plugId ); 
    153211        if ( !plug || !plug->discover() ) { 
    154             debugError( "discover: plug discovering failed\n" ); 
     212            debugError( "discoverPlugsExternal: plug discovering failed\n" ); 
    155213            return false; 
    156214        } 
    157215 
    158         m_isoOutputPlugs.push_back( plug ); 
    159     } 
    160  
    161     debugOutput( DEBUG_LEVEL_VERBOSE, 
    162                  "number of iso input plugs = %d, " 
    163                  "number of iso output plugs = %d\n", 
    164                  plugInfoCmd.m_serialBusIsochronousInputPlugs, 
    165                  plugInfoCmd.m_serialBusIsochronousOutputPlugs ); 
    166  
    167     return true; 
    168 
    169  
    170 bool 
    171 AvDevice::discoverPlugConnectionsInput() 
    172 
    173     ////////////////////////////////////////////// 
    174     // Step 2: For each ISO input plug: get internal 
    175     // output connections (data sink) of the ISO input plug 
     216        debugOutput( DEBUG_LEVEL_NORMAL, "discoverPlugsExternal: plug '%s' found\n", 
     217                     plug->getName() ); 
     218        m_isoPlugs.push_back( plug ); 
     219        m_externalPlugs.push_back( plug ); 
     220    } 
     221 
     222    return true; 
     223
     224 
     225bool 
     226AvDevice::discoverPlugConnections() 
     227
     228 
    176229 
    177230    /* 
     
    275328} 
    276329 
     330/* 
    277331bool 
    278332AvDevice::discoverPlugConnectionsOutput() 
     
    282336    // intput connections (data source) of the ISO output plug 
    283337 
    284     /* 
    285338    for ( AvPlugVector::iterator it = m_isoOutputPlugs.begin(); 
    286339          it != m_isoOutputPlugs.end(); 
     
    357410        } 
    358411    } 
     412 
     413    return true; 
     414} 
    359415    */ 
    360     return true; 
    361 
     416 
    362417 
    363418bool 
     
    386441} 
    387442 
     443    /* 
    388444bool 
    389445AvDevice::discoverPlugConnection( AvPlug& srcPlug, 
    390446                                  SubunitPlugSpecificDataPlugAddress& subunitPlugAddress ) 
    391447{ 
    392     /* 
    393448    AvDeviceSubunit* subunit = getSubunit( subunitPlugAddress.m_subunitType, 
    394449                                           subunitPlugAddress.m_subunitId ); 
     
    426481                     "subunit -> ignored\n" ); 
    427482    } 
     483 
     484    return true; 
     485} 
    428486    */ 
    429487 
    430     return true; 
    431 } 
    432488 
    433489bool 
     
    557613 
    558614AvPlug* 
    559 AvDevice::getPlugById( AvPlugVector& plugs, int id ) 
     615AvDevice::getPlugById( AvPlugVector& plugs, PlugAddress::EPlugDirection plugDirection, int id ) 
    560616{ 
    561617    for ( AvPlugVector::iterator it = plugs.begin(); 
     
    564620    { 
    565621        AvPlug* plug = *it; 
    566         if ( id == plug->getPlugId() ) { 
     622        if ( ( id == plug->getPlugId() ) 
     623             && ( plugDirection == plug->getPlugDirection() ) ) 
     624        { 
    567625            return plug; 
    568626        } 
     
    599657AvDevice::setSamplingFrequency( ESamplingFrequency samplingFrequency ) 
    600658{ 
    601     AvPlug* plug = getPlugById( m_isoInputPlugs, 0 ); 
     659    AvPlug* plug = getPlugById( m_isoPlugs, PlugAddress::ePD_Input, 0 ); 
    602660    if ( !plug ) { 
    603661        debugError( "setSampleRate: Could not retrieve iso input plug 0\n" ); 
     
    610668    } 
    611669 
    612     plug = getPlugById( m_isoOutputPlugs, 0 ); 
     670    plug = getPlugById( m_isoPlugs, PlugAddress::ePD_Output, 0 ); 
    613671    if ( !plug ) { 
    614672        debugError( "setSampleRate: Could not retrieve iso output plug 0\n" ); 
  • trunk/libfreebob/src/avdevice.h

    r157 r158  
    5959 
    6060protected: 
     61    bool enumerateSubUnits(); 
     62 
    6163    bool discoverPlugs(); 
    62     bool discoverPlugConnectionsInput(); 
    63     bool discoverPlugConnectionsOutput(); 
     64    bool discoverPlugsIso( PlugAddress::EPlugDirection plugDirection, 
     65                           plug_id_t plugMaxId ); 
     66    bool discoverPlugsExternal( PlugAddress::EPlugDirection plugDirection, 
     67                                plug_id_t plugMaxId ); 
     68    bool discoverPlugConnections(); 
    6469    bool discoverSyncModes(); 
    6570 
    66     bool discoverPlugConnection( AvPlug& srcPlug, 
    67                                  SubunitPlugSpecificDataPlugAddress& subunitPlugAddress ); 
    68  
    69     bool enumerateSubUnits(); 
    7071 
    7172    AvDeviceSubunit* getSubunit( subunit_type_t subunitType, 
     
    7778    AvPlug* getSyncPlug( int maxPlugId, PlugAddress::EPlugDirection ); 
    7879 
    79     AvPlug* getPlugById( AvPlugVector& plugs, int id ); 
     80    AvPlug* getPlugById( AvPlugVector& plugs, 
     81                         PlugAddress::EPlugDirection plugDireciton, 
     82                         int id ); 
    8083 
    8184    bool setSamplingFrequencyPlug( AvPlug& plug, 
     
    8790    int              m_nodeId; 
    8891 
    89     AvPlugVector     m_isoInputPlugs; 
    90     AvPlugVector     m_isoOutputPlugs; 
     92    AvPlugVector     m_isoPlugs; 
    9193    AvPlugVector     m_externalPlugs; 
    92  
    9394    AvPlugVector     m_syncPlugs; 
    9495 
     
    9798    AvDeviceSubunitVector  m_subunits; 
    9899 
    99     nr_of_plugs_t m_serialBusIsochronousInputPlugs; 
    100     nr_of_plugs_t m_serialBusIsochronousOutputPlugs; 
    101  
    102100    DECLARE_DEBUG_MODULE; 
    103101}; 
  • trunk/libfreebob/src/avdevicesubunit.cpp

    r157 r158  
    6666    } 
    6767 
     68    debugOutput( DEBUG_LEVEL_NORMAL, "\n" 
     69                 "\tnumber of source plugs = %d\n " 
     70                 "\tnumber of destination output plugs = %d\n", 
     71                 plugInfoCmd.m_sourcePlugs, 
     72                 plugInfoCmd.m_destinationPlugs ); 
     73 
     74    if ( !discoverPlugs(  PlugAddress::ePD_Input, 
     75                          plugInfoCmd.m_destinationPlugs ) ) 
     76    { 
     77        debugError( "discover: destination plug discovering failed\n" ); 
     78        return false; 
     79    } 
     80 
     81    if ( !discoverPlugs(  PlugAddress::ePD_Output, 
     82                          plugInfoCmd.m_sourcePlugs ) ) 
     83    { 
     84        debugError( "discover: source plug discovering failed\n" ); 
     85        return false; 
     86    } 
     87 
     88    return true; 
     89} 
     90 
     91bool 
     92AvDeviceSubunit::discoverPlugs(PlugAddress::EPlugDirection plugDirection, 
     93                               plug_id_t plugMaxId ) 
     94{ 
    6895    for ( int plugIdx = 0; 
    69           plugIdx < plugInfoCmd.m_destinationPlugs
     96          plugIdx < plugMaxId
    7097          ++plugIdx ) 
    7198    { 
     
    76103                                   subunitType, 
    77104                                   getSubunitId(), 
    78                                    PlugAddress::ePD_Input, 
     105                                   AvPlug::eAP_SubunitPlug, 
     106                                   plugDirection, 
    79107                                   plugIdx ); 
    80108        if ( !plug || !plug->discover() ) { 
    81             debugError( "discover: plug discover failed\n" ); 
     109            debugError( "discoverPlugs: plug discover failed\n" ); 
    82110            return false; 
    83111        } 
    84112 
     113        debugOutput( DEBUG_LEVEL_NORMAL, "discoverPlugs: plug '%s' found\n", 
     114                     plug->getName() ); 
    85115        m_plugs.push_back( plug ); 
    86116    } 
    87  
    88     for ( int plugIdx = 0; 
    89           plugIdx < plugInfoCmd.m_sourcePlugs; 
    90           ++plugIdx ) 
    91     { 
    92         AVCCommand::ESubunitType subunitType = 
    93             static_cast<AVCCommand::ESubunitType>( getSubunitType() ); 
    94         AvPlug* plug = new AvPlug( *m_avDevice->get1394Service(), 
    95                                    m_avDevice->getNodeId(), 
    96                                    subunitType, 
    97                                    getSubunitId(), 
    98                                    PlugAddress::ePD_Output, 
    99                                    plugIdx ); 
    100         if ( !plug || !plug->discover() ) { 
    101             debugError( "discover: plug discover failed\n" ); 
    102             return false; 
    103         } 
    104  
    105         m_plugs.push_back( plug ); 
    106     } 
    107  
    108117    return true; 
    109118} 
  • trunk/libfreebob/src/avdevicesubunit.h

    r157 r158  
    4848 
    4949 protected: 
     50    bool discoverPlugs(PlugAddress::EPlugDirection plugDirection, 
     51                       plug_id_t plugMaxId ); 
     52 
     53 protected: 
    5054    AvDevice*      m_avDevice; 
    5155    AVCCommand::ESubunitType m_sbType; 
  • trunk/libfreebob/src/avdevicexml.cpp

    r157 r158  
    4545    // get plugs 
    4646 
    47     AvPlug* inputPlug = getPlugById( m_isoInputPlugs, 0 ); 
     47    AvPlug* inputPlug = getPlugById( m_isoPlugs, PlugAddress::ePD_Input, 0 ); 
    4848    if ( !inputPlug ) { 
    4949        debugError( "addXmlDescription: No iso input plug found with id %d\n" ); 
    5050        return false; 
    5151    } 
    52     AvPlug* outputPlug = getPlugById( m_isoOutputPlugs, 0 ); 
     52    AvPlug* outputPlug = getPlugById( m_isoPlugs, PlugAddress::ePD_Output, 0 ); 
    5353    if ( !outputPlug ) { 
    5454        debugError( "addXmlDescription: No iso output plug found with id %d\n" ); 
  • trunk/libfreebob/src/avplug.cpp

    r157 r158  
    2525 
    2626 
    27 IMPL_DEBUG_MODULE( AvPlug, AvPlug, DEBUG_LEVEL_VERBOSE ); 
     27IMPL_DEBUG_MODULE( AvPlug, AvPlug, DEBUG_LEVEL_NORMAL ); 
    2828 
    2929AvPlug::AvPlug( Ieee1394Service& ieee1394Service, 
     
    3131                AVCCommand::ESubunitType subunitType, 
    3232                subunit_id_t subunitId, 
     33                EAvPlugType plugType, 
    3334                PlugAddress::EPlugDirection plugDirection, 
    3435                plug_id_t plugId ) 
     
    3738    , m_subunitType( subunitType ) 
    3839    , m_subunitId( subunitId ) 
     40    , m_type( plugType ) 
    3941    , m_direction( plugDirection ) 
    4042    , m_id( plugId ) 
     43    , m_infoPlugType( ExtendedPlugInfoPlugTypeSpecificData::eEPIPT_Unknown ) 
     44    , m_nrOfChannels( 0 ) 
    4145{ 
    4246} 
     
    4751    , m_subunitType( rhs.m_subunitType ) 
    4852    , m_subunitId( rhs.m_subunitId ) 
     53    , m_type( rhs.m_type ) 
    4954    , m_direction( rhs.m_direction ) 
    5055    , m_id( rhs.m_id ) 
     56    , m_infoPlugType( rhs.m_infoPlugType ) 
     57    , m_nrOfChannels( rhs.m_nrOfChannels ) 
     58    , m_name( rhs.m_name ) 
     59    , m_clusterInfos( rhs.m_clusterInfos ) 
     60    , m_formatInfos( rhs.m_formatInfos ) 
    5161{ 
    5262} 
     
    167177                     plugType, 
    168178                     extendedPlugInfoPlugTypeToString( plugType ) ); 
    169         m_type = static_cast<ExtendedPlugInfoPlugTypeSpecificData::EExtendedPlugInfoPlugType>( plugType ); 
     179        m_infoPlugType = static_cast<ExtendedPlugInfoPlugTypeSpecificData::EExtendedPlugInfoPlugType>( plugType ); 
    170180    } 
    171181 
     
    325335AvPlug::discoverClusterInfo() 
    326336{ 
    327     if ( m_type == ExtendedPlugInfoPlugTypeSpecificData::eEPIPT_Sync ) 
     337    if ( m_infoPlugType == ExtendedPlugInfoPlugTypeSpecificData::eEPIPT_Sync ) 
    328338    { 
    329339        // If the plug is of type sync it is either a normal 2 channel 
     
    402412        debugOutput( DEBUG_LEVEL_VERBOSE, 
    403413                     "discoverStreamFormat: %s plug %d uses " 
    404                      "sampling frequency %d\n", 
     414                     "sampling frequency %d, nr of stream infos = %d\n", 
    405415                     m_name.c_str(), 
    406416                     m_id, 
    407                      m_samplingFrequency ); 
     417                     m_samplingFrequency, 
     418                     compoundStream->m_numberOfStreamFormatInfos ); 
    408419 
    409420        for ( int i = 1; 
     
    422433                compoundStream->m_streamFormatInfos[ i - 1 ]; 
    423434 
     435            debugOutput( DEBUG_LEVEL_VERBOSE, "discoverStreamFormat: " 
     436                         "number of channels = %d, stream format = %d\n", 
     437                         streamFormatInfo->m_numberOfChannels, 
     438                         streamFormatInfo->m_streamFormat ); 
     439 
    424440            int nrOfChannels = clusterInfo->m_nrOfChannels; 
    425441            if ( streamFormatInfo->m_streamFormat == 
     
    430446            } 
    431447            // sanity checks 
    432             if (  nrOfChannels != 
    433                   streamFormatInfo->m_numberOfChannels ) 
     448            if ( nrOfChannels != streamFormatInfo->m_numberOfChannels ) 
    434449            { 
    435450                debugError( "discoverStreamFormat: Number of channels " 
    436                             "mismatch: %s plug %d discovering reported " 
     451                            "mismatch: '%s' plug %d discovering reported " 
    437452                            "%d channels for cluster '%s', while stream " 
    438453                            "format reported %d\n", 
     
    571586    case AVCCommand::eST_Unit: 
    572587        { 
    573             UnitPlugAddress unitPlugAddress( UnitPlugAddress::ePT_PCR, 
     588            UnitPlugAddress::EPlugType ePlugType = UnitPlugAddress::ePT_Unknown; 
     589            switch ( m_type ) { 
     590                case eAP_PCR: 
     591                    ePlugType = UnitPlugAddress::ePT_PCR; 
     592                    break; 
     593                case eAP_ExternalPlug: 
     594                    ePlugType = UnitPlugAddress::ePT_ExternalPlug; 
     595                    break; 
     596                case eAP_AsynchronousPlug: 
     597                    ePlugType = UnitPlugAddress::ePT_AsynchronousPlug; 
     598                    break; 
     599                default: 
     600                    ePlugType = UnitPlugAddress::ePT_Unknown; 
     601            } 
     602            UnitPlugAddress unitPlugAddress( ePlugType, 
    574603                                             m_id ); 
    575604            extPlugInfoCmd.setPlugAddress( PlugAddress( m_direction, 
     
    606635    case AVCCommand::eST_Unit: 
    607636    { 
    608         UnitPlugAddress unitPlugAddress( UnitPlugAddress::ePT_PCR, 
     637            UnitPlugAddress::EPlugType ePlugType = UnitPlugAddress::ePT_Unknown; 
     638            switch ( m_type ) { 
     639                case eAP_PCR: 
     640                    ePlugType = UnitPlugAddress::ePT_PCR; 
     641                    break; 
     642                case eAP_ExternalPlug: 
     643                    ePlugType = UnitPlugAddress::ePT_ExternalPlug; 
     644                    break; 
     645                case eAP_AsynchronousPlug: 
     646                    ePlugType = UnitPlugAddress::ePT_AsynchronousPlug; 
     647                    break; 
     648                default: 
     649                    ePlugType = UnitPlugAddress::ePT_Unknown; 
     650            } 
     651        UnitPlugAddress unitPlugAddress( ePlugType, 
    609652                                         m_id ); 
    610653        extStreamFormatInfoCmd.setPlugAddress( PlugAddress( m_direction, 
  • trunk/libfreebob/src/avplug.h

    r157 r158  
    3535class AvPlug { 
    3636public: 
     37 
     38    enum EAvPlugType { 
     39        eAP_PCR, 
     40        eAP_ExternalPlug, 
     41        eAP_AsynchronousPlug, 
     42        eAP_SubunitPlug, 
     43    }; 
     44 
    3745    AvPlug( Ieee1394Service& ieee1394Service, 
    3846            int m_nodeId, 
    3947            AVCCommand::ESubunitType subunitType, 
    4048            subunit_id_t subunitId, 
     49            EAvPlugType plugType, 
    4150            PlugAddress::EPlugDirection plugDirection, 
    4251            plug_id_t plugId ); 
     
    4655    bool discover(); 
    4756 
    48     ExtendedPlugInfoPlugTypeSpecificData::EExtendedPlugInfoPlugType 
    49         getPlugType() 
    50         { return m_type; } 
    5157    plug_id_t      getPlugId() 
    5258        { return m_id; } 
     
    9298    AVCCommand::ESubunitType     m_subunitType; 
    9399    subunit_id_t                 m_subunitId; 
     100    EAvPlugType                  m_type; 
    94101    PlugAddress::EPlugDirection  m_direction; 
    95102    plug_id_t                    m_id; 
    96103 
    97     // Plug type 
    98     ExtendedPlugInfoPlugTypeSpecificData::EExtendedPlugInfoPlugType m_type; 
     104    // Info plug type 
     105    ExtendedPlugInfoPlugTypeSpecificData::EExtendedPlugInfoPlugType m_infoPlugType; 
    99106 
    100107    // Number of channels 
  • trunk/libfreebob/src/libfreebobavc/avc_extended_cmd_generic.h

    r125 r158  
    3838        ePT_ExternalPlug     = 0x01, 
    3939        ePT_AsynchronousPlug = 0x02, 
     40        ePT_Unknown          = 0xff, 
    4041    }; 
    4142