Changeset 1110

Show
Ignore:
Timestamp:
05/03/08 13:04:27 (12 years ago)
Author:
wagi
Message:

Lot's of small and big bug fixes allong the caching path.
There were several parts not correctly deserialized.

This should fix ticket #65

Files:

Legend:

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

    r871 r1110  
    386386} 
    387387 
     388bool 
     389BeBoB::SubunitAudio::deserializeUpdateChild( Glib::ustring basePath, 
     390                                             Util::IODeserialize& deser ) 
     391{ 
     392    bool result = true; 
     393    int i = 0; 
     394 
     395    for ( FunctionBlockVector::iterator it = m_functions.begin(); 
     396          it != m_functions.end(); 
     397          ++it ) 
     398    { 
     399        std::ostringstream strstrm; 
     400        strstrm << basePath << "FunctionBlock" << i << "/"; 
     401 
     402        result &= (*it)->deserializeUpdate( basePath, deser ); 
     403         
     404        i++; 
     405    } 
     406 
     407    return result; 
     408} 
     409 
    388410//////////////////////////////////////////// 
    389411 
     
    458480    return true; 
    459481} 
     482 
     483bool  
     484BeBoB::SubunitMusic::deserializeUpdateChild( Glib::ustring basePath, 
     485                                             Util::IODeserialize& deser ) 
     486{ 
     487    return true; 
     488} 
  • trunk/libffado/src/bebob/bebob_avdevice_subunit.h

    r864 r1110  
    8282                                   Util::IODeserialize& deser, 
    8383                                   AVC::Unit& unit ); 
     84    virtual bool deserializeUpdateChild( Glib::ustring basePath, 
     85                                         Util::IODeserialize& deser ); 
    8486 
    8587protected: 
     
    115117                                   Util::IODeserialize& deser, 
    116118                                   AVC::Unit& unit ); 
     119    virtual bool deserializeUpdateChild( Glib::ustring basePath, 
     120                                         Util::IODeserialize& deser ); 
    117121 
    118122}; 
  • trunk/libffado/src/bebob/bebob_functionblock.cpp

    r864 r1110  
    188188    FunctionBlock* pFB = 0; 
    189189 
     190    if ( !deser.isExisting( basePath + "m_type" ) ) { 
     191        return 0; 
     192    } 
     193 
    190194    result  = deser.read( basePath + "m_type", type ); 
    191195    result &= deser.read( basePath + "m_subtype", subtype ); 
     
    227231    result &= deser.read( basePath + "m_nrOfInputPlugs", pFB->m_nrOfInputPlugs ); 
    228232    result &= deser.read( basePath + "m_nrOfOutputPlugs", pFB->m_nrOfOutputPlugs ); 
    229     result &= deserializePlugVector( basePath + "m_plugs", deser, 
    230                                      unit.getPlugManager(), pFB->m_plugs ); 
    231  
    232     return 0; 
     233 
     234    if ( !result ) { 
     235        delete pFB; 
     236        return 0; 
     237    } 
     238 
     239    return pFB; 
     240
     241 
     242bool  
     243FunctionBlock::deserializeUpdate( Glib::ustring basePath, 
     244                                  Util::IODeserialize& deser ) 
     245
     246    bool result; 
     247 
     248    result = deserializePlugVector( basePath + "m_plugs", deser, 
     249                                    m_subunit->getUnit().getPlugManager(), m_plugs ); 
     250    return result; 
    233251} 
    234252 
  • trunk/libffado/src/bebob/bebob_functionblock.h

    r864 r1110  
    8080 
    8181    static FunctionBlock* deserialize( Glib::ustring basePath, 
    82                        Util::IODeserialize& deser, 
    83                        AVC::Unit& unit, 
    84                        AVC::Subunit& subunit); 
     82                                       Util::IODeserialize& deser, 
     83                                       AVC::Unit& unit, 
     84                                       AVC::Subunit& subunit ); 
     85    bool deserializeUpdate( Glib::ustring basePath, 
     86                            Util::IODeserialize& deser ); 
    8587protected: 
    8688    bool discoverPlugs( AVC::Plug::EPlugDirection plugDirection, 
  • trunk/libffado/src/genericavc/avc_avdevice.cpp

    r1029 r1110  
    248248        Plug::eAPT_Sync ); 
    249249    if ( !syncMSUInputPlugs.size() ) { 
    250         debugWarning( "No sync input plug for MSU subunit found\n" ); 
     250        // there exist devices which do not have a sync plug 
     251        // or their av/c model is broken.  
    251252        return r; 
    252253    } 
  • trunk/libffado/src/libavc/audiosubunit/avc_audiosubunit.h

    r864 r1110  
    5656                                   Util::IODeserialize& deser, 
    5757                                   Unit& avDevice ) { return true; } 
     58    virtual bool deserializeUpdateChild( Glib::ustring basePath, 
     59                                         Util::IODeserialize& deser ) { return true; } 
    5860 
    5961}; 
  • trunk/libffado/src/libavc/general/avc_plug.cpp

    r1047 r1110  
    5050            EPlugDirection plugDirection, 
    5151            plug_id_t plugId ) 
    52     : m_unit(unit
    53     , m_subunit(subunit
     52    : m_unit( unit
     53    , m_subunit( subunit
    5454    , m_functionBlockType( functionBlockType ) 
    5555    , m_functionBlockId( functionBlockId ) 
     
    16421642                   PlugManager& plugManager ) 
    16431643{ 
    1644     // FIXME: The derived class should be creating these, such that discover() can become pure virtual 
     1644    ESubunitType          subunitType; 
     1645    subunit_t             subunitId; 
     1646    function_block_type_t functionBlockType; 
     1647    function_block_id_t   functionBlockId; 
     1648    EPlugAddressType      addressType; 
     1649    EPlugDirection        direction; 
     1650    plug_id_t             id; 
     1651 
    16451652    if ( !deser.isExisting( basePath + "m_subunitType" ) ) { 
    16461653        return 0; 
    16471654    } 
    1648     Plug* pPlug = new Plug; 
     1655 
     1656    bool result=true; 
     1657 
     1658    result  = deser.read( basePath + "m_subunitType", subunitType ); 
     1659    result &= deser.read( basePath + "m_subunitId", subunitId ); 
     1660    Subunit* subunit = unit.getSubunit( subunitType, subunitId ); 
     1661 
     1662    result &= deser.read( basePath + "m_functionBlockType", functionBlockType ); 
     1663    result &= deser.read( basePath + "m_functionBlockId", functionBlockId ); 
     1664    result &= deser.read( basePath + "m_addressType", addressType ); 
     1665    result &= deser.read( basePath + "m_direction", direction ); 
     1666    result &= deser.read( basePath + "m_id", id ); 
     1667 
     1668    Plug* pPlug = unit.createPlug( &unit, subunit, functionBlockType,  
     1669                                   functionBlockId, addressType, direction, id); 
    16491670    if ( !pPlug ) { 
    16501671        return 0; 
    16511672    } 
    16521673 
    1653     pPlug->m_unit = &unit; 
    1654  
    1655     bool result=true; 
    1656  
    1657     result  = deser.read( basePath + "m_subunitType", pPlug->m_subunitType ); 
    1658     result &= deser.read( basePath + "m_subunitId", pPlug->m_subunitId ); 
    1659     result &= deser.read( basePath + "m_functionBlockType", pPlug->m_functionBlockType ); 
    1660     result &= deser.read( basePath + "m_functionBlockId", pPlug->m_functionBlockId ); 
    1661     result &= deser.read( basePath + "m_addressType", pPlug->m_addressType ); 
    1662     result &= deser.read( basePath + "m_direction", pPlug->m_direction ); 
    1663     result &= deser.read( basePath + "m_id", pPlug->m_id ); 
    16641674    result &= deser.read( basePath + "m_infoPlugType", pPlug->m_infoPlugType ); 
    16651675    result &= deser.read( basePath + "m_nrOfChannels", pPlug->m_nrOfChannels ); 
     
    21722182 
    21732183    int i = 0; 
    2174     bool bFinished = false
     2184    Plug* pPlug = 0
    21752185    do { 
    21762186        std::ostringstream strstrm; 
     
    21782188        // unit still holds a null pointer for the plug manager 
    21792189        // therefore we have to *this as additional argument 
    2180         Plug* pPlug = Plug::deserialize( strstrm.str() + "/", 
    2181                                          deser, 
    2182                                          unit, 
    2183                                          *pMgr ); 
     2190        pPlug = Plug::deserialize( strstrm.str() + "/", 
     2191                                   deser, 
     2192                                   unit, 
     2193                                   *pMgr ); 
    21842194        if ( pPlug ) { 
    21852195            pMgr->m_plugs.push_back( pPlug ); 
    21862196            i++; 
    2187         } else { 
    2188             bFinished = true; 
    2189         } 
    2190     } while ( !bFinished ); 
     2197        } 
     2198    } while ( pPlug ); 
    21912199 
    21922200    return pMgr; 
     
    23772385{ 
    23782386    int i = 0; 
    2379     bool bFinished = false; 
    2380     bool result = true; 
     2387    Plug* pPlug = 0; 
    23812388    do { 
    23822389        std::ostringstream strstrm; 
     2390        unsigned int iPlugId; 
     2391 
    23832392        strstrm << basePath << i; 
    23842393 
    2385         // check for one element to exist. when one exist the other elements 
    2386         // must also be there. otherwise just return (last) result. 
    2387         if ( deser.isExisting( strstrm.str() + "/global_id" ) ) { 
    2388             unsigned int iPlugId; 
    2389             result &= deser.read( strstrm.str() + "/global_id", iPlugId ); 
    2390  
    2391             if ( result ) { 
    2392                 Plug* pPlug = plugManager.getPlug( iPlugId ); 
    2393                 if ( pPlug ) { 
    2394                     vec.push_back( pPlug ); 
    2395                 } else { 
    2396                     result = false; 
    2397                     bFinished = true; 
    2398                 } 
    2399                 i++; 
    2400             } else { 
    2401                 bFinished = true; 
    2402             } 
    2403         } else { 
    2404             bFinished = true; 
    2405         } 
    2406     } while ( !bFinished ); 
    2407  
    2408     return result; 
    2409 
    2410  
    2411 
     2394        if ( !deser.isExisting( strstrm.str() + "/global_id" ) ) { 
     2395            // no more plugs found, so this is the normal return point 
     2396            return true; 
     2397        } 
     2398 
     2399        if ( !deser.read( strstrm.str() + "/global_id", iPlugId ) ) { 
     2400            return false; 
     2401        } 
     2402   
     2403        pPlug = plugManager.getPlug( iPlugId ); 
     2404        if ( pPlug ) { 
     2405            vec.push_back( pPlug ); 
     2406            i++; 
     2407        } 
     2408    } while ( pPlug ); 
     2409 
     2410    // if we reach here, the plug manager didn't find any plug with the id iPlugId. 
     2411    return false; 
     2412
     2413 
     2414
  • trunk/libffado/src/libavc/general/avc_subunit.cpp

    r1047 r1110  
    258258    result  = deser.read( basePath + "m_sbType", sbType ); 
    259259 
    260     Subunit* pSubunit = 0; 
    261  
    262     // FIXME: The derived class should be creating these, such that discover() can become pure virtual 
    263     switch( sbType ) { 
    264     case eST_Audio: 
    265         pSubunit = new SubunitAudio; 
    266         break; 
    267     case eST_Music: 
    268         pSubunit = new SubunitMusic; 
    269         break; 
    270     default: 
    271         pSubunit = 0; 
    272     } 
     260    Subunit* pSubunit = unit.createSubunit(unit, sbType, 0); 
    273261 
    274262    if ( !pSubunit ) { 
     
    279267    pSubunit->m_sbType = sbType; 
    280268    result &= deser.read( basePath + "m_sbId", pSubunit->m_sbId ); 
    281     result &= deserializePlugVector( basePath + "m_plugs", deser, 
    282                                      unit.getPlugManager(), pSubunit->m_plugs ); 
    283269    result &= pSubunit->deserializeChild( basePath, deser, unit ); 
    284270 
     
    291277} 
    292278 
    293 
     279bool 
     280Subunit::deserializeUpdate( Glib::ustring basePath, 
     281                            Util::IODeserialize& deser ) 
     282
     283    bool result; 
     284    std::ostringstream strstrm; 
     285    strstrm << basePath << m_sbId << "/"; 
     286 
     287    result  = deserializePlugVector( strstrm.str() + "m_plugs", deser, 
     288                                     m_unit->getPlugManager(), m_plugs );     
     289    result &= deserializeUpdateChild( strstrm.str(), deser ); 
     290     
     291    return result; 
     292
     293 
     294
  • trunk/libffado/src/libavc/general/avc_subunit.h

    r864 r1110  
    8181    static Subunit* deserialize( Glib::ustring basePath, 
    8282                                 Util::IODeserialize& deser, Unit& avDevice ); 
     83    bool deserializeUpdate( Glib::ustring basePath, 
     84                            Util::IODeserialize& deser ); 
     85 
    8386 protected: 
    8487    Subunit(); 
     
    8992                                   Util::IODeserialize& deser, 
    9093                                   Unit& avDevice ) = 0; 
     94    virtual bool deserializeUpdateChild( Glib::ustring basePath, 
     95                                         Util::IODeserialize& deser ) = 0; 
     96 
    9197    bool discoverPlugs(); 
    9298    bool discoverPlugs(Plug::EPlugDirection plugDirection, 
  • trunk/libffado/src/libavc/general/avc_unit.cpp

    r1047 r1110  
    868868{ 
    869869    int i = 0; 
    870     bool bFinished = false
     870    T* ptr = 0
    871871    do { 
    872872        std::ostringstream strstrm; 
    873873        strstrm << path << i << "/"; 
    874         T* ptr = T::deserialize( strstrm.str(), 
    875                                  deser, 
    876                                  unit ); 
     874        ptr = T::deserialize( strstrm.str(), 
     875                              deser, 
     876                              unit ); 
    877877        if ( ptr ) { 
    878878            vec.push_back( ptr ); 
    879             i++; 
    880         } else { 
    881             bFinished = true; 
    882         } 
    883     } while ( !bFinished ); 
     879        } 
     880        i++; 
     881    } while ( ptr ); 
    884882 
    885883    return true; 
     
    997995    if ( !m_pPlugManager ) 
    998996        return false; 
     997 
     998    // update the plug related stuff in the subunits. we have to 
     999    // do that in 2 steps because we have a circular dependency. 
     1000    for ( SubunitVector::iterator it = m_subunits.begin(); 
     1001          it != m_subunits.end(); 
     1002          ++it ) 
     1003    { 
     1004        result &= (*it)->deserializeUpdate( basePath + "Subunit", deser ); 
     1005    } 
    9991006 
    10001007    // load path /PcrPlug0/global_id 
     
    10131020    m_pPlugManager->deserializeUpdate( basePath, deser ); 
    10141021 
    1015     unsigned int i; 
    1016     result &= deser.read( basePath + "m_activeSyncInfo", i ); 
    1017  
    1018     if ( result ) { 
     1022    if ( deser.isExisting(basePath + "m_activeSyncInfo" ) ) { 
     1023        // the sync info doesn't have to be there. 
     1024 
     1025        unsigned int i; 
     1026        result &= deser.read( basePath + "m_activeSyncInfo", i ); 
    10191027        if ( i < m_syncInfos.size() ) { 
    10201028            m_activeSyncInfo = &m_syncInfos[i]; 
     
    10221030    } 
    10231031 
    1024     return true
     1032    return result
    10251033} 
    10261034 
  • trunk/libffado/src/libavc/musicsubunit/avc_musicsubunit.cpp

    r1042 r1110  
    318318} 
    319319 
    320 
     320bool 
     321SubunitMusic::deserializeUpdateChild( Glib::ustring basePath, 
     322                                      Util::IODeserialize& deser ) 
     323
     324    return true; 
     325
     326 
     327
  • trunk/libffado/src/libavc/musicsubunit/avc_musicsubunit.h

    r1042 r1110  
    5959                                   Util::IODeserialize& deser, 
    6060                                   Unit& avDevice ); 
     61    virtual bool deserializeUpdateChild( Glib::ustring basePath, 
     62                                         Util::IODeserialize& deser ); 
    6163 
    6264    class AVCMusicStatusDescriptor*  m_status_descriptor;