Changeset 736
- Timestamp:
- 11/28/07 05:36:19 (16 years ago)
- Files:
-
- trunk/libffado/SConstruct (modified) (4 diffs)
- trunk/libffado/src/bebob/bebob_avdevice_subunit.cpp (modified) (5 diffs)
- trunk/libffado/src/bebob/bebob_functionblock.cpp (modified) (3 diffs)
- trunk/libffado/src/bebob/bebob_functionblock.h (modified) (2 diffs)
- trunk/libffado/src/genericavc/avc_avdevice.cpp (modified) (1 diff)
- trunk/libffado/src/libavc/audiosubunit/avc_audiosubunit.h (modified) (1 diff)
- trunk/libffado/src/libavc/general/avc_plug.cpp (modified) (5 diffs)
- trunk/libffado/src/libavc/general/avc_plug.h (modified) (5 diffs)
- trunk/libffado/src/libavc/general/avc_subunit.cpp (modified) (7 diffs)
- trunk/libffado/src/libavc/general/avc_subunit.h (modified) (2 diffs)
- trunk/libffado/src/libavc/general/avc_unit.cpp (modified) (3 diffs)
- trunk/libffado/src/libavc/musicsubunit/avc_musicsubunit.cpp (modified) (10 diffs)
- trunk/libffado/src/libieee1394/configrom.cpp (modified) (3 diffs)
Legend:
- Unmodified
- Added
- Removed
- Modified
- Copied
- Moved
trunk/libffado/SConstruct
r734 r736 62 62 buildenv['PKG_CONFIG_PATH']='' 63 63 64 if os.environ.has_key('LD_LIBRARY_PATH'): 65 buildenv['LD_LIBRARY_PATH']=os.environ['LD_LIBRARY_PATH'] 66 else: 67 buildenv['LD_LIBRARY_PATH']='' 68 64 69 65 70 env = Environment( tools=['default','scanreplace','pyuic','dbus','doxygen','pkgconfig'], toolpath=['admin'], ENV = buildenv, options=opts ) … … 92 97 opts.Save( 'cache/' + build_base + "options.cache", env ) 93 98 94 # 95 # Check for apps... 96 # 97 def CheckForApp( context, app ): 98 context.Message( "Checking if '%s' executes... " % app ) 99 ret = context.env.WhereIs( app ) 100 if ret != "": 101 context.Result( True ) 102 else: 103 context.Result( False ) 104 return ret 105 106 tests = { 'CheckForApp' : CheckForApp } 99 100 tests = {} 107 101 tests.update( env['PKGCONFIG_TESTS'] ) 108 102 … … 154 148 # Optional checks follow: 155 149 # 156 env['PYUIC'] = conf.CheckForApp( 'pyuic' )157 150 env['ALSA_SEQ_OUTPUT'] = conf.CheckLib( 'asound', symbol='snd_seq_event_output_direct', autoadd=0 ) 158 151 … … 197 190 env['sharedir'] = Template( os.path.join( env['SHAREDIR'] ) ).safe_substitute( env ) 198 191 192 env.Command( target=env['sharedir'], source="", action=Mkdir( env['sharedir'] ) ) 193 199 194 env.Alias( "install", env['libdir'] ) 200 195 env.Alias( "install", env['includedir'] ) trunk/libffado/src/bebob/bebob_avdevice_subunit.cpp
r734 r736 82 82 { 83 83 debugOutput(DEBUG_LEVEL_NORMAL, "Discovering %s...\n", getName()); 84 84 85 85 // discover the AV/C generic part 86 86 if ( !AVC::SubunitAudio::discover() ) { … … 160 160 #ifdef DEBUG 161 161 if ((int)getDebugLevel() >= DEBUG_LEVEL_NORMAL) { 162 162 163 163 for ( FunctionBlockVector::iterator it = m_functions.begin(); 164 164 it != m_functions.end(); … … 340 340 bool 341 341 BeBoB::SubunitAudio::serializeChild( Glib::ustring basePath, 342 342 Util::IOSerialize& ser ) const 343 343 { 344 344 bool result = true; … … 363 363 bool 364 364 BeBoB::SubunitAudio::deserializeChild( Glib::ustring basePath, 365 366 365 Util::IODeserialize& deser, 366 AVC::Unit& avDevice ) 367 367 { 368 368 int i = 0; … … 426 426 { 427 427 debugOutput(DEBUG_LEVEL_NORMAL, "Discovering %s...\n", getName()); 428 428 429 429 // discover the AV/C generic part 430 430 if ( !AVC::SubunitMusic::discover() ) { trunk/libffado/src/bebob/bebob_functionblock.cpp
r734 r736 160 160 161 161 bool 162 serializePlugVector( Glib::ustring basePath,163 Util::IOSerialize& ser,164 const PlugVector& vec )165 {166 bool result = true;167 int i = 0;168 for ( PlugVector::const_iterator it = vec.begin();169 it != vec.end();170 ++it )171 {172 std::ostringstream strstrm;173 strstrm << basePath << i;174 result &= ser.write( strstrm.str(), ( *it )->getGlobalId() );175 i++;176 }177 return result;178 }179 180 bool181 deserializePlugVector( Glib::ustring basePath,182 Util::IODeserialize& deser,183 AVC::Unit& unit,184 PlugVector& vec )185 {186 int i = 0;187 bool bFinished = false;188 bool result = true;189 do {190 plug_id_t plugId;191 std::ostringstream strstrm;192 strstrm << basePath << i;193 194 if ( deser.isExisting( strstrm.str() ) ) {195 result &= deser.read( strstrm.str(), plugId );196 AVC::Plug* pPlug = unit.getPlugManager().getPlug( plugId );197 198 if ( result && pPlug ) {199 vec.push_back( pPlug );200 i++;201 } else {202 bFinished = true;203 }204 } else {205 bFinished = true;206 }207 } while ( !bFinished );208 209 return result;210 }211 212 bool213 162 FunctionBlock::serialize( Glib::ustring basePath, Util::IOSerialize& ser ) const 214 163 { … … 229 178 FunctionBlock* 230 179 FunctionBlock::deserialize( Glib::ustring basePath, 231 232 233 180 Util::IODeserialize& deser, 181 AVC::Unit& unit, 182 AVC::Subunit& subunit ) 234 183 { 235 184 bool result; … … 278 227 result &= deser.read( basePath + "m_nrOfOutputPlugs", pFB->m_nrOfOutputPlugs ); 279 228 result &= deser.read( basePath + "m_verbose", pFB->m_verbose ); 280 result &= deserializePlugVector( basePath + "m_plugs", deser, unit, pFB->m_plugs ); 229 result &= deserializePlugVector( basePath + "m_plugs", deser, 230 unit.getPlugManager(), pFB->m_plugs ); 281 231 282 232 return 0; trunk/libffado/src/bebob/bebob_functionblock.h
r734 r736 69 69 70 70 virtual const char* getName() = 0; 71 71 72 72 AVC::function_block_type_t getType() {return m_type;}; 73 73 AVC::function_block_type_t getSubtype() {return m_subtype;}; 74 74 AVC::function_block_id_t getId() {return m_id;}; 75 75 76 76 AVC::no_of_input_plugs_t getNrOfInputPlugs() {return m_nrOfInputPlugs;}; 77 77 AVC::no_of_output_plugs_t getNrOfOutputPlugs() {return m_nrOfOutputPlugs;}; 78 78 79 79 bool serialize( Glib::ustring basePath, Util::IOSerialize& ser ) const; 80 80 81 static FunctionBlock* deserialize( Glib::ustring basePath, 81 82 Util::IODeserialize& deser, … … 144 145 145 146 virtual const char* getName(); 146 147 147 148 // FIXME: this is not pretty! 148 149 enum EControlSelectorEncoding { trunk/libffado/src/genericavc/avc_avdevice.cpp
r734 r736 236 236 bool found=false; 237 237 for ( PlugVector::const_iterator it2 = syncMSUInputPlugs.begin(); 238 it2 != syncMSUInputPlugs.end();239 ++it2 )238 it2 != syncMSUInputPlugs.end(); 239 ++it2 ) 240 240 { 241 241 AVC::Plug* msuPlug = *it2; trunk/libffado/src/libavc/audiosubunit/avc_audiosubunit.h
r734 r736 52 52 protected: 53 53 virtual bool serializeChild( Glib::ustring basePath, 54 Util::IOSerialize& ser ) const { return false;};54 Util::IOSerialize& ser ) const { return true; } 55 55 virtual bool deserializeChild( Glib::ustring basePath, 56 56 Util::IODeserialize& deser, 57 Unit& avDevice ) { return false;};57 Unit& avDevice ) { return true; } 58 58 59 59 }; trunk/libffado/src/libavc/general/avc_plug.cpp
r734 r736 1576 1576 } 1577 1577 1578 1579 bool1580 Plug::serializePlugVector( Glib::ustring basePath,1581 Util::IOSerialize& ser,1582 const PlugVector& vec) const1583 {1584 bool result = true;1585 int i = 0;1586 for ( PlugVector::const_iterator it = vec.begin();1587 it != vec.end();1588 ++it )1589 {1590 const Plug* pPlug = *it;1591 std::ostringstream strstrm;1592 strstrm << basePath << i;1593 1594 result &= ser.write( strstrm.str() + "/global_id", pPlug->getGlobalId() );1595 i++;1596 }1597 return result;1598 }1599 1600 bool1601 Plug::deserializePlugVector( Glib::ustring basePath,1602 Util::IODeserialize& deser,1603 PlugVector& vec )1604 {1605 int i = 0;1606 bool bFinished = false;1607 bool result = true;1608 do {1609 std::ostringstream strstrm;1610 strstrm << basePath << i;1611 1612 // check for one element to exist. when one exist the other elements1613 // must also be there. otherwise just return (last) result.1614 if ( deser.isExisting( strstrm.str() + "/global_id" ) ) {1615 unsigned int iPlugId;1616 result &= deser.read( strstrm.str() + "/global_id", iPlugId );1617 1618 if ( result ) {1619 Plug* pPlug = m_unit->getPlugManager().getPlug( iPlugId );1620 if ( pPlug ) {1621 vec.push_back( pPlug );1622 } else {1623 result = false;1624 bFinished = true;1625 }1626 i++;1627 } else {1628 bFinished = true;1629 }1630 } else {1631 bFinished = true;1632 }1633 } while ( !bFinished );1634 1635 return result;1636 }1637 1638 1578 bool 1639 1579 Plug::serialize( Glib::ustring basePath, Util::IOSerialize& ser ) const … … 1683 1623 bool result=true; 1684 1624 1685 ESubunitType subunitType; 1686 result = deser.read( basePath + "m_subunitType", subunitType ); 1687 subunit_t subunitId; 1688 result &= deser.read( basePath + "m_subunitId", subunitId ); 1689 pPlug->m_subunit = unit.getSubunit( subunitType, subunitType ); 1690 1625 result = deser.read( basePath + "m_subunitType", pPlug->m_subunitType ); 1626 result &= deser.read( basePath + "m_subunitId", pPlug->m_subunitId ); 1691 1627 result &= deser.read( basePath + "m_functionBlockType", pPlug->m_functionBlockType ); 1692 1628 result &= deser.read( basePath + "m_functionBlockId", pPlug->m_functionBlockId ); … … 1718 1654 bool 1719 1655 Plug::deserializeUpdate( Glib::ustring basePath, 1720 1656 Util::IODeserialize& deser ) 1721 1657 { 1722 1658 bool result; 1723 1659 1724 result = deserializePlugVector( basePath + "m_inputConnections", deser, m_inputConnections ); 1725 result &= deserializePlugVector( basePath + "m_outputConnections", deser, m_outputConnections ); 1660 result = deserializePlugVector( basePath + "m_inputConnections", deser, 1661 m_unit->getPlugManager(), m_inputConnections ); 1662 result &= deserializePlugVector( basePath + "m_outputConnections", deser, 1663 m_unit->getPlugManager(), m_outputConnections ); 1726 1664 1727 1665 return result; 1666 } 1667 1668 bool 1669 Plug::deserializeUpdateSubunit() 1670 { 1671 m_subunit = m_unit->getSubunit( m_subunitType, m_subunitId ); 1672 return true; 1728 1673 } 1729 1674 … … 2205 2150 } 2206 2151 2152 bool 2153 PlugManager::deserializeUpdate() 2154 { 2155 bool result = true; 2156 2157 for ( PlugVector::const_iterator it = m_plugs.begin(); 2158 it != m_plugs.end(); 2159 ++it ) 2160 { 2161 Plug* pPlug = *it; 2162 2163 result &= pPlug->deserializeUpdateSubunit(); 2164 } 2165 2166 return result; 2167 } 2207 2168 2208 2169 //////////////////////////////////// … … 2339 2300 } 2340 2301 2341 } 2302 bool 2303 serializePlugVector( Glib::ustring basePath, 2304 Util::IOSerialize& ser, 2305 const PlugVector& vec) 2306 { 2307 bool result = true; 2308 int i = 0; 2309 for ( PlugVector::const_iterator it = vec.begin(); 2310 it != vec.end(); 2311 ++it ) 2312 { 2313 const Plug* pPlug = *it; 2314 std::ostringstream strstrm; 2315 strstrm << basePath << i; 2316 2317 result &= ser.write( strstrm.str() + "/global_id", pPlug->getGlobalId() ); 2318 i++; 2319 } 2320 return result; 2321 } 2322 2323 bool 2324 deserializePlugVector( Glib::ustring basePath, 2325 Util::IODeserialize& deser, 2326 const PlugManager& plugManager, 2327 PlugVector& vec ) 2328 { 2329 int i = 0; 2330 bool bFinished = false; 2331 bool result = true; 2332 do { 2333 std::ostringstream strstrm; 2334 strstrm << basePath << i; 2335 2336 // check for one element to exist. when one exist the other elements 2337 // must also be there. otherwise just return (last) result. 2338 if ( deser.isExisting( strstrm.str() + "/global_id" ) ) { 2339 unsigned int iPlugId; 2340 result &= deser.read( strstrm.str() + "/global_id", iPlugId ); 2341 2342 if ( result ) { 2343 Plug* pPlug = plugManager.getPlug( iPlugId ); 2344 if ( pPlug ) { 2345 vec.push_back( pPlug ); 2346 } else { 2347 result = false; 2348 bFinished = true; 2349 } 2350 i++; 2351 } else { 2352 bFinished = true; 2353 } 2354 } else { 2355 bFinished = true; 2356 } 2357 } while ( !bFinished ); 2358 2359 return result; 2360 } 2361 2362 } trunk/libffado/src/libavc/general/avc_plug.h
r734 r736 163 163 bool deserializeUpdate( Glib::ustring basePath, 164 164 Util::IODeserialize& deser ); 165 bool deserializeUpdateSubunit(); 165 166 166 167 public: … … 256 257 bool deserializeFormatInfos( Glib::ustring basePath, 257 258 Util::IODeserialize& deser ); 258 259 bool serializePlugVector( Glib::ustring basePath,260 Util::IOSerialize& ser,261 const PlugVector& vec) const;262 bool deserializePlugVector( Glib::ustring basePath,263 Util::IODeserialize& deser,264 PlugVector& vec );265 259 266 260 protected: … … 285 279 Unit* m_unit; 286 280 Subunit* m_subunit; 281 ESubunitType m_subunitType; 282 subunit_t m_subunitId; 287 283 function_block_type_t m_functionBlockType; 288 284 function_block_id_t m_functionBlockId; … … 349 345 bool tidyPlugConnections(PlugConnectionVector&); 350 346 347 bool deserializeUpdate(); 348 351 349 private: 352 350 … … 379 377 typedef std::vector<PlugConnection> PlugConnectionOwnerVector; 380 378 379 380 bool serializePlugVector( Glib::ustring basePath, 381 Util::IOSerialize& ser, 382 const PlugVector& vec); 383 384 bool deserializePlugVector( Glib::ustring basePath, 385 Util::IODeserialize& deser, 386 const PlugManager& plugManager, 387 PlugVector& vec ); 388 381 389 } 382 390 trunk/libffado/src/libavc/general/avc_subunit.cpp
r734 r736 107 107 { 108 108 debugOutput(DEBUG_LEVEL_NORMAL, "Discovering plugs...\n"); 109 109 110 110 PlugInfoCmd plugInfoCmd( getUnit().get1394Service(), 111 111 PlugInfoCmd::eSF_SerialBusIsochronousAndExternalPlug ); … … 147 147 { 148 148 debugOutput(DEBUG_LEVEL_NORMAL, "Discovering connections...\n"); 149 149 150 150 for ( PlugVector::iterator it = getPlugs().begin(); 151 151 it != getPlugs().end(); … … 183 183 return false; 184 184 } 185 185 186 186 plug->setVerboseLevel(getDebugLevel()); 187 187 188 188 if ( !plug->discover() ) { 189 189 debugError( "plug discover failed\n" ); … … 232 232 bool 233 233 Subunit::serialize( Glib::ustring basePath, 234 234 Util::IOSerialize& ser ) const 235 235 { 236 236 bool result; … … 239 239 result &= ser.write( basePath + "m_sbId", m_sbId ); 240 240 result &= ser.write( basePath + "m_verboseLevel", getDebugLevel() ); 241 result &= serializePlugVector( basePath + "m_plugs", ser, m_plugs ); 241 242 result &= serializeChild( basePath, ser ); 242 243 … … 259 260 260 261 Subunit* pSubunit = 0; 261 262 262 263 #warning FIXME: The derived class should be creating these 263 264 // FIXME: The derived class should be creating these, such that discover() can become pure virtual … … 280 281 pSubunit->m_sbType = sbType; 281 282 result &= deser.read( basePath + "m_sbId", pSubunit->m_sbId ); 283 result &= deserializePlugVector( basePath + "m_plugs", deser, 284 unit.getPlugManager(), pSubunit->m_plugs ); 282 285 int verboseLevel; 283 286 result &= deser.read( basePath + "m_verboseLevel", verboseLevel ); trunk/libffado/src/libavc/general/avc_subunit.h
r734 r736 73 73 74 74 PlugVector& getPlugs() 75 75 { return m_plugs; } 76 76 Plug* getPlug(Plug::EPlugDirection direction, plug_id_t plugId); 77 77 … … 80 80 bool serialize( Glib::ustring basePath, Util::IOSerialize& ser ) const; 81 81 static Subunit* deserialize( Glib::ustring basePath, 82 82 Util::IODeserialize& deser, Unit& avDevice ); 83 83 protected: 84 84 Subunit(); trunk/libffado/src/libavc/general/avc_unit.cpp
r734 r736 975 975 result = ser.write( basePath + "m_verboseLevel_unit", getDebugLevel() ); 976 976 result &= serializeVector( basePath + "Subunit", ser, m_subunits ); 977 result &= serialize Vector( basePath + "PcrPlug", ser, m_pcrPlugs );978 result &= serialize Vector( basePath + "ExternalPlug", ser, m_externalPlugs );977 result &= serializePlugVector( basePath + "PcrPlug", ser, m_pcrPlugs ); 978 result &= serializePlugVector( basePath + "ExternalPlug", ser, m_externalPlugs ); 979 979 result &= serializeVector( basePath + "PlugConnection", ser, m_plugConnections ); 980 980 result &= m_pPlugManager->serialize( basePath + "Plug", ser ); // serialize all av plugs … … 1007 1007 setDebugLevel( verboseLevel ); 1008 1008 1009 result &= deserializeVector<Subunit>( basePath + "Subunit", deser, *this, 1009 result &= deserializeVector<Subunit>( basePath + "Subunit", deser, *this, m_subunits ); 1010 1010 1011 1011 if (m_pPlugManager) … … 1017 1017 return false; 1018 1018 1019 // XXX We have to deserialize the m_pcrPlugs and m_externPlugs members somehow. 1020 // Of course the simple following simple approach wont work at the moment. Some 1021 // more hacking needed :) 1022 //result &= deserializeVector<Plug>( basePath + "PcrPlug", deser, *this, m_pcrPlugs ); 1023 //result &= deserializeVector<Plug>( basePath + "ExternalPlug", deser, *this, m_externalPlugs ); 1024 result &= deserializePlugUpdateConnections( basePath + "PcrPlug", deser, m_pcrPlugs ); 1025 result &= deserializePlugUpdateConnections( basePath + "ExternalPlug", deser, m_externalPlugs ); 1019 result &= deserializePlugVector( basePath + "PcrPlug", deser, getPlugManager(), m_pcrPlugs ); 1020 result &= deserializePlugVector( basePath + "ExternalPlug", deser, getPlugManager(), m_externalPlugs ); 1026 1021 result &= deserializeVector<PlugConnection>( basePath + "PlugConnnection", deser, *this, m_plugConnections ); 1027 1022 result &= deserializeVector<Subunit>( basePath + "Subunit", deser, *this, m_subunits ); 1028 1023 result &= deserializeSyncInfoVector( basePath + "SyncInfo", deser, m_syncInfos ); 1029 1024 1025 result &= deserializePlugUpdateConnections( basePath + "PcrPlug", deser, m_pcrPlugs ); 1026 result &= deserializePlugUpdateConnections( basePath + "ExternalPlug", deser, m_externalPlugs ); 1027 m_pPlugManager->deserializeUpdate(); 1028 1030 1029 unsigned int i; 1031 1030 result &= deser.read( basePath + "m_activeSyncInfo", i ); trunk/libffado/src/libavc/musicsubunit/avc_musicsubunit.cpp
r734 r736 63 63 { 64 64 debugOutput(DEBUG_LEVEL_NORMAL, "Discovering %s...\n", getName()); 65 65 66 66 // discover the AV/C generic part 67 67 if ( !Subunit::discover() ) { 68 68 return false; 69 69 } 70 70 71 71 // now we have the subunit plugs 72 72 73 73 return true; 74 74 } … … 79 79 debugOutput(DEBUG_LEVEL_VERBOSE, "Loading info from descriptor for plug: \n"); 80 80 bool result=true; 81 81 82 82 // load the descriptor (if not already loaded) 83 83 if (m_status_descriptor != NULL) { 84 84 result &= m_status_descriptor->load(); 85 85 } 86 86 87 87 AVCMusicSubunitPlugInfoBlock *info; 88 88 info = m_status_descriptor->getSubunitPlugInfoBlock(plug.getDirection(), plug.getPlugId()); 89 89 90 90 if (info == NULL) { 91 91 debugError("Could not find plug info block\n"); 92 92 return false; 93 93 } 94 94 95 95 debugOutput(DEBUG_LEVEL_VERBOSE, "Found plug: %s\n",info->getName().c_str()); 96 96 97 97 // plug name 98 98 result &= plug.setName(info->getName()); 99 99 100 100 // plug type 101 101 switch (info->m_plug_type) { … … 119 119 break; 120 120 } 121 121 122 122 // number of channels 123 123 result &= plug.setNrOfChannels(info->m_nb_channels); 124 124 125 125 int idx=1; 126 126 for ( AVCMusicClusterInfoBlockVectorIterator it = info->m_Clusters.begin(); 127 it != info->m_Clusters.end();128 ++it )127 it != info->m_Clusters.end(); 128 ++it ) 129 129 { 130 130 struct Plug::ClusterInfo cinfo; 131 131 132 132 AVCMusicClusterInfoBlock *c=(*it); 133 133 134 134 cinfo.m_index=idx; //FIXME: is this correct? 135 135 cinfo.m_portType=c->m_port_type; … … 141 141 cinfo.m_index, cinfo.m_portType, cinfo.m_nrOfChannels, cinfo.m_streamFormat, cinfo.m_name.c_str()); 142 142 143 for ( AVCMusicClusterInfoBlock::SignalInfoVectorIterator sig_it 144 = c->m_SignalInfos.begin();145 sig_it != c->m_SignalInfos.end();146 ++sig_it )143 for ( AVCMusicClusterInfoBlock::SignalInfoVectorIterator sig_it 144 = c->m_SignalInfos.begin(); 145 sig_it != c->m_SignalInfos.end(); 146 ++sig_it ) 147 147 { 148 148 struct AVCMusicClusterInfoBlock::sSignalInfo s=(*sig_it); 149 149 struct Plug::ChannelInfo sinfo; 150 150 151 151 sinfo.m_streamPosition=s.stream_position; 152 152 sinfo.m_location=s.stream_location; 153 153 154 154 AVCMusicPlugInfoBlock *mplug=m_status_descriptor->getMusicPlugInfoBlock(s.music_plug_id); 155 155 156 156 if (mplug==NULL) { 157 157 debugWarning("No music plug found for this signal\n"); … … 160 160 sinfo.m_name=mplug->getName(); 161 161 } 162 162 163 163 if (plug.getDirection() == Plug::eAPD_Input) { 164 // it's an input plug to the subunit 164 // it's an input plug to the subunit 165 165 // so we have to check the source field of the music plug 166 166 if(s.stream_position != mplug->m_source_stream_position) { … … 177 177 } 178 178 } else if (plug.getDirection() == Plug::eAPD_Output) { 179 // it's an output plug from the subunit 179 // it's an output plug from the subunit 180 180 // so we have to check the destination field of the music plug 181 181 if(s.stream_position != mplug->m_dest_stream_position) { … … 194 194 debugWarning("Invalid plug direction.\n"); 195 195 } 196 196 197 197 debugOutput(DEBUG_LEVEL_VERBOSE, "Adding signal pos=%2d loc=%2d name=%s\n", 198 198 sinfo.m_streamPosition, sinfo.m_location, mplug->getName().c_str()); 199 199 200 200 cinfo.m_channelInfos.push_back(sinfo); 201 201 } … … 204 204 plug.getClusterInfos().push_back(cinfo); 205 205 } 206 207 206 207 208 208 return result; 209 209 … … 239 239 bool 240 240 SubunitMusic::serializeChild( Glib::ustring basePath, 241 241 Util::IOSerialize& ser ) const 242 242 { 243 243 return true; … … 246 246 bool 247 247 SubunitMusic::deserializeChild( Glib::ustring basePath, 248 249 248 Util::IODeserialize& deser, 249 Unit& unit ) 250 250 { 251 251 return true; trunk/libffado/src/libieee1394/configrom.cpp
r734 r736 64 64 , m_1394Service( &ieee1394service ) 65 65 , m_nodeId( nodeId ) 66 , m_avcDevice( false ) 66 , m_avcDevice( false ) // FIXME: this does not seem veryu 67 67 , m_guid( 0 ) 68 68 , m_vendorName( "" ) … … 91 91 , m_1394Service( 0 ) 92 92 , m_nodeId( -1 ) 93 , m_avcDevice( false ) 93 , m_avcDevice( false ) // FIXME: this does not seem veryu 94 94 , m_guid( 0 ) 95 95 , m_vendorName( "" ) … … 292 292 if ( m_unit_specifier_id == 0x0000a02d ) // XXX 293 293 { 294 if ( kv->value.immediate == 0x10001 ) { 294 m_avcDevice = true; // FIXME: disable this check for the moment 295 if ( kv->value.immediate == 0x14001 ) { 295 296 m_avcDevice = true; 296 297 }