Changeset 378

Show
Ignore:
Timestamp:
01/21/07 04:05:19 (16 years ago)
Author:
wagi
Message:

FunctionBlock?: De/Serialize added

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/libfreebob/src/bebob/bebob_avdevice.cpp

    r376 r378  
    11/* bebob_avdevice.cpp 
    2  * Copyright (C) 2005,06 by Daniel Wagner 
     2 * Copyright (C) 2005,06,07 by Daniel Wagner 
    33 * 
    44 * This file is part of FreeBoB. 
    …… 
    12321232} 
    12331233 
    1234  
    1235 template <typename T> bool serializeVector( Glib::ustring path, 
    1236                                             Util::IOSerialize& ser, 
    1237                                             T& vec ) 
    1238 { 
    1239     bool result = true; // if vec.size() == 0 
    1240     int i = 0; 
    1241     for ( typename T::iterator it = vec.begin(); it != vec.end(); ++it ) { 
    1242         std::ostringstream strstrm; 
    1243         strstrm << path << i; 
    1244         result &= ( *it )->serialize( strstrm.str() + "/", ser ); 
    1245         i++; 
    1246     } 
    1247     return result; 
    1248 } 
    1249  
    1250 template <typename T, typename VT> bool deserializeVector( Glib::ustring path, 
    1251                                                            Util::IODeserialize& deser, 
    1252                                                            AvDevice& avDevice, 
    1253                                                            VT& vec ) 
    1254 { 
    1255     int i = 0; 
    1256     bool bFinished = false; 
    1257     do { 
    1258         std::ostringstream strstrm; 
    1259         strstrm << path << i; 
    1260         T* ptr = T::deserialize( strstrm.str() + "/", 
    1261                                  deser, 
    1262                                  avDevice ); 
    1263         if ( ptr ) { 
    1264             vec.push_back( ptr ); 
    1265             i++; 
    1266         } else { 
    1267             bFinished = true; 
    1268         } 
    1269     } while ( !bFinished ); 
    1270  
    1271     return true; 
    1272 } 
    1273  
    12741234static bool 
    12751235deserializeAvPlugUpdateConnections( Glib::ustring path, 
    …… 
    12901250bool 
    12911251AvDevice::serialize( Glib::ustring 
    1292                      basePath, Util::IOSerialize& ser ) 
     1252                     basePath, Util::IOSerialize& ser ) const 
    12931253{ 
    12941254    bool result; 

  • trunk/libfreebob/src/bebob/bebob_avdevice.h

    r375 r378  
    4040#include "iavdevice.h" 
    4141 
     42#include <sstream> 
     43 
    4244class ConfigRom; 
    4345class Ieee1394Service; 
    …… 
    99101    bool setActiveSync( const SyncInfo& syncInfo ); 
    100102 
    101     bool serialize( Glib::ustring basePath, Util::IOSerialize& ser ); 
     103    bool serialize( Glib::ustring basePath, Util::IOSerialize& ser ) const; 
    102104    static AvDevice* deserialize( Glib::ustring basePath, 
    103105                                  Util::IODeserialize& deser, 
    …… 
    168170}; 
    169171 
     172template <typename T> bool serializeVector( Glib::ustring path, 
     173                                            Util::IOSerialize& ser, 
     174                                            const T& vec ) 
     175{ 
     176    bool result = true; // if vec.size() == 0 
     177    int i = 0; 
     178    for ( typename T::const_iterator it = vec.begin(); it != vec.end(); ++it ) { 
     179        std::ostringstream strstrm; 
     180        strstrm << path << i; 
     181        result &= ( *it )->serialize( strstrm.str() + "/", ser ); 
     182        i++; 
     183    } 
     184    return result; 
    170185} 
    171186 
     187template <typename T, typename VT> bool deserializeVector( Glib::ustring path, 
     188                                                           Util::IODeserialize& deser, 
     189                                                           AvDevice& avDevice, 
     190                                                           VT& vec ) 
     191{ 
     192    int i = 0; 
     193    bool bFinished = false; 
     194    do { 
     195        std::ostringstream strstrm; 
     196        strstrm << path << i << "/"; 
     197        T* ptr = T::deserialize( strstrm.str(), 
     198                                 deser, 
     199                                 avDevice ); 
     200        if ( ptr ) { 
     201            vec.push_back( ptr ); 
     202            i++; 
     203        } else { 
     204            bFinished = true; 
     205        } 
     206    } while ( !bFinished ); 
     207 
     208    return true; 
     209} 
     210 
     211} 
     212 
    172213#endif 

  • trunk/libfreebob/src/bebob/bebob_avdevice_subunit.cpp

    r376 r378  
    535535        FunctionBlock* pFB = FunctionBlock::deserialize( strstrm.str(), 
    536536                                                         deser, 
    537                                                          avDevice ); 
     537                                                         avDevice, 
     538                                                         *this ); 
    538539        if ( pFB ) { 
    539540            m_functions.push_back( pFB ); 

  • trunk/libfreebob/src/bebob/bebob_functionblock.cpp

    r376 r378  
    2424#include "configrom.h" 
    2525 
    26 namespace BeBoB { 
    27  
    28 IMPL_DEBUG_MODULE( FunctionBlock, FunctionBlock, DEBUG_LEVEL_NORMAL ); 
    29  
    30 FunctionBlock::FunctionBlock( 
     26 
     27IMPL_DEBUG_MODULE( BeBoB::FunctionBlock, BeBoB::FunctionBlock, DEBUG_LEVEL_NORMAL ); 
     28 
     29BeBoB::FunctionBlock::FunctionBlock( 
    3130    AvDeviceSubunit& subunit, 
    3231    function_block_type_t type, 
     32    function_block_type_t subtype, 
    3333    function_block_id_t id, 
    3434    ESpecialPurpose purpose, 
    …… 
    3838    : m_subunit( &subunit ) 
    3939    , m_type( type ) 
     40    , m_subtype( subtype ) 
    4041    , m_id( id ) 
    4142    , m_purpose( purpose ) 
    …… 
    4748} 
    4849 
    49 FunctionBlock::FunctionBlock( const FunctionBlock& rhs ) 
     50BeBoB::FunctionBlock::FunctionBlock( const FunctionBlock& rhs ) 
    5051    : m_subunit( rhs.m_subunit ) 
    5152    , m_type( rhs.m_type ) 
     53    , m_subtype( rhs.m_subtype ) 
    5254    , m_id( rhs.m_id ) 
    5355    , m_purpose( rhs.m_purpose ) 
    …… 
    5860} 
    5961 
    60 FunctionBlock::~FunctionBlock() 
     62BeBoB::FunctionBlock::FunctionBlock() 
     63{ 
     64} 
     65 
     66BeBoB::FunctionBlock::~FunctionBlock() 
    6167{ 
    6268    for ( AvPlugVector::iterator it = m_plugs.begin(); 
    …… 
    7076 
    7177bool 
    72 FunctionBlock::discover() 
     78BeBoB::FunctionBlock::discover() 
    7379{ 
    7480    debugOutput( DEBUG_LEVEL_VERBOSE, 
    …… 
    95101 
    96102bool 
    97 FunctionBlock::discoverPlugs( AvPlug::EAvPlugDirection plugDirection, 
    98                               plug_id_t plugMaxId ) 
     103BeBoB::FunctionBlock::discoverPlugs( AvPlug::EAvPlugDirection plugDirection, 
     104                                     plug_id_t plugMaxId ) 
    99105{ 
    100106    for ( int plugId = 0; plugId < plugMaxId; ++plugId ) { 
    …… 
    128134 
    129135bool 
    130 FunctionBlock::discoverConnections() 
     136BeBoB::FunctionBlock::discoverConnections() 
    131137{ 
    132138    debugOutput( DEBUG_LEVEL_VERBOSE, 
    …… 
    148154 
    149155bool 
    150 FunctionBlock::serialize( Glib::ustring basePath, Util::IOSerialize& ser ) const 
    151 { 
    152     int dummy = 42; 
    153     return ser.write( basePath + "dummy", dummy ); 
    154 } 
    155  
    156 FunctionBlock* 
    157 FunctionBlock::deserialize( Glib::ustring basePath, 
    158                             Util::IODeserialize& deser, 
    159                             AvDevice& avDevice ) 
    160 { 
     156serializeAvPlugVector( Glib::ustring basePath, 
     157                       Util::IOSerialize& ser, 
     158                       const BeBoB::AvPlugVector& vec ) 
     159{ 
     160    bool result = true; 
     161    int i = 0; 
     162    for ( BeBoB::AvPlugVector::const_iterator it = vec.begin(); 
     163          it != vec.end(); 
     164          ++it ) 
     165    { 
     166        std::ostringstream strstrm; 
     167        strstrm << basePath << i; 
     168        result &= ser.write( strstrm.str(), ( *it )->getGlobalId() ); 
     169        i++; 
     170    } 
     171    return result; 
     172} 
     173 
     174bool 
     175deserializeAvPlugVector( Glib::ustring basePath, 
     176                         Util::IODeserialize& deser, 
     177                         BeBoB::AvDevice& avDevice, 
     178                         BeBoB::AvPlugVector& vec ) 
     179{ 
     180    int i = 0; 
     181    bool bFinished = false; 
     182    bool result = true; 
     183    do { 
     184        plug_id_t plugId; 
     185        std::ostringstream strstrm; 
     186        strstrm << basePath << i; 
     187 
     188        result &= deser.read( strstrm.str(), plugId ); 
     189        BeBoB::AvPlug* pPlug = avDevice.getPlugManager().getPlug( plugId ); 
     190 
     191        if ( pPlug ) { 
     192            vec.push_back( pPlug ); 
     193            i++; 
     194        } else { 
     195            bFinished = true; 
     196        } 
     197    } while ( !bFinished ); 
     198 
     199    return result; 
     200} 
     201 
     202bool 
     203BeBoB::FunctionBlock::serialize( Glib::ustring basePath, Util::IOSerialize& ser ) const 
     204{ 
     205    bool result; 
     206 
     207    result  = ser.write( basePath + "m_type", m_type ); 
     208    result &= ser.write( basePath + "m_subtype", m_subtype ); 
     209    result &= ser.write( basePath + "m_id", m_id ); 
     210    result &= ser.write( basePath + "m_purpose", m_purpose ); 
     211    result &= ser.write( basePath + "m_nrOfInputPlugs", m_nrOfInputPlugs ); 
     212    result &= ser.write( basePath + "m_nrOfOutputPlugs", m_nrOfOutputPlugs ); 
     213    result &= ser.write( basePath + "m_verbose", m_verbose ); 
     214    result &= serializeAvPlugVector( basePath + "m_plugs", ser, m_plugs ); 
     215 
     216    return result; 
     217} 
     218 
     219BeBoB::FunctionBlock* 
     220BeBoB::FunctionBlock::deserialize( Glib::ustring basePath, 
     221                                   Util::IODeserialize& deser, 
     222                                   AvDevice& avDevice, 
     223                                   AvDeviceSubunit& subunit ) 
     224{ 
     225    bool result; 
     226    function_block_type_t type; 
     227    function_block_type_t subtype; 
     228    FunctionBlock* pFB = 0; 
     229 
     230    result  = deser.read( basePath + "m_type", type ); 
     231    result &= deser.read( basePath + "m_subtype", subtype ); 
     232    if ( !result ) { 
     233        return 0; 
     234    } 
     235 
     236    switch ( type ) { 
     237    case ExtendedSubunitInfoCmd::eFBT_AudioSubunitSelector: 
     238        pFB = new FunctionBlockSelector; 
     239        break; 
     240    case ExtendedSubunitInfoCmd::eFBT_AudioSubunitFeature: 
     241        pFB = new FunctionBlockFeature; 
     242        break; 
     243    case ExtendedSubunitInfoCmd::eFBT_AudioSubunitProcessing: 
     244        if ( subtype == ExtendedSubunitInfoCmd::ePT_EnhancedMixer ) { 
     245            pFB = new FunctionBlockEnhancedMixer; 
     246        } else { 
     247            pFB = new FunctionBlockProcessing; 
     248        } 
     249        break; 
     250    case ExtendedSubunitInfoCmd::eFBT_AudioSubunitCodec: 
     251        pFB = new FunctionBlockCodec; 
     252        break; 
     253    default: 
     254        pFB = 0; 
     255    } 
     256 
     257    if ( !pFB ) { 
     258        return 0; 
     259    } 
     260 
     261    pFB->m_subunit = &subunit; 
     262    pFB->m_type = type; 
     263    pFB->m_subtype = subtype; 
     264 
     265    result &= deser.read( basePath + "m_id", pFB->m_id ); 
     266    result &= deser.read( basePath + "m_purpose", pFB->m_purpose ); 
     267    result &= deser.read( basePath + "m_nrOfInputPlugs", pFB->m_nrOfInputPlugs ); 
     268    result &= deser.read( basePath + "m_nrOfOutputPlugs", pFB->m_nrOfOutputPlugs ); 
     269    result &= deser.read( basePath + "m_verbose", pFB->m_verbose ); 
     270    result &= deserializeAvPlugVector( basePath + "m_plugs", deser, avDevice, pFB->m_plugs ); 
     271 
    161272    return 0; 
    162273} 
    …… 
    164275/////////////////////// 
    165276 
    166 FunctionBlockSelector::FunctionBlockSelector( 
     277BeBoB::FunctionBlockSelector::FunctionBlockSelector( 
    167278    AvDeviceSubunit& subunit, 
    168279    function_block_id_t id, 
    …… 
    173284    : FunctionBlock( subunit, 
    174285                     eFBT_AudioSubunitSelector, 
     286                     0, 
    175287                     id, 
    176288                     purpose, 
    …… 
    181293} 
    182294 
    183 FunctionBlockSelector::FunctionBlockSelector( 
     295BeBoB::FunctionBlockSelector::FunctionBlockSelector( 
    184296    const FunctionBlockSelector& rhs ) 
    185297    : FunctionBlock( rhs ) 
    …… 
    187299} 
    188300 
    189 FunctionBlockSelector::~FunctionBlockSelector() 
     301BeBoB::FunctionBlockSelector::FunctionBlockSelector() 
     302    : FunctionBlock() 
     303{ 
     304} 
     305 
     306BeBoB::FunctionBlockSelector::~FunctionBlockSelector() 
    190307{ 
    191308} 
    192309 
    193310const char* 
    194 FunctionBlockSelector::getName() 
     311BeBoB::FunctionBlockSelector::getName() 
    195312{ 
    196313    return "Selector"; 
    197314} 
    198315 
     316bool 
     317BeBoB::FunctionBlockSelector::serializeChild( Glib::ustring basePath, 
     318                                              Util::IOSerialize& ser ) const 
     319{ 
     320    return true; 
     321} 
     322 
     323bool 
     324BeBoB::FunctionBlockSelector::deserializeChild( Glib::ustring basePath, 
     325                                                Util::IODeserialize& deser, 
     326                                                AvDevice& avDevice ) 
     327{ 
     328    return true; 
     329} 
     330 
    199331/////////////////////// 
    200332 
    201 FunctionBlockFeature::FunctionBlockFeature( 
     333BeBoB::FunctionBlockFeature::FunctionBlockFeature( 
    202334    AvDeviceSubunit& subunit, 
    203335    function_block_id_t id, 
    …… 
    208340    : FunctionBlock( subunit, 
    209341                     eFBT_AudioSubunitFeature, 
     342                     0, 
    210343                     id, 
    211344                     purpose, 
    …… 
    216349} 
    217350 
    218 FunctionBlockFeature::FunctionBlockFeature( 
     351BeBoB::FunctionBlockFeature::FunctionBlockFeature( 
    219352    const FunctionBlockFeature& rhs ) 
    220353    : FunctionBlock( rhs ) 
    …… 
    222355} 
    223356 
    224 FunctionBlockFeature::~FunctionBlockFeature() 
     357BeBoB::FunctionBlockFeature::FunctionBlockFeature() 
     358    : FunctionBlock() 
     359{ 
     360} 
     361 
     362BeBoB::FunctionBlockFeature::~FunctionBlockFeature() 
    225363{ 
    226364} 
    227365 
    228366const char* 
    229 FunctionBlockFeature::getName() 
     367BeBoB::FunctionBlockFeature::getName() 
    230368{ 
    231369    return "Feature"; 
    232370} 
    233371 
     372bool 
     373BeBoB::FunctionBlockFeature::serializeChild( Glib::ustring basePath, 
     374                                             Util::IOSerialize& ser ) const 
     375{ 
     376    return true; 
     377} 
     378 
     379bool 
     380BeBoB::FunctionBlockFeature::deserializeChild( Glib::ustring basePath, 
     381                                               Util::IODeserialize& deser, 
     382                                               AvDevice& avDevice ) 
     383{ 
     384    return true; 
     385} 
     386 
    234387/////////////////////// 
    235388 
    236 FunctionBlockEnhancedMixer::FunctionBlockEnhancedMixer( 
     389BeBoB::FunctionBlockEnhancedMixer::FunctionBlockEnhancedMixer( 
    237390    AvDeviceSubunit& subunit, 
    238391    function_block_id_t id, 
    …… 
    243396    : FunctionBlock( subunit, 
    244397                     eFBT_AudioSubunitProcessing, 
     398                     ExtendedSubunitInfoCmd::ePT_EnhancedMixer, 
    245399                     id, 
    246400                     purpose, 
    …… 
    251405} 
    252406 
    253 FunctionBlockEnhancedMixer::FunctionBlockEnhancedMixer( 
     407BeBoB::FunctionBlockEnhancedMixer::FunctionBlockEnhancedMixer( 
    254408    const FunctionBlockEnhancedMixer& rhs ) 
    255409    : FunctionBlock( rhs ) 
    …… 
    257411} 
    258412 
    259 FunctionBlockEnhancedMixer::~FunctionBlockEnhancedMixer() 
     413BeBoB::FunctionBlockEnhancedMixer::FunctionBlockEnhancedMixer() 
     414    : FunctionBlock() 
     415{ 
     416} 
     417 
     418BeBoB::FunctionBlockEnhancedMixer::~FunctionBlockEnhancedMixer() 
    260419{ 
    261420} 
    262421 
    263422const char* 
    264 FunctionBlockEnhancedMixer::getName() 
     423BeBoB::FunctionBlockEnhancedMixer::getName() 
    265424{ 
    266425    return "EnhancedMixer"; 
    267426} 
    268427 
     428bool 
     429BeBoB::FunctionBlockEnhancedMixer::serializeChild( Glib::ustring basePath, 
     430                                                   Util::IOSerialize& ser ) const 
     431{ 
     432    return true; 
     433} 
     434 
     435bool 
     436BeBoB::FunctionBlockEnhancedMixer::deserializeChild( Glib::ustring basePath, 
     437                                                     Util::IODeserialize& deser, 
     438                                                     AvDevice& avDevice ) 
     439{ 
     440    return true; 
     441} 
     442 
    269443/////////////////////// 
    270444 
    271 FunctionBlockProcessing::FunctionBlockProcessing( 
     445BeBoB::FunctionBlockProcessing::FunctionBlockProcessing( 
    272446    AvDeviceSubunit& subunit, 
    273447    function_block_id_t id, 
    …… 
    278452    : FunctionBlock( subunit, 
    279453                     eFBT_AudioSubunitProcessing, 
     454                     0, 
    280455                     id, 
    281456                     purpose, 
    …… 
    286461} 
    287462 
    288 FunctionBlockProcessing::FunctionBlockProcessing( 
     463BeBoB::FunctionBlockProcessing::FunctionBlockProcessing( 
    289464    const FunctionBlockProcessing& rhs ) 
    290465    : FunctionBlock( rhs ) 
    …… 
    292467} 
    293468 
    294 FunctionBlockProcessing::~FunctionBlockProcessing() 
     469BeBoB::FunctionBlockProcessing::FunctionBlockProcessing() 
     470    : FunctionBlock() 
     471{ 
     472} 
     473 
     474BeBoB::FunctionBlockProcessing::~FunctionBlockProcessing() 
    295475{ 
    296476} 
    297477 
    298478const char* 
    299 FunctionBlockProcessing::getName() 
     479BeBoB::FunctionBlockProcessing::getName() 
    300480{ 
    301481    return "Dummy Processing"; 
    302482} 
    303483 
     484bool 
     485BeBoB::FunctionBlockProcessing::serializeChild( Glib::ustring basePath, 
     486                                                Util::IOSerialize& ser ) const 
     487{ 
     488    return true; 
     489} 
     490 
     491bool 
     492BeBoB::FunctionBlockProcessing::deserializeChild( Glib::ustring basePath, 
     493                                                  Util::IODeserialize& deser, 
     494                                                  AvDevice& avDevice ) 
     495{ 
     496    return true; 
     497} 
     498 
    304499/////////////////////// 
    305500 
    306 FunctionBlockCodec::FunctionBlockCodec( 
     501BeBoB::FunctionBlockCodec::FunctionBlockCodec( 
    307502    AvDeviceSubunit& subunit, 
    308503    function_block_id_t id, 
    …… 
    313508    : FunctionBlock( subunit, 
    314509                     eFBT_AudioSubunitCodec, 
     510                     0, 
    315511                     id, 
    316512                     purpose, 
    …… 
    321517} 
    322518 
    323 FunctionBlockCodec::FunctionBlockCodec( const FunctionBlockCodec& rhs ) 
     519BeBoB::FunctionBlockCodec::FunctionBlockCodec( const FunctionBlockCodec& rhs ) 
    324520    : FunctionBlock( rhs ) 
    325521{ 
    326522} 
    327523 
    328 FunctionBlockCodec::~FunctionBlockCodec() 
     524BeBoB::FunctionBlockCodec::FunctionBlockCodec() 
     525    : FunctionBlock() 
     526{ 
     527} 
     528 
     529BeBoB::FunctionBlockCodec::~FunctionBlockCodec() 
    329530{ 
    330531} 
    331532 
    332533const char* 
    333 FunctionBlockCodec::getName() 
     534BeBoB::FunctionBlockCodec::getName() 
    334535{ 
    335536    return "Dummy Codec"; 
    336537} 
    337538 
    338 } 
     539bool 
     540BeBoB::FunctionBlockCodec::serializeChild( Glib::ustring basePath, 
     541                                           Util::IOSerialize& ser ) const 
     542{ 
     543    return true; 
     544} 
     545 
     546bool 
     547BeBoB::FunctionBlockCodec::deserializeChild( Glib::ustring basePath, 
     548                                             Util::IODeserialize& deser, 
     549                                             AvDevice& avDevice ) 
     550{ 
     551    return true; 
     552} 

  • trunk/libfreebob/src/bebob/bebob_functionblock.h

    r376 r378  
    11/* bebob_functionblock.h 
    2  * Copyright (C) 2006 by Daniel Wagner 
     2 * Copyright (C) 2006,07 by Daniel Wagner 
    33 * 
    44 * This file is part of FreeBoB. 
    …… 
    4949    FunctionBlock( AvDeviceSubunit& subunit, 
    5050                   function_block_type_t type, 
     51                   function_block_type_t subtype, 
    5152                   function_block_id_t id, 
    5253                   ESpecialPurpose purpose, 
    …… 
    5556                   int verbose ); 
    5657    FunctionBlock( const FunctionBlock& rhs ); 
     58    FunctionBlock(); 
    5759    virtual ~FunctionBlock(); 
    5860 
    …… 
    6567    static FunctionBlock* deserialize( Glib::ustring basePath, 
    6668                                       Util::IODeserialize& deser, 
    67                                        AvDevice& avDevice ); 
     69                                       AvDevice& avDevice, 
     70                                       AvDeviceSubunit& subunit); 
    6871protected: 
    6972    bool discoverPlugs( AvPlug::EAvPlugDirection plugDirection, 
    …… 
    7376    AvDeviceSubunit*      m_subunit; 
    7477    function_block_type_t m_type; 
     78    function_block_type_t m_subtype; 
    7579    function_block_id_t   m_id; 
    7680    ESpecialPurpose       m_purpose; 
    7781    no_of_input_plugs_t   m_nrOfInputPlugs; 
    7882    no_of_output_plugs_t  m_nrOfOutputPlugs; 
    79     int m_verbose; 
    80  
    81     AvPlugVector m_plugs; 
     83    int                   m_verbose; 
     84    AvPlugVector          m_plugs; 
    8285 
    8386    DECLARE_DEBUG_MODULE; 
    …… 
    99102                          int verbose); 
    100103    FunctionBlockSelector( const FunctionBlockSelector& rhs ); 
     104    FunctionBlockSelector(); 
    101105    virtual ~FunctionBlockSelector(); 
    102106 
    103107    virtual const char* getName(); 
     108 
     109protected: 
     110    virtual bool serializeChild( Glib::ustring basePath, 
     111                                 Util::IOSerialize& ser ) const; 
     112    virtual bool deserializeChild( Glib::ustring basePath, 
     113                                   Util::IODeserialize& deser, 
     114                                   AvDevice& avDevice ); 
    104115}; 
    105116 
    …… 
    116127                         int verbose); 
    117128    FunctionBlockFeature( const FunctionBlockFeature& rhs ); 
     129    FunctionBlockFeature(); 
    118130    virtual ~FunctionBlockFeature(); 
    119131 
    120132    virtual const char* getName(); 
     133 
     134protected: 
     135    virtual bool serializeChild( Glib::ustring basePath, 
     136                                 Util::IOSerialize& ser ) const; 
     137    virtual bool deserializeChild( Glib::ustring basePath, 
     138                                   Util::IODeserialize& deser, 
     139                                   AvDevice& avDevice ); 
    121140}; 
    122141 
    …… 
    132151                                no_of_output_plugs_t nrOfOutputPlugs, 
    133152                                int verbose ); 
     153    FunctionBlockEnhancedMixer(); 
    134154    FunctionBlockEnhancedMixer( const FunctionBlockEnhancedMixer& rhs ); 
    135155    virtual ~FunctionBlockEnhancedMixer(); 
    136156 
    137157    virtual const char* getName(); 
     158 
     159protected: 
     160    virtual bool serializeChild( Glib::ustring basePath, 
     161                                 Util::IOSerialize& ser ) const; 
     162    virtual bool deserializeChild( Glib::ustring basePath, 
     163                                   Util::IODeserialize& deser, 
     164                                   AvDevice& avDevice ); 
    138165}; 
    139166 
    …… 
    150177                             int verbose ); 
    151178    FunctionBlockProcessing( const FunctionBlockProcessing& rhs ); 
     179    FunctionBlockProcessing(); 
    152180    virtual ~FunctionBlockProcessing(); 
    153181 
    154182    virtual const char* getName(); 
     183 
     184protected: 
     185    virtual bool serializeChild( Glib::ustring basePath, 
     186                                 Util::IOSerialize& ser ) const; 
     187    virtual bool deserializeChild( Glib::ustring basePath, 
     188                                   Util::IODeserialize& deser, 
     189                                   AvDevice& avDevice ); 
    155190}; 
    156191 
    …… 
    167202                       int verbose); 
    168203    FunctionBlockCodec( const FunctionBlockCodec& rhs ); 
     204    FunctionBlockCodec(); 
    169205    virtual ~FunctionBlockCodec(); 
    170206 
    171207    virtual const char* getName(); 
     208 
     209protected: 
     210    virtual bool serializeChild( Glib::ustring basePath, 
     211                                 Util::IOSerialize& ser ) const; 
     212    virtual bool deserializeChild( Glib::ustring basePath, 
     213                                   Util::IODeserialize& deser, 
     214                                   AvDevice& avDevice ); 
    172215}; 
    173216 

  • trunk/libfreebob/src/libfreebobavc/avc_extended_subunit_info.h

    r375 r378  
    6666 
    6767    enum EProcessingType { 
     68        ePT_Unknown                 = 0x00, 
    6869        ePT_Mixer                   = 0x01, 
    6970        ePT_Generic                 = 0x02, 

  • trunk/libfreebob/src/libfreebobavc/avc_function_block.h

    r375 r378  
    9191    // Control selector encoding 
    9292    enum EControlSelectorEncoding { 
     93        eCSE_Selector_Unknown           = 0x00, 
    9394        eCSE_Selector_Selector          = 0x01, 
    9495    }; 
    …… 
    115116    // Control selector encoding 
    116117    enum EControlSelectorEncoding { 
     118        eCSE_Feature_Unknown            = 0x00, 
    117119        eCSE_Feature_Mute               = 0x01, 
    118120        eCSE_Feature_Volume             = 0x02, 
    …… 
    163165    // Control selector encoding 
    164166    enum EControlSelectorEncoding { 
     167        eCSE_Processing_Unknown         = 0x00, 
    165168        eCSE_Processing_Enable          = 0x01, 
    166169        eCSE_Processing_Mode            = 0x02, 
    …… 
    168171        eCSE_Processing_EnhancedMixer   = 0xf1, 
    169172 
    170         // lots of definition missing 
     173        // lots of definitions missing 
    171174 
    172175    }; 
    …… 
    197200    // CODEC type endcoding 
    198201    enum ECodecTypeEncoding { 
     202        eCTE_Unknown                    = 0x00, 
    199203        eCTE_Ac3Decoder                 = 0x01, 
    200204        eCTE_MpegDecoder                = 0x02,