Changeset 524

Timestamp:

08/17/07 06:49:43 (16 years ago)

Author:

ppalmers

Message:

echo discovery works, audio I/O works, still some issues with midi and channel naming

Files:

• branches/echoaudio/src/bebob/bebob_avdevice.cpp (modified) (8 diffs)
• branches/echoaudio/src/bebob/bebob_avdevice.h (modified) (3 diffs)
• branches/echoaudio/src/bebob/bebob_avdevice_subunit.cpp (modified) (9 diffs)
• branches/echoaudio/src/bebob/bebob_avdevice_subunit.h (modified) (6 diffs)
• branches/echoaudio/src/bebob/bebob_avplug.cpp (modified) (2 diffs)
• branches/echoaudio/src/bebob/bebob_avplug.h (modified) (1 diff)
• branches/echoaudio/src/genericavc/avc_avdevice.cpp (modified) (9 diffs)
• branches/echoaudio/src/genericavc/avc_avdevice.h (modified) (4 diffs)
• branches/echoaudio/src/libavc/avc_definitions.cpp (modified) (2 diffs)
• branches/echoaudio/src/libavc/avc_definitions.h (modified) (3 diffs)
• branches/echoaudio/src/libavc/descriptors/avc_descriptor.cpp (modified) (9 diffs)
• branches/echoaudio/src/libavc/descriptors/avc_descriptor.h (modified) (4 diffs)
• branches/echoaudio/src/libavc/general/avc_connect.cpp (modified) (2 diffs)
• branches/echoaudio/src/libavc/general/avc_plug.cpp (modified) (12 diffs)
• branches/echoaudio/src/libavc/general/avc_plug.h (modified) (12 diffs)
• branches/echoaudio/src/libavc/general/avc_signal_format.cpp (added)
• branches/echoaudio/src/libavc/general/avc_signal_format.h (added)
• branches/echoaudio/src/libavc/general/avc_subunit.cpp (modified) (2 diffs)
• branches/echoaudio/src/libavc/general/avc_subunit.h (modified) (4 diffs)
• branches/echoaudio/src/libavc/general/avc_unit.cpp (modified) (7 diffs)
• branches/echoaudio/src/libavc/general/avc_unit.h (modified) (4 diffs)
• branches/echoaudio/src/libavc/musicsubunit/avc_descriptor_music.cpp (modified) (8 diffs)
• branches/echoaudio/src/libavc/musicsubunit/avc_descriptor_music.h (modified) (8 diffs)
• branches/echoaudio/src/libavc/musicsubunit/avc_musicsubunit.cpp (modified) (3 diffs)
• branches/echoaudio/src/libavc/musicsubunit/avc_musicsubunit.h (modified) (3 diffs)
• branches/echoaudio/src/libstreaming/PortManager.cpp (modified) (3 diffs)
• branches/echoaudio/src/libstreaming/PortManager.h (modified) (1 diff)
• branches/echoaudio/src/Makefile.am (modified) (2 diffs)
• branches/echoaudio/tests/Makefile.am (modified) (1 diff)
• branches/echoaudio/tests/streaming/testmidistreaming1.c (modified) (21 diffs)
• branches/echoaudio/tests/streaming/teststreaming.c (modified) (11 diffs)
• branches/echoaudio/tests/streaming/teststreaming2.c (modified) (12 diffs)
• branches/echoaudio/tests/streaming/teststreaming3.c (modified) (11 diffs)

branches/echoaudio/src/bebob/bebob_avdevice.cpp

@@ -94 +94 @@
-}
-
+AVC::Subunit* 
+BeBoB::AvDevice::createSubunit(AVC::Unit& unit,
+                               AVC::ESubunitType type,
+                               AVC::subunit_t id ) 
+{
+    switch (type) {
+        case AVC::eST_Audio:
+            return new BeBoB::SubunitAudio(unit, id );
+        case AVC::eST_Music:
+            return new BeBoB::SubunitMusic(unit, id );
+        default:
+            return NULL;
+    }
+}
+
+AVC::Plug *
+BeBoB::AvDevice::createPlug( AVC::Unit* unit,
+                     AVC::Subunit* subunit,
+                     AVC::function_block_type_t functionBlockType,
+                     AVC::function_block_type_t functionBlockId,
+                     AVC::Plug::EPlugAddressType plugAddressType,
+                     AVC::Plug::EPlugDirection plugDirection,
+                     AVC::plug_id_t plugId )
+{
+
+    return new BeBoB::Plug( unit,
+                     subunit,
+                     functionBlockType,
+                     functionBlockId,
+                     plugAddressType,
+                     plugDirection,
+                     plugId );
+}
+
-void
-AvDevice::setVerboseLevel(int l)
@@ -166 +200 @@
-//     }
-
-    // bebob specific discovery procedure
-    if ( !discoverPlugs() ) {
-        debugError( "Detecting plugs failed\n" );
-        return false;
-    }
-
-    if ( !discoverPlugConnections() ) {
-        debugError( "Detecting plug connections failed\n" );
-        return false;
-    }
-
-    if ( !discoverSubUnitsPlugConnections() ) {
-        debugError( "Detecting plug connnection failed\n" );
-        return false;
-    }
-
-    if ( !discoverSyncModes() ) {
-        debugError( "Detecting sync modes failed\n" );
-        return false;
-    }
-
-    // create a GenericMixer and add it as an OSC child node
-    //  remove if already there
@@ -206 +219 @@
-        }
-    }
-    return true;
-}
-
-bool
-AvDevice::enumerateSubUnits()
-{
-    SubUnitInfoCmd subUnitInfoCmd( get1394Service() );
-    subUnitInfoCmd.setCommandType( AVCCommand::eCT_Status );
-
-    // NOTE: BeBoB has always exactly one audio and one music subunit. This
-    // means is fits into the first page of the SubUnitInfo command.
-    // So there is no need to do more than needed
-
-    subUnitInfoCmd.m_page = 0;
-    subUnitInfoCmd.setNodeId( getConfigRom().getNodeId() );
-    subUnitInfoCmd.setVerbose( getDebugLevel() );
-    if ( !subUnitInfoCmd.fire() ) {
-        debugError( "Subunit info command failed\n" );
-        // shouldn't this be an error situation?
-        return false;
-    }
-
-    for ( int i = 0; i < subUnitInfoCmd.getNrOfValidEntries(); ++i ) {
-        subunit_type_t subunit_type
-            = subUnitInfoCmd.m_table[i].m_subunit_type;
-
-        unsigned int subunitId = getNrOfSubunits( subunit_type );
-
-        debugOutput( DEBUG_LEVEL_VERBOSE,
-                     "subunit_id = %2d, subunit_type = %2d (%s)\n",
-                     subunitId,
-                     subunit_type,
-                     subunitTypeToString( subunit_type ) );
-
-        AVC::Subunit* subunit = 0;
-        switch( subunit_type ) {
-        case eST_Audio:
-            subunit = new BeBoB::SubunitAudio( *this,
-                                               subunitId );
-            if ( !subunit ) {
-                debugFatal( "Could not allocate SubunitAudio\n" );
-                return false;
-            }
-            
-            if ( !subunit->discover() ) {
-                debugError( "enumerateSubUnits: Could not discover "
-                            "subunit_id = %2d, subunit_type = %2d (%s)\n",
-                            subunitId,
-                            subunit_type,
-                            subunitTypeToString( subunit_type ) );
-                delete subunit;
-                return false;
-            } else {
-                m_subunits.push_back( subunit );
-            }
-            
-            break;
-        case eST_Music:
-            subunit = new BeBoB::SubunitMusic( *this,
-                                               subunitId );
-            if ( !subunit ) {
-                debugFatal( "Could not allocate SubunitMusic\n" );
-                return false;
-            }
-            if ( !subunit->discover() ) {
-                debugError( "enumerateSubUnits: Could not discover "
-                            "subunit_id = %2d, subunit_type = %2d (%s)\n",
-                            subunitId,
-                            subunit_type,
-                            subunitTypeToString( subunit_type ) );
-                delete subunit;
-                return false;
-            } else {
-                m_subunits.push_back( subunit );
-            }
-
-            break;
-        default:
-            debugOutput( DEBUG_LEVEL_NORMAL,
-                         "Unsupported subunit found, subunit_type = %d (%s)\n",
-                         subunit_type,
-                         subunitTypeToString( subunit_type ) );
-            continue;
-
-        }
-    }
-
-    return true;
-}
-
-bool
-AvDevice::discoverPlugs()
-{
-    debugOutput( DEBUG_LEVEL_NORMAL, "Discovering plugs...\n");
-
-    //////////////////////////////////////////////
-    // Get number of available isochronous input
-    // and output plugs of unit
-
-    PlugInfoCmd plugInfoCmd( *m_p1394Service );
-    plugInfoCmd.setNodeId( m_pConfigRom->getNodeId() );
-    plugInfoCmd.setCommandType( AVCCommand::eCT_Status );
-    plugInfoCmd.setVerbose( m_verboseLevel );
-
-    if ( !plugInfoCmd.fire() ) {
-        debugError( "plug info command failed\n" );
-        return false;
-    }
-
-    debugOutput( DEBUG_LEVEL_NORMAL, "number of iso input plugs = %d\n",
-                 plugInfoCmd.m_serialBusIsochronousInputPlugs );
-    debugOutput( DEBUG_LEVEL_NORMAL, "number of iso output plugs = %d\n",
-                 plugInfoCmd.m_serialBusIsochronousOutputPlugs );
-    debugOutput( DEBUG_LEVEL_NORMAL, "number of external input plugs = %d\n",
-                 plugInfoCmd.m_externalInputPlugs );
-    debugOutput( DEBUG_LEVEL_NORMAL, "number of external output plugs = %d\n",
-                 plugInfoCmd.m_externalOutputPlugs );
-
-    if ( !discoverPlugsPCR( Plug::eAPD_Input,
-                            plugInfoCmd.m_serialBusIsochronousInputPlugs ) )
-    {
-        debugError( "pcr input plug discovering failed\n" );
-        return false;
-    }
-
-    if ( !discoverPlugsPCR( Plug::eAPD_Output,
-                            plugInfoCmd.m_serialBusIsochronousOutputPlugs ) )
-    {
-        debugError( "pcr output plug discovering failed\n" );
-        return false;
-    }
-
-    if ( !discoverPlugsExternal( Plug::eAPD_Input,
-                                 plugInfoCmd.m_externalInputPlugs ) )
-    {
-        debugError( "external input plug discovering failed\n" );
-        return false;
-    }
-
-    if ( !discoverPlugsExternal( Plug::eAPD_Output,
-                                 plugInfoCmd.m_externalOutputPlugs ) )
-    {
-        debugError( "external output plug discovering failed\n" );
-        return false;
-    }
-
-    return true;
-}
-
-bool
-AvDevice::discoverPlugsPCR( Plug::EPlugDirection plugDirection,
-                            plug_id_t plugMaxId )
-{
-    debugOutput( DEBUG_LEVEL_NORMAL, "Discovering PCR plugs, direction %d...\n",plugDirection);
-    for ( int plugId = 0;
-          plugId < plugMaxId;
-          ++plugId )
-    {
-        AVC::Plug* plug  = new Plug( this,
-                                NULL,
-                                0xff,
-                                0xff,
-                                Plug::eAPA_PCR,
-                                plugDirection,
-                                plugId );
-        if ( !plug || !plug->discover() ) {
-            debugError( "plug discovering failed\n" );
-            delete plug;
-            return false;
-        }
-
-        debugOutput( DEBUG_LEVEL_NORMAL, "plug '%s' found\n",
-                     plug->getName() );
-        m_pcrPlugs.push_back( plug );
-    }
-
-    return true;
-}
-
-bool
-AvDevice::discoverPlugsExternal( Plug::EPlugDirection plugDirection,
-                                 plug_id_t plugMaxId )
-{
-    debugOutput( DEBUG_LEVEL_NORMAL, "Discovering Externals plugs, direction %d...\n",plugDirection);
-    for ( int plugId = 0;
-          plugId < plugMaxId;
-          ++plugId )
-    {
-        AVC::Plug* plug  = new Plug( this, NULL,
-                                0xff,
-                                0xff,
-                                Plug::eAPA_ExternalPlug,
-                                plugDirection,
-                                plugId );
-        if ( !plug || !plug->discover() ) {
-            debugError( "plug discovering failed\n" );
-            return false;
-        }
-
-        debugOutput( DEBUG_LEVEL_NORMAL, "plug '%s' found\n",
-                     plug->getName() );
-        m_externalPlugs.push_back( plug );
-    }
-
-    return true;
-}
-
-bool
-AvDevice::discoverPlugConnections()
-{
-    for ( PlugVector::iterator it = m_pcrPlugs.begin();
-          it != m_pcrPlugs.end();
-          ++it )
-    {
-        BeBoB::Plug* plug = dynamic_cast<BeBoB::Plug*>(*it);
-        if(!plug) {
-            debugError("BUG: not a bebob plug\n");
-            return false;
-        }
-        if ( !plug->discoverConnections() ) {
-            debugError( "Could not discover plug connections\n" );
-            return false;
-        }
-    }
-    for ( PlugVector::iterator it = m_externalPlugs.begin();
-          it != m_externalPlugs.end();
-          ++it )
-    {
-        BeBoB::Plug* plug = dynamic_cast<BeBoB::Plug*>(*it);
-        if(!plug) {
-            debugError("BUG: not a bebob plug\n");
-            return false;
-        }
-        if ( !plug->discoverConnections() ) {
-            debugError( "Could not discover plug connections\n" );
-            return false;
-        }
-    }
-
-    return true;
-}
-
-bool
-AvDevice::discoverSubUnitsPlugConnections()
-{
-    for ( SubunitVector::iterator it = m_subunits.begin();
-          it != m_subunits.end();
-          ++it )
-    {
-        BeBoB::Subunit* subunit = dynamic_cast<BeBoB::Subunit*>(*it);
-        if (subunit==NULL) {
-            debugError("BUG: subunit is not a BeBoB::Subunit\n");
-            return false;
-        }
-
-        if ( !subunit->discoverConnections() ) {
-            debugError( "Subunit '%s'  plug connections failed\n",
-                        subunit->getName() );
-            return false;
-        }
-    }
-    return true;
-}
-
-bool
-AvDevice::discoverSyncModes()
-{
-    // Following possible sync plugs exists:
-    // - Music subunit sync output plug = internal sync (CSP)
-    // - Unit input plug 0 = SYT match
-    // - Unit input plut 1 = Sync stream
-    //
-    // If last sync mode is reported it is mostelikely not
-    // implemented *sic*
-    //
-    // Following sync sources are device specific:
-    // - All unit external input plugs which have a
-    //   sync information (WS, SPDIF, ...)
-
-    // First we have to find the sync input and output plug
-    // in the music subunit.
-
-    // Note PCR input means 1394bus-to-device where as
-    // MSU input means subunit-to-device
-
-    PlugVector syncPCRInputPlugs = getPlugsByType( m_pcrPlugs,
-                                                     Plug::eAPD_Input,
-                                                     Plug::eAPT_Sync );
-    if ( !syncPCRInputPlugs.size() ) {
-        debugWarning( "No PCR sync input plug found\n" );
-    }
-
-    PlugVector syncPCROutputPlugs = getPlugsByType( m_pcrPlugs,
-                                                      Plug::eAPD_Output,
-                                                      Plug::eAPT_Sync );
-    if ( !syncPCROutputPlugs.size() ) {
-        debugWarning( "No PCR sync output plug found\n" );
-    }
-
-    PlugVector isoPCRInputPlugs = getPlugsByType( m_pcrPlugs,
-                                                    Plug::eAPD_Input,
-                                                    Plug::eAPT_IsoStream );
-    if ( !isoPCRInputPlugs.size() ) {
-        debugWarning( "No PCR iso input plug found\n" );
-
-    }
-
-    PlugVector isoPCROutputPlugs = getPlugsByType( m_pcrPlugs,
-                                                    Plug::eAPD_Output,
-                                                    Plug::eAPT_IsoStream );
-    if ( !isoPCROutputPlugs.size() ) {
-        debugWarning( "No PCR iso output plug found\n" );
-
-    }
-
-    PlugVector digitalPCRInputPlugs = getPlugsByType( m_externalPlugs,
-                                                    Plug::eAPD_Input,
-                                                    Plug::eAPT_Digital );
-
-    PlugVector syncMSUInputPlugs = m_pPlugManager->getPlugsByType(
-        eST_Music,
-        0,
-        0xff,
-        0xff,
-        Plug::eAPA_SubunitPlug,
-        Plug::eAPD_Input,
-        Plug::eAPT_Sync );
-    if ( !syncMSUInputPlugs.size() ) {
-        debugWarning( "No sync input plug for MSU subunit found\n" );
-    }
-
-    PlugVector syncMSUOutputPlugs = m_pPlugManager->getPlugsByType(
-        eST_Music,
-        0,
-        0xff,
-        0xff,
-        Plug::eAPA_SubunitPlug,
-        Plug::eAPD_Output,
-        Plug::eAPT_Sync );
-    if ( !syncMSUOutputPlugs.size() ) {
-        debugWarning( "No sync output plug for MSU subunit found\n" );
-    }
-
-    debugOutput( DEBUG_LEVEL_VERBOSE, "PCR Sync Input Plugs:\n" );
-    showPlugs( syncPCRInputPlugs );
-    debugOutput( DEBUG_LEVEL_VERBOSE, "PCR Sync Output Plugs:\n" );
-    showPlugs( syncPCROutputPlugs );
-    debugOutput( DEBUG_LEVEL_VERBOSE, "PCR Iso Input Plugs:\n" );
-    showPlugs( isoPCRInputPlugs );
-    debugOutput( DEBUG_LEVEL_VERBOSE, "PCR Iso Output Plugs:\n" );
-    showPlugs( isoPCROutputPlugs );
-    debugOutput( DEBUG_LEVEL_VERBOSE, "PCR digital Input Plugs:\n" );
-    showPlugs( digitalPCRInputPlugs );
-    debugOutput( DEBUG_LEVEL_VERBOSE, "MSU Sync Input Plugs:\n" );
-    showPlugs( syncMSUInputPlugs );
-    debugOutput( DEBUG_LEVEL_VERBOSE, "MSU Sync Output Plugs:\n" );
-    showPlugs( syncMSUOutputPlugs );
-
-    // Check all possible PCR input to MSU input connections
-    // -> sync stream input
-    checkSyncConnectionsAndAddToList( syncPCRInputPlugs,
-                                      syncMSUInputPlugs,
-                                      "Sync Stream Input" );
-
-    // Check all possible MSU output to PCR output connections
-    // -> sync stream output
-    checkSyncConnectionsAndAddToList( syncMSUOutputPlugs,
-                                      syncPCROutputPlugs,
-                                      "Sync Stream Output" );
-
-    // Check all PCR iso input to MSU input connections
-    // -> SYT match
-    checkSyncConnectionsAndAddToList( isoPCRInputPlugs,
-                                      syncMSUInputPlugs,
-                                      "Syt Match" );
-
-    // Check all MSU sync output to MSU input connections
-    // -> CSP
-    checkSyncConnectionsAndAddToList( syncMSUOutputPlugs,
-                                      syncMSUInputPlugs,
-                                      "Internal (CSP)" );
-
-    // Check all external PCR digital input to MSU input connections
-    // -> SPDIF/ADAT sync
-    checkSyncConnectionsAndAddToList( digitalPCRInputPlugs,
-                                      syncMSUInputPlugs,
-                                      "Digital Input Sync" );
-
-    // Currently active connection signal source cmd, command type
-    // status, source unknown, destination MSU sync input plug
-
-    for ( PlugVector::const_iterator it = syncMSUInputPlugs.begin();
-          it != syncMSUInputPlugs.end();
-          ++it )
-    {
-        AVC::Plug* msuPlug = *it;
-        for ( PlugVector::const_iterator jt =
-                  msuPlug->getInputConnections().begin();
-              jt != msuPlug->getInputConnections().end();
-              ++jt )
-        {
-            AVC::Plug* plug = *jt;
-
-            for ( SyncInfoVector::iterator it = m_syncInfos.begin();
-                  it != m_syncInfos.end();
-                  ++it )
-            {
-                SyncInfo* pSyncInfo = &*it;
-                if ( ( pSyncInfo->m_source == plug )
-                     && ( pSyncInfo->m_destination == msuPlug ) )
-                {
-                    m_activeSyncInfo = pSyncInfo;
-                    break;
-                }
-            }
-            debugOutput( DEBUG_LEVEL_NORMAL,
-                         "Active Sync Connection: '%s' -> '%s'\n",
-                         plug->getName(),
-                         msuPlug->getName() );
-        }
-    }
-
-    return true;
-}
@@ -821 +412 @@
-}
-
-bool
-AvDevice::checkSyncConnectionsAndAddToList( PlugVector& plhs,
-                                            PlugVector& prhs,
-                                            std::string syncDescription )
-{
-    for ( PlugVector::iterator plIt = plhs.begin();
-          plIt != plhs.end();
-          ++plIt )
-    {
-        AVC::Plug* pl = *plIt;
-        for ( PlugVector::iterator prIt = prhs.begin();
-              prIt != prhs.end();
-              ++prIt )
-        {
-            AVC::Plug* pr = *prIt;
-            if ( pl->inquireConnnection( *pr ) ) {
-                m_syncInfos.push_back( SyncInfo( *pl, *pr, syncDescription ) );
-                debugOutput( DEBUG_LEVEL_NORMAL,
-                             "Sync connection '%s' -> '%s'\n",
-                             pl->getName(),
-                             pr->getName() );
-            }
-        }
-    }
-    return true;
-}
-
-bool AvDevice::setActiveSync(const SyncInfo& syncInfo)
-{
-    return syncInfo.m_source->setConnection( *syncInfo.m_destination );
-}
-
-bool
@@ -863 +423 @@
-        // don't lock
-    } else {
-
+
-    }
-
@@ -879 +439 @@
-        // don't unlock
-    } else {
-
+
-    }
-    return true;
@@ -1018 +578 @@
-                        // but bebob reports it starting from 1. Decide where
-                        // and how to handle this (pp: here)
+                        // note that the descriptor mechanism specifies indexing from 0
-                        channelInfo->m_streamPosition - 1,
-                        channelInfo->m_location - 1,
@@ -1028 +589 @@
-                        portname.str(),
-                        direction,
-
-
-
-
-
+
+
+
+
+
+
+
-                        Streaming::AmdtpPortInfo::E_Midi
-                );

branches/echoaudio/src/bebob/bebob_avdevice.h

@@ -88 +88 @@
-    virtual void showDevice();
-
-    bool setActiveSync( const SyncInfo& syncInfo );
-
-    bool serialize( Glib::ustring basePath, Util::IOSerialize& ser ) const;
-    static AvDevice* deserialize( Glib::ustring basePath,
@@ -100 +98 @@
-    ConfigRom& getConfigRom() const 
-        { return FFADODevice::getConfigRom(); };
-
+
+
+
+
+
+
+
+
+
+
+
-protected:
-
-    bool enumerateSubUnits();
-
-    bool discoverPlugs();
-    bool discoverPlugsPCR( AVC::Plug::EPlugDirection plugDirection,
-                           AVC::plug_id_t plugMaxId );
-    bool discoverPlugsExternal( AVC::Plug::EPlugDirection plugDirection,
-                                AVC::plug_id_t plugMaxId );
-    bool discoverPlugConnections();
-    bool discoverSyncModes();
-    bool discoverSubUnitsPlugConnections();
-
-    bool addPlugToProcessor( AVC::Plug& plug, Streaming::StreamProcessor *processor,
@@ -121 +118 @@
-                                   AVC::ESamplingFrequency samplingFrequency );
-
-
-
-
+
-
-protected:

branches/echoaudio/src/bebob/bebob_avdevice_subunit.cpp

@@ -36 +36 @@
-using namespace AVC;
-
-IMPL_DEBUG_MODULE( BeBoB::Subunit, BeBoB::Subunit, DEBUG_LEVEL_VERBOSE );
-IMPL_DEBUG_MODULE( BeBoB::SubunitAudio, BeBoB::SubunitAudio, DEBUG_LEVEL_VERBOSE );
-IMPL_DEBUG_MODULE( BeBoB::SubunitMusic, BeBoB::SubunitMusic, DEBUG_LEVEL_VERBOSE );
-
-bool
-BeBoB::Subunit::discover()
-{
-    if ( !discoverPlugs() ) {
-        debugError( "plug discovering failed\n" );
-        return false;
-    }
-
-    return true;
-}
-
-bool
-BeBoB::Subunit::discoverPlugs()
-{
-    PlugInfoCmd plugInfoCmd( getUnit().get1394Service(),
-                             PlugInfoCmd::eSF_SerialBusIsochronousAndExternalPlug );
-    plugInfoCmd.setNodeId( getUnit().getConfigRom().getNodeId() );
-    plugInfoCmd.setCommandType( AVCCommand::eCT_Status );
-    plugInfoCmd.setSubunitType( getSubunitType() );
-    plugInfoCmd.setSubunitId( getSubunitId() );
-    plugInfoCmd.setVerbose( getDebugLevel() );
-
-    if ( !plugInfoCmd.fire() ) {
-        debugError( "plug info command failed\n" );
-        return false;
-    }
-
-    debugOutput( DEBUG_LEVEL_NORMAL, "number of source plugs = %d\n",
-                 plugInfoCmd.m_sourcePlugs );
-    debugOutput( DEBUG_LEVEL_NORMAL, "number of destination output "
-                 "plugs = %d\n", plugInfoCmd.m_destinationPlugs );
-
-    if ( !discoverPlugs( Plug::eAPD_Input,
-                         plugInfoCmd.m_destinationPlugs ) )
-    {
-        debugError( "destination plug discovering failed\n" );
-        return false;
-    }
-
-    if ( !discoverPlugs(  Plug::eAPD_Output,
-                          plugInfoCmd.m_sourcePlugs ) )
-    {
-        debugError( "source plug discovering failed\n" );
-        return false;
-    }
-
-    return true;
-}
-
-bool
-BeBoB::Subunit::discoverConnections()
-{
-    debugOutput(DEBUG_LEVEL_NORMAL, "Discovering connections...\n");
-    
-    for ( PlugVector::iterator it = getPlugs().begin();
-          it != getPlugs().end();
-          ++it )
-    {
-        BeBoB::Plug* plug = dynamic_cast<BeBoB::Plug*>(*it);
-        if(!plug) {
-            debugError("BUG: not a bebob plug\n");
-            return false;
-        }
-        if ( !plug->discoverConnections() ) {
-            debugError( "plug connection discovering failed ('%s')\n",
-                        plug->getName() );
-            return false;
-        }
-    }
-
-    return true;
-}
-
-bool
-BeBoB::Subunit::discoverPlugs(Plug::EPlugDirection plugDirection,
-                                      plug_id_t plugMaxId )
-{
-    debugOutput(DEBUG_LEVEL_NORMAL, "Discovering plugs...\n");
-    for ( int plugIdx = 0;
-          plugIdx < plugMaxId;
-          ++plugIdx )
-    {
-        ESubunitType subunitType =
-            static_cast<ESubunitType>( getSubunitType() );
-        BeBoB::Plug* plug = new BeBoB::Plug( &getUnit(),
-                                             &getSubunit(),
-                                             0xff,
-                                             0xff,
-                                             Plug::eAPA_SubunitPlug,
-                                             plugDirection,
-                                             plugIdx );
-        if ( !plug ) {
-            debugError( "plug creation failed\n" );
-            return false;
-        }
-        
-        plug->setVerboseLevel(getDebugLevel());
-        
-        if ( !plug->discover() ) {
-            debugError( "plug discover failed\n" );
-            return false;
-        }
-
-        debugOutput( DEBUG_LEVEL_NORMAL, "plug '%s' found\n",
-                     plug->getName() );
-        getPlugs().push_back( plug );
-    }
-    return true;
-}
-
-
-//////////////////////////
-
@@ -156 +41 @@
-                                   subunit_t id )
-    : AVC::SubunitAudio( avDevice, id )
-    , BeBoB::Subunit()
-{
-}
@@ -168 +52 @@
-{
-
+}
+
+AVC::Plug *
+BeBoB::SubunitAudio::createPlug( AVC::Unit* unit,
+                     AVC::Subunit* subunit,
+                     AVC::function_block_type_t functionBlockType,
+                     AVC::function_block_type_t functionBlockId,
+                     AVC::Plug::EPlugAddressType plugAddressType,
+                     AVC::Plug::EPlugDirection plugDirection,
+                     AVC::plug_id_t plugId )
+{
+
+    return new BeBoB::Plug( unit,
+                     subunit,
+                     functionBlockType,
+                     functionBlockId,
+                     plugAddressType,
+                     plugDirection,
+                     plugId );
-}
-
@@ -179 +82 @@
-        return false;
-    }
-    
-    // do BeBoB subunit specific discovery
-    if ( !BeBoB::Subunit::discover() ) {
-        return false;
-    }
-
-    // do the remaining BeBoB audio subunit discovery
@@ -198 +96 @@
-{
-    debugOutput(DEBUG_LEVEL_NORMAL, "Discovering connections...\n");
-BeBoB::
+
-        return false;
-    }
@@ -488 +386 @@
-                                   subunit_t id )
-    : AVC::SubunitMusic( avDevice, id )
-    , BeBoB::Subunit()
-{
-}
@@ -494 +391 @@
-BeBoB::SubunitMusic::SubunitMusic()
-    : AVC::SubunitMusic()
-    , BeBoB::Subunit()
-{
-}
@@ -500 +396 @@
-BeBoB::SubunitMusic::~SubunitMusic()
-{
+}
+
+AVC::Plug *
+BeBoB::SubunitMusic::createPlug( AVC::Unit* unit,
+                     AVC::Subunit* subunit,
+                     AVC::function_block_type_t functionBlockType,
+                     AVC::function_block_type_t functionBlockId,
+                     AVC::Plug::EPlugAddressType plugAddressType,
+                     AVC::Plug::EPlugDirection plugDirection,
+                     AVC::plug_id_t plugId )
+{
+
+    return new BeBoB::Plug( unit,
+                     subunit,
+                     functionBlockType,
+                     functionBlockId,
+                     plugAddressType,
+                     plugDirection,
+                     plugId );
-}
-
@@ -511 +426 @@
-        return false;
-    }
-    
-    // do BeBoB subunit specific discovery
-    if ( !BeBoB::Subunit::discover() ) {
-        return false;
-    }
-
-    // do the remaining BeBoB music subunit discovery

branches/echoaudio/src/bebob/bebob_avdevice_subunit.h

@@ -44 +44 @@
-/////////////////////////////
-
-class Subunit {
-public:
-    Subunit() {};
-    virtual ~Subunit() {};
-    virtual bool discover();
-    virtual bool discoverConnections();
-    
-    // required functions
-    // implemented by the derived class
-    virtual const char* getName() = 0;
-    virtual AVC::subunit_t getSubunitId() = 0;
-    virtual AVC::ESubunitType getSubunitType() = 0;
-    virtual AVC::Unit& getUnit() const = 0;
-    virtual AVC::Subunit& getSubunit() = 0;
-    virtual AVC::PlugVector& getPlugs() = 0;
-
-protected:
-    bool discoverPlugs();
-    bool discoverPlugs(Plug::EPlugDirection plugDirection,
-                       AVC::plug_id_t plugMaxId );
-private:
-    DECLARE_DEBUG_MODULE;
-};
-
-/////////////////////////////
-
-class SubunitAudio : public AVC::SubunitAudio
-                   , public BeBoB::Subunit
-{
-public:
@@ -82 +55 @@
-    virtual bool discoverConnections();
-
-
+
+
+
+
+
+
+
+
-    virtual const char* getName();
-    virtual AVC::subunit_t getSubunitId() 
-        { return AVC::SubunitAudio::getSubunitId(); };
-    virtual AVC::ESubunitType getSubunitType()
-        { return AVC::SubunitAudio::getSubunitType(); };
-    virtual AVC::Unit& getUnit() const
-        { return AVC::SubunitAudio::getUnit(); };
-    virtual AVC::Subunit& getSubunit()
-        { return *this; };
-    virtual AVC::PlugVector& getPlugs()
-        { return AVC::SubunitAudio::getPlugs(); };
-
-protected:
@@ -111 +81 @@
-                                   Util::IODeserialize& deser,
-                                   AVC::Unit& unit );
-
-
+
-};
-
@@ -118 +87 @@
-
-class SubunitMusic : public AVC::SubunitMusic
-                   , public BeBoB::Subunit
-{
- public:
@@ -126 +94 @@
-    virtual ~SubunitMusic();
-
-
+
+
+
+
+
+
+
+
+
+
-    virtual const char* getName();
-    virtual AVC::subunit_t getSubunitId() 
-        { return AVC::SubunitMusic::getSubunitId(); };
-    virtual AVC::ESubunitType getSubunitType()
-        { return AVC::SubunitMusic::getSubunitType(); };
-    virtual AVC::Unit& getUnit() const
-        { return AVC::SubunitMusic::getUnit(); };
-    virtual AVC::Subunit& getSubunit()
-        { return *this; };
-    virtual AVC::PlugVector& getPlugs()
-        { return AVC::SubunitMusic::getPlugs(); };
-
-    
-    virtual bool discover();
-
-protected:
@@ -148 +112 @@
-                                   Util::IODeserialize& deser,
-                                   AVC::Unit& unit );
-
-
+
-};
-

branches/echoaudio/src/bebob/bebob_avplug.cpp

@@ -423 +423 @@
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-
@@ -760 +761 @@
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+

branches/echoaudio/src/bebob/bebob_avplug.h

@@ -74 +74 @@
-    bool discoverChannelName();
-    bool discoverClusterInfo();
-    bool discoverStreamFormat();
-    bool discoverSupportedStreamFormats();
-    bool discoverConnectionsInput();
-    bool discoverConnectionsOutput();
-
-    AVC::ExtendedPlugInfoCmd setPlugAddrToPlugInfoCmd();
-
-    AVC::ExtendedStreamFormatCmd setPlugAddrToStreamFormatCmd(
-            AVC::ExtendedStreamFormatCmd::ESubFunction subFunction);
-
-private:

branches/echoaudio/src/genericavc/avc_avdevice.cpp

@@ -1 +1 @@
-/*
- * Copyright (C) 2005-2007 by Pieter Palmers
+ * Copyright (C) 2005-2007 by Daniel Wagner
- *
- * This file is part of FFADO
@@ -30 +31 @@
-
-#include "libavc/avc_definitions.h"
+#include "libavc/general/avc_plug_info.h"
-
-#include "debugmodule/debugmodule.h"
@@ -42 +44 @@
-#include <libraw1394/csr.h>
-
+using namespace AVC;
+
-namespace GenericAVC {
+
+IMPL_DEBUG_MODULE( AvDevice, AvDevice, DEBUG_LEVEL_VERBOSE );
-
-// to define the supported devices
@@ -105 +111 @@
-    }
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-}
-
-int
-AvDevice::getSamplingFrequency( ) {
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    return false;
+
-}
-
-bool
-AvDevice::lock() {
+    bool snoopMode=false;
+    if(!getOption("snoopMode", snoopMode)) {
+        debugWarning("Could not retrieve snoopMode parameter, defauling to false\n");
+    }
+
+    if (snoopMode) {
+        // don't lock
+    } else {
+//         return Unit::reserve(4);
+    }
-
-    return true;
-}
-
-
-bool
-AvDevice::unlock() {
-
+
+
+
+
+
+
+
+
+
+
-    return true;
-}
@@ -145 +245 @@
-        "%s %s at node %d\n", m_model->vendor_name, m_model->model_name,
-        m_nodeId);
+
+    m_pPlugManager->showPlugs();
+    flushDebugOutput();
-}
-
-bool
-AvDevice::prepare() {
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    return true;
-}
@@ -155 +441 @@
-int
-AvDevice::getStreamCount() {
-0
+m_receiveProcessors.size() + m_transmitProcessors.size()
-}
-
@@ -161 +447 @@
-AvDevice::getStreamProcessorByIndex(int i) {
-
+    if (i<(int)m_receiveProcessors.size()) {
+        return m_receiveProcessors.at(i);
+    } else if (i<(int)m_receiveProcessors.size() + (int)m_transmitProcessors.size()) {
+        return m_transmitProcessors.at(i-m_receiveProcessors.size());
+    }
+
-    return NULL;
-}
@@ -166 +458 @@
-bool
-AvDevice::startStreamByIndex(int i) {
+    int iso_channel=-1;
+    bool snoopMode=false;
+    if(!getOption("snoopMode", snoopMode)) {
+        debugWarning("Could not retrieve snoopMode parameter, defauling to false\n");
+    }
+
+    if (i<(int)m_receiveProcessors.size()) {
+        int n=i;
+        Streaming::StreamProcessor *p=m_receiveProcessors.at(n);
+
+        if(snoopMode) { // a stream from the device to another host
+            // FIXME: put this into a decent framework!
+            // we should check the oPCR[n] on the device
+            struct iec61883_oPCR opcr;
+            if (iec61883_get_oPCRX(
+                    get1394Service().getHandle(),
+                    m_pConfigRom->getNodeId() | 0xffc0,
+                    (quadlet_t *)&opcr,
+                    n)) {
+
+                debugWarning("Error getting the channel for SP %d\n",i);
+                return false;
+            }
+
+            iso_channel=opcr.channel;
+        } else {
+            iso_channel=get1394Service().allocateIsoChannelCMP(
+                m_pConfigRom->getNodeId() | 0xffc0, n,
+                get1394Service().getLocalNodeId()| 0xffc0, -1);
+        }
+        if (iso_channel<0) {
+            debugError("Could not allocate ISO channel for SP %d\n",i);
+            return false;
+        }
+
+        debugOutput(DEBUG_LEVEL_VERBOSE, "Started SP %d on channel %d\n",i,iso_channel);
+
+        p->setChannel(iso_channel);
+        return true;
+
+    } else if (i<(int)m_receiveProcessors.size() + (int)m_transmitProcessors.size()) {
+        int n=i-m_receiveProcessors.size();
+        Streaming::StreamProcessor *p=m_transmitProcessors.at(n);
+
+        if(snoopMode) { // a stream from another host to the device
+            // FIXME: put this into a decent framework!
+            // we should check the iPCR[n] on the device
+            struct iec61883_iPCR ipcr;
+            if (iec61883_get_iPCRX(
+                    get1394Service().getHandle(),
+                    m_pConfigRom->getNodeId() | 0xffc0,
+                    (quadlet_t *)&ipcr,
+                    n)) {
+
+                debugWarning("Error getting the channel for SP %d\n",i);
+                return false;
+            }
+
+            iso_channel=ipcr.channel;
+
+        } else {
+            iso_channel=get1394Service().allocateIsoChannelCMP(
+                get1394Service().getLocalNodeId()| 0xffc0, -1,
+                m_pConfigRom->getNodeId() | 0xffc0, n);
+        }
+
+        if (iso_channel<0) {
+            debugError("Could not allocate ISO channel for SP %d\n",i);
+            return false;
+        }
+
+        debugOutput(DEBUG_LEVEL_VERBOSE, "Started SP %d on channel %d\n",i,iso_channel);
+
+        p->setChannel(iso_channel);
+        return true;
+    }
+
+    debugError("SP index %d out of range!\n",i);
-    return false;
-}
@@ -171 +541 @@
-bool
-AvDevice::stopStreamByIndex(int i) {
+    bool snoopMode=false;
+    if(!getOption("snoopMode", snoopMode)) {
+        debugWarning("Could not retrieve snoopMode parameter, defauling to false\n");
+    }
+
+    if (i<(int)m_receiveProcessors.size()) {
+        int n=i;
+        Streaming::StreamProcessor *p=m_receiveProcessors.at(n);
+
+        if(snoopMode) {
+
+        } else {
+            // deallocate ISO channel
+            if(!get1394Service().freeIsoChannel(p->getChannel())) {
+                debugError("Could not deallocate iso channel for SP %d\n",i);
+                return false;
+            }
+        }
+        p->setChannel(-1);
+
+        return true;
+
+    } else if (i<(int)m_receiveProcessors.size() + (int)m_transmitProcessors.size()) {
+        int n=i-m_receiveProcessors.size();
+        Streaming::StreamProcessor *p=m_transmitProcessors.at(n);
+
+        if(snoopMode) {
+
+        } else {
+            // deallocate ISO channel
+            if(!get1394Service().freeIsoChannel(p->getChannel())) {
+                debugError("Could not deallocate iso channel for SP %d\n",i);
+                return false;
+            }
+        }
+        p->setChannel(-1);
+
+        return true;
+    }
+
+    debugError("SP index %d out of range!\n",i);
-    return false;
-}

branches/echoaudio/src/genericavc/avc_avdevice.h

@@ -1 +1 @@
-/*
- * Copyright (C) 2005-2007 by Pieter Palmers
+ * Copyright (C) 2005-2007 by Daniel Wagner
- *
- * This file is part of FFADO
@@ -28 +29 @@
-
-#include "debugmodule/debugmodule.h"
+
-#include "libavc/avc_definitions.h"
+#include "libavc/general/avc_unit.h"
+#include "libavc/general/avc_subunit.h"
+#include "libavc/general/avc_plug.h"
+
+#include "libstreaming/AmdtpStreamProcessor.h"
+#include "libstreaming/AmdtpPort.h"
+#include "libstreaming/AmdtpPortInfo.h"
-
-class ConfigRom;
@@ -43 +52 @@
-};
-
-
+, public AVC::Unit
-public:
-    AvDevice( std::auto_ptr<ConfigRom>( configRom ),
@@ -67 +76 @@
-    bool startStreamByIndex(int i);
-    bool stopStreamByIndex(int i);
-
+
+
+
+
+
+
+
-protected:
+    bool addPlugToProcessor( AVC::Plug& plug, Streaming::StreamProcessor *processor,
+                             Streaming::AmdtpAudioPort::E_Direction direction);
+    bool setSamplingFrequencyPlug( AVC::Plug& plug,
+                                   AVC::Plug::EPlugDirection direction,
+                                   AVC::ESamplingFrequency samplingFrequency );
+    
-    struct VendorModelEntry *m_model;
-
+
+
+
+
+
+
+
-};
-

branches/echoaudio/src/libavc/avc_definitions.cpp

@@ -23 +23 @@
-
-#include "avc_definitions.h"
-
+
-
-namespace AVC {
@@ -154 +154 @@
-};
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

branches/echoaudio/src/libavc/avc_definitions.h

@@ -22 +22 @@
- */
-
-D
-D
+C
+C
-
-#include <libavc1394/avc1394.h>
@@ -116 +116 @@
-};
-
+enum ESubunitType byteToSubunitType(byte_t s);
+
-/**
- * \brief the possible sampling frequencies
@@ -151 +153 @@
-std::ostream& operator<<( std::ostream& stream, ESamplingFrequency samplingFrequency );
-
+/**
+ * \brief Convert from a FDF SFC field value to an integer sample rate
+ * @param fdf fdf sfc field value
+ * @return sample rate
+ */
+unsigned int fdfSfcToSampleRate(byte_t fdf);
+
+/**
+ * \brief Convert from an integer sample rate to a78 FDF SFC field value
+ * @param rate integer sample rate
+ * @return fdf sfc field value
+ */
+byte_t sampleRateToFdfSfc(unsigned int rate);
+
-}
-
-D
+C

branches/echoaudio/src/libavc/descriptors/avc_descriptor.cpp

@@ -25 +25 @@
-#include "avc_descriptor_cmd.h"
-
+#include "../general/avc_unit.h"
+#include "../general/avc_subunit.h"
+
-#include "../util/avc_serialize.h"
-#include "libieee1394/ieee1394service.h"
+#include "libieee1394/configrom.h"
-
-namespace AVC {
@@ -101 +105 @@
-
-//----------------------
-Ieee1394Service& ieee1394service
+Unit* unit
-    : IBusData()
-
-
-
-
+
+
-    , m_specifier ( AVCDescriptorSpecifier::eInvalid )
-    , m_data ( NULL )
-    , m_descriptor_length(0)
-
-
-
-
-                              fb_nodeid_t nodeId, ESubunitType subunitType, subunit_id_t subunitId
+
+
+
+
+AVCDescriptor::AVCDescriptor( Unit* unit, Subunit* subunit
-    : IBusData()
-
-
-
-
+
+
-    , m_specifier ( AVCDescriptorSpecifier::eInvalid )
-    , m_data ( NULL )
-    , m_descriptor_length(0)
-
-
-
-
-                              fb_nodeid_t nodeId, ESubunitType subunitType, subunit_id_t subunitId
+
+
+
+
+AVCDescriptor::AVCDescriptor( Unit* unit, Subunit* subunit
-                              AVCDescriptorSpecifier s )
-    : IBusData()
-
-
-
-
+
+
-    , m_specifier ( s )
-    , m_data ( NULL )
-    , m_descriptor_length(0)
+    , m_loaded ( false )
-{
-}
@@ -144 +143 @@
-    if (m_data != NULL) free(m_data);
-}
+bool
+AVCDescriptor::reload()
+{
+    m_loaded=false;
+    return load();
+}
-
-bool
@@ -149 +154 @@
-{
-    bool result;
-
+
+
+
+
+
+
+
-
-    debugOutput(DEBUG_LEVEL_VERBOSE, " Open descriptor (%s)\n",getDescriptorName());
-    openDescCmd.setMode( OpenDescriptorCmd::eRead );
-    openDescCmd.m_specifier=&m_specifier;
-nodeId
+unit->getConfigRom().getNodeId()
-    openDescCmd.setCommandType( AVCCommand::eCT_Control );
-    openDescCmd.setSubunitType( getSubunitType() );
@@ -168 +179 @@
-    
-    debugOutput(DEBUG_LEVEL_VERBOSE, " Read status descriptor\n");
-*m_p1394Service
+m_unit->get1394Service()
-    readDescCmd.m_specifier=&m_specifier;
-nodeId
+unit->getConfigRom().getNodeId()
-    readDescCmd.setCommandType( AVCCommand::eCT_Control );
-    readDescCmd.setSubunitType( getSubunitType() );
@@ -210 +221 @@
-        readDescCmd.clear();
-        readDescCmd.m_specifier=&m_specifier;
-nodeId
+unit->getConfigRom().getNodeId()
-        readDescCmd.setCommandType( AVCCommand::eCT_Control );
-        readDescCmd.setSubunitType( getSubunitType() );
@@ -251 +262 @@
-    openDescCmd.setMode( OpenDescriptorCmd::eClose );
-    openDescCmd.m_specifier=&m_specifier;
-nodeId
+unit->getConfigRom().getNodeId()
-    openDescCmd.setCommandType( AVCCommand::eCT_Control );
-    openDescCmd.setSubunitType( getSubunitType() );
@@ -289 +300 @@
-    }
-#endif
+    m_loaded=true;
-    return true;
-}
@@ -309 +321 @@
-    return new AVCDescriptor( *this );
-}
-bool
-AVCDescriptor::setSubunitType(ESubunitType subunitType)
-{
-    m_subunit_type = subunitType;
-    return true;
-}
-
-bool
-AVCDescriptor::setNodeId( fb_nodeid_t nodeId )
-{
-    m_nodeId = nodeId;
-    return true;
-}
-
-bool
-AVCDescriptor::setSubunitId(subunit_id_t subunitId)
-{
-    m_subunit_id = subunitId & 0x7;
-    return true;
-}
-
-ESubunitType
-
-
-m_subunit_type;
-
-
-
-
-
-m_subunit_id
-
-
-
-
+ const
+
+(m_subunit==NULL?eST_Unit:m_subunit->getSubunitType()); 
+
+
+ 
+ const
+
+(m_subunit==NULL?0xFF:m_subunit->getSubunitId())
+
+
+
+Level
-{
-    setDebugLevel(verboseLevel);

branches/echoaudio/src/libavc/descriptors/avc_descriptor.h

@@ -47 +47 @@
-
-namespace AVC {
+
+class Unit;
+class Subunit;
-
-class IOSSerialize;
@@ -112 +115 @@
-
-    // note: in the end these have to be protected
-
-
-
-
-
-
+
+
+
-    virtual ~AVCDescriptor();
-    
@@ -123 +123 @@
-    
-    void setSpecifier(AVCDescriptorSpecifier s) {m_specifier=s;};
-
-
-
-
-
-
-
-
-
+
+
+
+
+
-    int getVerboseLevel();
-
@@ -138 +134 @@
-    
-    bool load();
+    bool reload();
-    
-protected:
-
-
-
-
-
+
+
-    
-    AVCDescriptorSpecifier m_specifier;
-    
-
-
-
-
-
-
+
+
+
+
+
-};
-

branches/echoaudio/src/libavc/general/avc_connect.cpp

@@ -45 +45 @@
-ConnectCmd::serialize( IOSSerialize& se )
-{
-
-
+
+
+
-}
-
@@ -52 +53 @@
-ConnectCmd::deserialize( IISDeserialize& de )
-{
-
-
+
+
+
-}
-

branches/echoaudio/src/libavc/general/avc_plug.cpp

@@ -25 +25 @@
-#include "avc_plug.h"
-#include "avc_unit.h"
+#include "avc_signal_format.h"
+
-#include "libieee1394/configrom.h"
-
@@ -123 +125 @@
-
-bool
+Plug::discover()
+{
+
+    if ( !initFromDescriptor() ) {
+        debugError( "discover: Could not init plug from descriptor (%d,%d,%d,%d,%d)\n",
+                    m_unit->getConfigRom().getNodeId(), getSubunitType(), getSubunitId(), m_direction, m_id );
+//         return false;
+    }
+
+    if ( !discoverPlugType() ) {
+        debugError( "discover: Could not discover plug type (%d,%d,%d,%d,%d)\n",
+                    m_unit->getConfigRom().getNodeId(), getSubunitType(), getSubunitId(), m_direction, m_id );
+        return false;
+    }
+
+    if ( !discoverName() ) {
+        debugError( "Could not discover name (%d,%d,%d,%d,%d)\n",
+                    m_unit->getConfigRom().getNodeId(), getSubunitType(), getSubunitId(), m_direction, m_id );
+        return false;
+    }
+
+    if ( !discoverNoOfChannels() ) {
+        debugError( "Could not discover number of channels "
+                    "(%d,%d,%d,%d,%d)\n",
+                    m_unit->getConfigRom().getNodeId(), getSubunitType(), getSubunitId(), m_direction, m_id );
+        return false;
+    }
+
+    if ( !discoverChannelPosition() ) {
+        debugError( "Could not discover channel positions "
+                    "(%d,%d,%d,%d,%d)\n",
+                    m_unit->getConfigRom().getNodeId(), getSubunitType(), getSubunitId(), m_direction, m_id );
+        return false;
+    }
+
+    if ( !discoverChannelName() ) {
+        debugError( "Could not discover channel name "
+                    "(%d,%d,%d,%d,%d)\n",
+                    m_unit->getConfigRom().getNodeId(), getSubunitType(), getSubunitId(), m_direction, m_id );
+        return false;
+    }
+
+    if ( !discoverClusterInfo() ) {
+        debugError( "Could not discover channel name "
+                    "(%d,%d,%d,%d,%d)\n",
+                    m_unit->getConfigRom().getNodeId(), getSubunitType(), getSubunitId(), m_direction, m_id );
+        return false;
+    }
+
+    if ( !discoverStreamFormat() ) {
+        debugError( "Could not discover stream format "
+                    "(%d,%d,%d,%d,%d)\n",
+                    m_unit->getConfigRom().getNodeId(), getSubunitType(), getSubunitId(), m_direction, m_id );
+//         return false;
+    }
+
+    if ( !discoverSupportedStreamFormats() ) {
+        debugError( "Could not discover supported stream formats "
+                    "(%d,%d,%d,%d,%d)\n",
+                    m_unit->getConfigRom().getNodeId(), getSubunitType(), getSubunitId(), m_direction, m_id );
+//         return false;
+    }
+
+    return m_unit->getPlugManager().addPlug( *this );
+}
+
+bool
+Plug::initFromDescriptor()
+{
+    if(getSubunitType()==eST_Unit) {
+        debugOutput(DEBUG_LEVEL_VERBOSE, "Not loading unit plug from descriptor.\n");
+        return true;
+    } else {
+        return m_subunit->initPlugFromDescriptor(*this);
+    }
+}
+
+bool
+Plug::discoverConnections()
+{
+    return discoverConnectionsInput() && discoverConnectionsOutput();
+}
+
+bool
+Plug::discoverPlugType()
+{
+
+    return true;
+}
+
+bool
+Plug::discoverName()
+{
+    // name already set
+    if (m_name != "") return true;
+    
+    m_name = plugAddressTypeToString(getPlugAddressType());
+    m_name += " ";
+    m_name += plugTypeToString(getPlugType());
+    m_name += " ";
+    m_name += plugDirectionToString(getPlugDirection());
+
+    return true;
+}
+
+bool
+Plug::discoverNoOfChannels()
+{
+
+    return true;
+}
+
+bool
+Plug::discoverChannelPosition()
+{
+
+    return true;
+}
+
+bool
+Plug::discoverChannelName()
+{
+    
+    return true;
+}
+
+bool
+Plug::discoverClusterInfo()
+{
+
+    return true;
+}
+
+bool
+Plug::discoverStreamFormat()
+{
+    ExtendedStreamFormatCmd extStreamFormatCmd =
+        setPlugAddrToStreamFormatCmd( ExtendedStreamFormatCmd::eSF_ExtendedStreamFormatInformationCommand );
+    extStreamFormatCmd.setVerbose( getDebugLevel() );
+
+    if ( !extStreamFormatCmd.fire() ) {
+        debugError( "stream format command failed\n" );
+        return false;
+    }
+
+    if ( ( extStreamFormatCmd.getStatus() ==  ExtendedStreamFormatCmd::eS_NoStreamFormat )
+         || ( extStreamFormatCmd.getStatus() ==  ExtendedStreamFormatCmd::eS_NotUsed ) )
+    {
+        debugOutput( DEBUG_LEVEL_VERBOSE,
+                     "No stream format information available\n" );
+        return true;
+    }
+
+    if ( !extStreamFormatCmd.getFormatInformation() ) {
+        debugWarning( "No stream format information for plug found -> skip\n" );
+        return true;
+    }
+
+    if ( extStreamFormatCmd.getFormatInformation()->m_root
+           != FormatInformation::eFHR_AudioMusic  )
+    {
+        debugWarning( "Format hierarchy root is not Audio&Music -> skip\n" );
+        return true;
+    }
+
+    FormatInformation* formatInfo =
+        extStreamFormatCmd.getFormatInformation();
+    FormatInformationStreamsCompound* compoundStream
+        = dynamic_cast< FormatInformationStreamsCompound* > (
+            formatInfo->m_streams );
+    if ( compoundStream ) {
+        m_samplingFrequency =
+            compoundStream->m_samplingFrequency;
+        debugOutput( DEBUG_LEVEL_VERBOSE,
+                     "%s plug %d uses "
+                     "sampling frequency %d, nr of stream infos = %d\n",
+                     getName(),
+                     m_id,
+                     m_samplingFrequency,
+                     compoundStream->m_numberOfStreamFormatInfos );
+
+        for ( int i = 1;
+              i <= compoundStream->m_numberOfStreamFormatInfos;
+              ++i )
+        {
+            ClusterInfo* clusterInfo =
+                const_cast<ClusterInfo*>( getClusterInfoByIndex( i ) );
+
+            if ( !clusterInfo ) {
+                debugError( "No matching cluster "
+                            "info found for index %d\n",  i );
+                    return false;
+            }
+            StreamFormatInfo* streamFormatInfo =
+                compoundStream->m_streamFormatInfos[ i - 1 ];
+
+            debugOutput( DEBUG_LEVEL_VERBOSE,
+                         "number of channels = %d, stream format = %d\n",
+                         streamFormatInfo->m_numberOfChannels,
+                         streamFormatInfo->m_streamFormat );
+
+            int nrOfChannels = clusterInfo->m_nrOfChannels;
+            if ( streamFormatInfo->m_streamFormat ==
+                 FormatInformation::eFHL2_AM824_MIDI_CONFORMANT )
+            {
+                // 8 logical midi channels fit into 1 channel
+                nrOfChannels = ( ( nrOfChannels + 7 ) / 8 );
+            }
+            // sanity check
+            if ( nrOfChannels != streamFormatInfo->m_numberOfChannels )
+            {
+                debugWarning( "Number of channels "
+                              "mismatch: '%s' plug discovering reported "
+                              "%d channels for cluster '%s', while stream "
+                              "format reported %d\n",
+                              getName(),
+                              nrOfChannels,
+                              clusterInfo->m_name.c_str(),
+                              streamFormatInfo->m_numberOfChannels);
+            }
+            clusterInfo->m_streamFormat = streamFormatInfo->m_streamFormat;
+
+            debugOutput( DEBUG_LEVEL_VERBOSE,
+                         "%s plug %d cluster info %d ('%s'): "
+                         "stream format %d\n",
+                         getName(),
+                         m_id,
+                         i,
+                         clusterInfo->m_name.c_str(),
+                         clusterInfo->m_streamFormat );
+        }
+    }
+
+    FormatInformationStreamsSync* syncStream
+        = dynamic_cast< FormatInformationStreamsSync* > (
+            formatInfo->m_streams );
+    if ( syncStream ) {
+        m_samplingFrequency =
+            syncStream->m_samplingFrequency;
+        debugOutput( DEBUG_LEVEL_VERBOSE,
+                     "%s plug %d is sync stream with sampling frequency %d\n",
+                     getName(),
+                     m_id,
+                     m_samplingFrequency );
+    }
+
+
+    if ( !compoundStream && !syncStream )
+    {
+        debugError( "Unsupported stream format\n" );
+        return false;
+    }
+
+    return true;
+}
+
+bool
+Plug::discoverSupportedStreamFormats()
+{
+    ExtendedStreamFormatCmd extStreamFormatCmd =
+        setPlugAddrToStreamFormatCmd(
+            ExtendedStreamFormatCmd::eSF_ExtendedStreamFormatInformationCommandList);
+    extStreamFormatCmd.setVerbose( getDebugLevel() );
+
+    int i = 0;
+    bool cmdSuccess = false;
+
+    do {
+        extStreamFormatCmd.setIndexInStreamFormat( i );
+        extStreamFormatCmd.setCommandType( AVCCommand::eCT_Status );
+        cmdSuccess = extStreamFormatCmd.fire();
+        if ( cmdSuccess
+             && ( extStreamFormatCmd.getResponse()
+                  == AVCCommand::eR_Implemented ) )
+        {
+            FormatInfo formatInfo;
+            formatInfo.m_index = i;
+            bool formatInfoIsValid = true;
+
+            FormatInformationStreamsSync* syncStream
+                = dynamic_cast< FormatInformationStreamsSync* >
+                ( extStreamFormatCmd.getFormatInformation()->m_streams );
+            if ( syncStream ) {
+                formatInfo.m_samplingFrequency =
+                    syncStream->m_samplingFrequency;
+                formatInfo.m_isSyncStream = true ;
+            }
+
+            FormatInformationStreamsCompound* compoundStream
+                = dynamic_cast< FormatInformationStreamsCompound* >
+                ( extStreamFormatCmd.getFormatInformation()->m_streams );
+            if ( compoundStream ) {
+                formatInfo.m_samplingFrequency =
+                    compoundStream->m_samplingFrequency;
+                formatInfo.m_isSyncStream = false;
+                for ( int j = 0;
+                      j < compoundStream->m_numberOfStreamFormatInfos;
+                      ++j )
+                {
+                    switch ( compoundStream->m_streamFormatInfos[j]->m_streamFormat ) {
+                    case AVC1394_STREAM_FORMAT_AM824_IEC60968_3:
+                        formatInfo.m_audioChannels +=
+                            compoundStream->m_streamFormatInfos[j]->m_numberOfChannels;
+                        break;
+                    case AVC1394_STREAM_FORMAT_AM824_MULTI_BIT_LINEAR_AUDIO_RAW:
+                        formatInfo.m_audioChannels +=
+                            compoundStream->m_streamFormatInfos[j]->m_numberOfChannels;
+                        break;
+                    case AVC1394_STREAM_FORMAT_AM824_MIDI_CONFORMANT:
+                        formatInfo.m_midiChannels +=
+                            compoundStream->m_streamFormatInfos[j]->m_numberOfChannels;
+                        break;
+                    default:
+                        formatInfoIsValid = false;
+                        debugWarning("unknown stream format (0x%02x) for channel "
+                                      "(%d)\n",
+                                     compoundStream->m_streamFormatInfos[j]->m_streamFormat,
+                                     j );
+                    }
+                }
+            }
+
+            if ( formatInfoIsValid ) {
+                flushDebugOutput();
+                debugOutput( DEBUG_LEVEL_VERBOSE,
+                             "[%s:%d] formatInfo[%d].m_samplingFrequency "
+                             "= %d\n",
+                             getName(), m_id,
+                             i, formatInfo.m_samplingFrequency );
+                debugOutput( DEBUG_LEVEL_VERBOSE,
+                             "[%s:%d] formatInfo[%d].m_isSyncStream = %d\n",
+                             getName(), m_id,
+                             i, formatInfo.m_isSyncStream );
+                debugOutput( DEBUG_LEVEL_VERBOSE,
+                             "[%s:%d] formatInfo[%d].m_audioChannels = %d\n",
+                             getName(), m_id,
+                             i, formatInfo.m_audioChannels );
+                debugOutput( DEBUG_LEVEL_VERBOSE,
+                             "[%s:%d] formatInfo[%d].m_midiChannels = %d\n",
+                             getName(), m_id,
+                             i, formatInfo.m_midiChannels );
+                m_formatInfos.push_back( formatInfo );
+                flushDebugOutput();
+            }
+        }
+
+        ++i;
+    } while ( cmdSuccess && ( extStreamFormatCmd.getResponse()
+                              == ExtendedStreamFormatCmd::eR_Implemented ) );
+
+    return true;
+}
+
+bool
+Plug::discoverConnectionsInput()
+{
+    debugOutput( DEBUG_LEVEL_VERBOSE, "Discovering incoming connections...\n");
+
+    int sourcePlugGlobalId=getSignalSource();
+    
+    if(sourcePlugGlobalId >= 0) {
+        Plug *p=m_unit->getPlugManager().getPlug(sourcePlugGlobalId);
+        if (p==NULL) {
+            debugError( "Plug with global id %d not found\n",sourcePlugGlobalId );
+            return false;
+        }
+        // connected to another plug
+        debugOutput( DEBUG_LEVEL_VERBOSE, "Plug '%s' gets signal from '%s'...\n",
+            getName(), p->getName() );
+
+
+
+        if ( p ) {
+            debugOutput( DEBUG_LEVEL_VERBOSE,
+                        "'(%d) %s' has a connection to '(%d) %s'\n",
+                        getGlobalId(),
+                        getName(),
+                        p->getGlobalId(),
+                        p->getName() );
+            addPlugConnection( m_inputConnections, *p );
+        } else {
+            debugError( "no corresponding plug found for '(%d) %s'\n",
+                        getGlobalId(),
+                        getName() );
+            return false;
+        }
+            
+    }
+
+    return true;
+}
+
+bool
+Plug::discoverConnectionsOutput()
+{
+    debugOutput( DEBUG_LEVEL_VERBOSE, "Discovering outgoing connections...\n");
+    
+//     int i=0;
+//     int nbPlugs=m_unit->getPlugManager().getPlugCount();
+//     debugOutput( DEBUG_LEVEL_VERBOSE, "checking %d plugs\n", nbPlugs);
+//     
+//     for (i=0;i<nbPlugs;i++) {
+//         Plug *p=m_unit->getPlugManager().getPlug(i);
+//         
+//         if(p==NULL) {
+//             debugError("could not get plug 0x%02X\n",i);
+//             continue;
+//         }
+//         
+//         if(p->getGlobalId()==getGlobalId()) continue; // skip yourself
+//         
+// 
+//     }
+
+    return true;
+}
+
+bool
-Plug::inquireConnnection( Plug& plug )
-{
@@ -148 +568 @@
-}
-
+int
+Plug::getSignalSource()
+{
+    if((getPlugAddressType() == eAPA_PCR) ||
+       (getPlugAddressType() == eAPA_ExternalPlug)) {
+        if (getPlugDirection() != eAPD_Output) {
+            debugWarning("Signal Source command not valid for non-output unit plugs...\n");
+            return -1;
+        }
+    }
+    
+    if(getPlugAddressType() == eAPA_SubunitPlug) {
+        if (getPlugDirection() != eAPD_Input) {
+            debugWarning("Signal Source command not valid for non-input subunit plugs...\n");
+            return -1;
+        }
+    }
+    
+    SignalSourceCmd signalSourceCmd( m_unit->get1394Service() );
+    
+    signalSourceCmd.setNodeId( m_unit->getConfigRom().getNodeId() );
+    signalSourceCmd.setSubunitType( eST_Unit  );
+    signalSourceCmd.setSubunitId( 0xff );
+
+    SignalSubunitAddress signalSubunitAddr;
+    signalSubunitAddr.m_subunitType = 0xFF;
+    signalSubunitAddr.m_subunitId = 0xFF;
+    signalSubunitAddr.m_plugId = 0xFE;
+    signalSourceCmd.setSignalSource( signalSubunitAddr );
+    
+    setDestPlugAddrToSignalCmd( signalSourceCmd, *this );
+
+    signalSourceCmd.setCommandType( AVCCommand::eCT_Status );
+    signalSourceCmd.setVerbose( getDebugLevel() );
+    signalSourceCmd.setVerbose( DEBUG_LEVEL_VERY_VERBOSE );
+
+    if ( !signalSourceCmd.fire() ) {
+        debugError( "Could not get signal source for '%s'\n",
+                    getName() );
+        return -1;
+    }
+
+    if ( signalSourceCmd.getResponse() == AVCCommand::eR_Implemented ) {
+        SignalAddress* src=signalSourceCmd.getSignalSource();
+        Plug* p=NULL;
+        if(dynamic_cast<SignalUnitAddress *>(src)) {
+            SignalUnitAddress *usrc=dynamic_cast<SignalUnitAddress *>(src);
+            if (usrc->m_plugId & 0x80) {
+                p=m_unit->getPlugManager().getPlug( eST_Unit, 0xFF, 
+                        0xFF, 0xFF, eAPA_ExternalPlug, eAPD_Input, 
+                        usrc->m_plugId & 0x7F );
+            } else {
+                p=m_unit->getPlugManager().getPlug( eST_Unit, 0xFF, 
+                        0xFF, 0xFF, eAPA_PCR, eAPD_Input, 
+                        usrc->m_plugId & 0x7F );
+            }
+        } else if (dynamic_cast<SignalSubunitAddress *>(src)) {
+            SignalSubunitAddress *susrc=dynamic_cast<SignalSubunitAddress *>(src);
+            p=m_unit->getPlugManager().getPlug( byteToSubunitType(susrc->m_subunitType), 
+                    susrc->m_subunitId, 0xFF, 0xFF, eAPA_SubunitPlug, 
+                    eAPD_Output, susrc->m_plugId);
+        } else return -1;
+        
+        if (p==NULL) {
+            debugError("reported signal source plug not found\n");
+            return -1;
+        }
+        
+        return p->getGlobalId();
+    }
+
+    return -1;
+}
+
-bool
-Plug::setConnection( Plug& plug )
@@ -174 +668 @@
-}
-
+bool 
+Plug::propagateFromConnectedPlug( ) {
+
+    if (getDirection() == eAPD_Output) {
+        if (getInputConnections().size()==0) {
+            debugWarning("No input connections to propagate from, skipping.\n");
+            return true;
+        }
+        if (getInputConnections().size()>1) {
+            debugWarning("Too many input connections to propagate from, using first one.\n");
+        }
+        
+        Plug* p = *(getInputConnections().begin());
+        return propagateFromPlug( p );
+        
+    } else if (getDirection() == eAPD_Input) {
+        if (getOutputConnections().size()==0) {
+            debugWarning("No output connections to propagate from, skipping.\n");
+            return true;
+        }
+        if (getOutputConnections().size()>1) {
+            debugWarning("Too many output connections to propagate from, using first one.\n");
+        }
+        
+        Plug* p = *(getOutputConnections().begin());
+        return propagateFromPlug( p );
+        
+    } else {
+        debugWarning("plug with undefined direction\n");
+        return false;
+    }
+}
+
+bool 
+Plug::propagateFromPlug( Plug *p ) {
+    debugOutput( DEBUG_LEVEL_VERBOSE,
+                 "Propagating info from plug '%s' to plug '%s'\n",
+                 p->getName(), getName() );
+    
+    if (m_clusterInfos.size()==0) {
+        m_clusterInfos=p->m_clusterInfos;
+    }
+    
+    m_nrOfChannels=p->m_nrOfChannels;
+    
+    return true;
+}
+
-int
-Plug::getNrOfStreams() const
@@ -194 +736 @@
-}
-
+bool
+Plug::setNrOfChannels(int i)
+{
+    m_nrOfChannels=i;
+    return true;
+}
+
-int
-Plug::getSampleRate() const
-{
+    if(getPlugAddressType()==eAPA_PCR) {
+        if(getPlugDirection()==eAPD_Input) {
+            InputPlugSignalFormatCmd cmd( m_unit->get1394Service() );
+            cmd.m_form=0xFF;
+            cmd.m_eoh=0xFF;
+            cmd.m_fmt=0xFF;
+            cmd.m_plug=getPlugId();
+            
+            cmd.setNodeId( m_unit->getConfigRom().getNodeId() );
+            cmd.setSubunitType( eST_Unit  );
+            cmd.setSubunitId( 0xff );
+            
+            cmd.setCommandType( AVCCommand::eCT_Status );
+
+            if ( !cmd.fire() ) {
+                debugError( "input plug signal format command failed\n" );
+                return 0;
+            }
+            
+            if (cmd.m_fmt != 0x10 ) {
+                debugWarning("Incorrect FMT response received: 0x%02X\n",cmd.m_fmt);
+            }
+            
+            return fdfSfcToSampleRate(cmd.m_fdf[0]);
+            
+        } else if (getPlugDirection()==eAPD_Output) {
+            OutputPlugSignalFormatCmd cmd( m_unit->get1394Service() );
+            cmd.m_form=0xFF;
+            cmd.m_eoh=0xFF;
+            cmd.m_fmt=0xFF;
+            cmd.m_plug=getPlugId();
+            
+            cmd.setNodeId( m_unit->getConfigRom().getNodeId() );
+            cmd.setSubunitType( eST_Unit  );
+            cmd.setSubunitId( 0xff );
+    
+            cmd.setCommandType( AVCCommand::eCT_Status );
+            
+            if ( !cmd.fire() ) {
+                debugError( "output plug signal format command failed\n" );
+                return 0;
+            }
+            
+            if (cmd.m_fmt != 0x10 ) {
+                debugWarning("Incorrect FMT response received: 0x%02X\n",cmd.m_fmt);
+            }
+            
+            return fdfSfcToSampleRate(cmd.m_fdf[0]);
+        
+        } else {
+            debugError("PCR plug with undefined direction.\n");
+            return 0;
+        }
+    }
+    
+    // fallback
-    return convertESamplingFrequency( static_cast<ESamplingFrequency>( m_samplingFrequency ) );
+}
+
+bool
+Plug::setSampleRate( int rate )
+{
+    // apple style
+    if(getPlugAddressType()==eAPA_PCR) {
+        if(getPlugDirection()==eAPD_Input) {
+            InputPlugSignalFormatCmd cmd( m_unit->get1394Service() );
+            cmd.m_eoh=1;
+            cmd.m_form=0;
+            cmd.m_fmt=0x10;
+            cmd.m_plug=getPlugId();
+            cmd.m_fdf[0]=sampleRateToFdfSfc(rate);
+            cmd.m_fdf[1]=0xFF;
+            cmd.m_fdf[2]=0xFF;
+
+            cmd.setNodeId( m_unit->getConfigRom().getNodeId() );
+            cmd.setSubunitType( eST_Unit  );
+            cmd.setSubunitId( 0xff );
+            
+            cmd.setCommandType( AVCCommand::eCT_Control );
+
+            if ( !cmd.fire() ) {
+                debugError( "input plug signal format command failed\n" );
+                return false;
+            }
+
+            if ( cmd.getResponse() == AVCCommand::eR_Accepted )
+            {
+                return true;
+            }
+            debugWarning( "output plug signal format command not accepted\n" );
+
+        } else if (getPlugDirection()==eAPD_Output) {
+            OutputPlugSignalFormatCmd cmd( m_unit->get1394Service() );
+            cmd.m_eoh=1;
+            cmd.m_form=0;
+            cmd.m_fmt=0x10;
+            cmd.m_plug=getPlugId();
+            cmd.m_fdf[0]=sampleRateToFdfSfc(rate);
+            cmd.m_fdf[1]=0xFF;
+            cmd.m_fdf[2]=0xFF;
+            
+            cmd.setNodeId( m_unit->getConfigRom().getNodeId() );
+            cmd.setSubunitType( eST_Unit  );
+            cmd.setSubunitId( 0xff );
+    
+            cmd.setCommandType( AVCCommand::eCT_Control );
+            
+            if ( !cmd.fire() ) {
+                debugError( "output plug signal format command failed\n" );
+                return false;
+            }
+
+            if ( cmd.getResponse() == AVCCommand::eR_Accepted )
+            {
+                return true;
+            }
+            debugWarning( "output plug signal format command not accepted\n" );
+        } else {
+            debugError("PCR plug with undefined direction.\n");
+            return false;
+        }
+    }
+
+    // fallback: BeBoB style
+    ESamplingFrequency samplingFrequency = parseSampleRate(rate);
+    
+    ExtendedStreamFormatCmd extStreamFormatCmd(
+        m_unit->get1394Service(),
+        ExtendedStreamFormatCmd::eSF_ExtendedStreamFormatInformationCommandList );
+    UnitPlugAddress unitPlugAddress( UnitPlugAddress::ePT_PCR,
+                                     getPlugId() );
+
+    extStreamFormatCmd.setPlugAddress(
+        PlugAddress(
+            Plug::convertPlugDirection(getPlugDirection() ),
+            PlugAddress::ePAM_Unit,
+            unitPlugAddress ) );
+
+    extStreamFormatCmd.setNodeId( m_unit->getConfigRom().getNodeId() );
+    extStreamFormatCmd.setCommandType( AVCCommand::eCT_Status );
+
+    int i = 0;
+    bool cmdSuccess = false;
+    bool correctFormatFound = false;
+
+    do {
+        extStreamFormatCmd.setIndexInStreamFormat( i );
+        extStreamFormatCmd.setCommandType( AVCCommand::eCT_Status );
+        extStreamFormatCmd.setVerbose( getDebugLevel() );
+
+        cmdSuccess = extStreamFormatCmd.fire();
+
+        if ( cmdSuccess
+             && ( extStreamFormatCmd.getResponse() ==
+                  AVCCommand::eR_Implemented ) )
+        {
+            ESamplingFrequency foundFreq = eSF_DontCare;
+
+            FormatInformation* formatInfo =
+                extStreamFormatCmd.getFormatInformation();
+            FormatInformationStreamsCompound* compoundStream
+                = dynamic_cast< FormatInformationStreamsCompound* > (
+                    formatInfo->m_streams );
+            if ( compoundStream ) {
+                foundFreq =
+                    static_cast< ESamplingFrequency >(
+                        compoundStream->m_samplingFrequency );
+            }
+
+            FormatInformationStreamsSync* syncStream
+                = dynamic_cast< FormatInformationStreamsSync* > (
+                    formatInfo->m_streams );
+            if ( syncStream ) {
+                foundFreq =
+                    static_cast< ESamplingFrequency >(
+                        syncStream->m_samplingFrequency );
+            }
+
+            if ( foundFreq == samplingFrequency )
+            {
+                correctFormatFound = true;
+                break;
+            }
+        }
+
+        ++i;
+    } while ( cmdSuccess
+              && ( extStreamFormatCmd.getResponse() ==
+                   ExtendedStreamFormatCmd::eR_Implemented ) );
+
+    if ( !cmdSuccess ) {
+        debugError( "setSampleRatePlug: Failed to retrieve format info\n" );
+        return false;
+    }
+
+    if ( !correctFormatFound ) {
+        debugError( "setSampleRatePlug: %s plug %d does not support "
+                    "sample rate %d\n",
+                    getName(),
+                    getPlugId(),
+                    convertESamplingFrequency( samplingFrequency ) );
+        return false;
+    }
+
+    extStreamFormatCmd.setSubFunction(
+        ExtendedStreamFormatCmd::eSF_ExtendedStreamFormatInformationCommand );
+    extStreamFormatCmd.setCommandType( AVCCommand::eCT_Control );
+    extStreamFormatCmd.setVerbose( getDebugLevel() );
+
+    if ( !extStreamFormatCmd.fire() ) {
+        debugError( "setSampleRate: Could not set sample rate %d "
+                    "to %s plug %d\n",
+                    convertESamplingFrequency( samplingFrequency ),
+                    getName(),
+                    getPlugId() );
+        return false;
+    }
+
+    return true;
-}
-
@@ -434 +1201 @@
-    }
-    return dir;
+}
+
+std::string
+Plug::plugAddressTypeToString(enum EPlugAddressType t) {
+    switch (t) {
+        case eAPA_PCR:
+            return string("PCR");
+        case eAPA_ExternalPlug:
+            return string("External");
+        case eAPA_AsynchronousPlug:
+            return string("Async");
+        case eAPA_SubunitPlug:
+            return string("Subunit");
+        case eAPA_FunctionBlockPlug:
+            return string("Function Block");
+        default:
+        case eAPA_Undefined:
+            return string("Undefined");
+    }
+}
+
+std::string
+Plug::plugTypeToString(enum EPlugType t) {
+    switch (t) {
+        case eAPT_IsoStream:
+            return string("IsoStream");
+        case eAPT_AsyncStream:
+            return string("AsyncStream");
+        case eAPT_Midi:
+            return string("MIDI");
+        case eAPT_Sync:
+            return string("Sync");
+        case eAPT_Analog:
+            return string("Analog");
+        case eAPT_Digital:
+            return string("Digital");
+        default:
+        case eAPT_Unknown:
+            return string("Unknown");
+    }
+}
+
+std::string
+Plug::plugDirectionToString(enum EPlugDirection t) {
+    switch (t) {
+        case eAPD_Input:
+            return string("Input");
+        case eAPD_Output:
+            return string("Output");
+        default:
+        case eAPT_Unknown:
+            return string("Unknown");
+    }
-}
-
@@ -459 +1279 @@
-    debugOutput( DEBUG_LEVEL_VERBOSE, "\tNumber of Streams  = %d\n",
-                 getNrOfStreams() );
+    debugOutput( DEBUG_LEVEL_VERBOSE, "\tIncoming connections from: ");
+    
+    for ( PlugVector::const_iterator it = m_inputConnections.begin();
+          it != m_inputConnections.end();
+          ++it )
+    {
+        debugOutputShort(DEBUG_LEVEL_VERBOSE, "%s, ", (*it)->getName());
+    }
+    debugOutputShort(DEBUG_LEVEL_VERBOSE, "\n");
+
+    debugOutput( DEBUG_LEVEL_VERBOSE, "\tOutgoing connections to: ");
+    for ( PlugVector::const_iterator it = m_outputConnections.begin();
+          it != m_outputConnections.end();
+          ++it )
+    {
+        debugOutputShort(DEBUG_LEVEL_VERBOSE, "%s, ", (*it)->getName());
+    }
+    debugOutputShort(DEBUG_LEVEL_VERBOSE, "\n");
+
-    flushDebugOutput();
-}
@@ -1040 +1879 @@
-
-// helper function
-Owner
+
-                           Plug& srcPlug,
-                           Plug& destPlug )
-{
+    for ( PlugConnectionVector::iterator it = connections.begin();
+          it != connections.end();
+          ++it )
+    {
+        PlugConnection* con = *it;
+        if ( ( &( con->getSrcPlug() ) == &srcPlug )
+             && ( &( con->getDestPlug() ) == &destPlug ) )
+        {
+            return;
+        }
+    }
+    connections.push_back( new PlugConnection( srcPlug, destPlug ) );
+}
+
+bool
+PlugManager::tidyPlugConnections(PlugConnectionVector& connections)
+{
+    for ( PlugVector::const_iterator it = m_plugs.begin();
+          it !=  m_plugs.end();
+          ++it )
+    {
+        Plug* plug = *it;
+        for ( PlugVector::const_iterator it =
+                  plug->getInputConnections().begin();
+            it != plug->getInputConnections().end();
+            ++it )
+        {
+            addConnection( connections, *( *it ), *plug );
+        }
+        plug->getInputConnections().clear();
+        
+        for ( PlugVector::const_iterator it =
+                  plug->getOutputConnections().begin();
+            it != plug->getOutputConnections().end();
+            ++it )
+        {
+            addConnection( connections, *plug, *( *it ) );
+        }
+        plug->getOutputConnections().clear();
+    }
+    
+    for ( PlugConnectionVector::iterator it = connections.begin();
+          it != connections.end();
+          ++it )
+    {
+        PlugConnection * con = *it;
+        con->getSrcPlug().getOutputConnections().push_back(&( con->getDestPlug() ));
+        con->getDestPlug().getInputConnections().push_back(&( con->getSrcPlug() ));
+
+    }
+    
+    return true;
+}
+
+static void addConnectionOwner( PlugConnectionOwnerVector& connections,
+                           Plug& srcPlug,
+                           Plug& destPlug )
+{
+
-    for ( PlugConnectionOwnerVector::iterator it = connections.begin();
-          it != connections.end();
@@ -1057 +1955 @@
-    connections.push_back( PlugConnection( srcPlug, destPlug ) );
-}
+
-
-void
@@ -1104 +2003 @@
-            ++it )
-        {
-
+Owner
-        }
-        for ( PlugVector::const_iterator it =
@@ -1111 +2010 @@
-            ++it )
-        {
-
+Owner
-        }
-    }
@@ -1409 +2308 @@
-}
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

branches/echoaudio/src/libavc/general/avc_plug.h

@@ -47 +47 @@
-class Subunit;
-class PlugManager;
+
-class Plug;
-
-typedef std::vector<Plug*> PlugVector;
+
+class PlugConnection;
+typedef std::vector<PlugConnection*> PlugConnectionVector;
+
-
-class Plug {
@@ -62 +66 @@
-        eAPA_Undefined,
-    };
+    std::string plugAddressTypeToString(enum EPlugAddressType t);
-
-    enum EPlugType {
@@ -72 +77 @@
-        eAPT_Unknown,
-    };
+    std::string plugTypeToString(enum EPlugType t);
-
-    enum EPlugDirection {
@@ -78 +84 @@
-        eAPD_Unknown,
-    };
+    std::string plugDirectionToString(enum EPlugDirection t);
-
-    // \todo This constructors sucks. too many parameters. fix it.
@@ -90 +97 @@
-    virtual ~Plug();
-
-    virtual bool discover() 
-    {//FIXME:
-        #warning FIXME i want to be pure!!
-        return true;
-    };
-
-    bool inquireConnnection( Plug& plug );
-    bool setConnection( Plug& plug );
+
+    int getSignalSource();
-
-    int getGlobalId() const
@@ -108 +111 @@
-    const char* getName() const
-        { return m_name.c_str(); }
+    bool setName(const char *n)
+        { m_name=n; return true;};
+    bool setName(std::string n)
+        { m_name=n; return true;};
-    EPlugDirection getPlugDirection() const
-        { return m_direction; }
+    bool setPlugDirection(EPlugDirection d)
+        { m_direction=d; return true; }
-    sampling_frequency_t getSamplingFrequency() const
-        { return m_samplingFrequency; }
-    int getSampleRate() const; // 22050, 24000, 32000, ...
+    bool setSampleRate( int rate );
+    
-    int getNrOfChannels() const;
+    bool setNrOfChannels(int i);
-    int getNrOfStreams() const;
-
+    // FIXME: this is the same as getPlugDirection
-    EPlugDirection getDirection() const
-        { return m_direction; }
@@ -122 +135 @@
-    EPlugType getPlugType() const
-        { return m_infoPlugType; }
+    bool setPlugType(EPlugType t)
+        { m_infoPlugType=t; return true; }
-
-    function_block_type_t getFunctionBlockType() const
@@ -128 +143 @@
-        { return m_functionBlockId; }
-
-
+
+
+
+
+
-        { return m_inputConnections; }
-const PlugVector& getOutputConnections() const
+PlugVector& getOutputConnections()
-        { return m_outputConnections; }
-
@@ -171 +190 @@
-    virtual void setVerboseLevel( int i ) 
-            {setDebugLevel(i);};
+    
+// the discovery interface
+// everything can be overloaded, or
+// can be left as is
+public:
+    virtual bool discover();
+    virtual bool discoverConnections();
+    virtual bool propagateFromConnectedPlug( );
+    
+protected:
+    virtual bool discoverPlugType();
+    virtual bool discoverName();
+    virtual bool discoverNoOfChannels();
+    virtual bool discoverChannelPosition();
+    virtual bool discoverChannelName();
+    virtual bool discoverClusterInfo();
+    virtual bool discoverStreamFormat();
+    virtual bool discoverSupportedStreamFormats();
+    virtual bool discoverConnectionsInput();
+    virtual bool discoverConnectionsOutput();
+    virtual bool initFromDescriptor();
+
+    bool propagateFromPlug( Plug *p );
+
+    ExtendedPlugInfoCmd setPlugAddrToPlugInfoCmd();
+
+    ExtendedStreamFormatCmd setPlugAddrToStreamFormatCmd(
+            ExtendedStreamFormatCmd::ESubFunction subFunction);
+
-protected:
-    Plug();
@@ -280 +328 @@
-    void showPlugs() const;
-
+    int getPlugCount() 
+        { return m_plugs.size(); };
+
-    Plug* getPlug( ESubunitType subunitType,
-                   subunit_id_t subunitId,
@@ -302 +353 @@
-    void setVerboseLevel( int i ) 
-            {setDebugLevel(i);};
+    PlugVector& getPlugs() {return m_plugs;};
+    bool tidyPlugConnections(PlugConnectionVector&);
+
-private:
-
@@ -330 +384 @@
-};
-
-typedef std::vector<PlugConnection*> PlugConnectionVector;
-typedef std::vector<PlugConnection> PlugConnectionOwnerVector;
-

branches/echoaudio/src/libavc/general/avc_subunit.cpp

@@ -66 +66 @@
-}
-
+Plug *
+Subunit::createPlug( AVC::Unit* unit,
+                     AVC::Subunit* subunit,
+                     AVC::function_block_type_t functionBlockType,
+                     AVC::function_block_type_t functionBlockId,
+                     AVC::Plug::EPlugAddressType plugAddressType,
+                     AVC::Plug::EPlugDirection plugDirection,
+                     AVC::plug_id_t plugId )
+{
+
+    return new Plug( unit,
+                     subunit,
+                     functionBlockType,
+                     functionBlockId,
+                     plugAddressType,
+                     plugDirection,
+                     plugId );
+}
+
-bool
-Subunit::discover()
-{
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    return true;
-}
@@ -98 +212 @@
-    }
-    return 0;
+}
+
+bool
+Subunit::initPlugFromDescriptor( Plug& plug )
+{
+    debugError("plug loading from descriptor not implemented\n");
+    return false;
-}
-

branches/echoaudio/src/libavc/general/avc_subunit.h

@@ -51 +51 @@
-
-    virtual bool discover();
+    virtual bool discoverConnections();
-    virtual const char* getName() = 0;
-
@@ -60 +61 @@
-    Unit& getUnit() const
-        { return *m_unit; }
+    Subunit& getSubunit()
+        { return *this; }
-
+    virtual Plug *createPlug( AVC::Unit* unit,
+                              AVC::Subunit* subunit,
+                              AVC::function_block_type_t functionBlockType,
+                              AVC::function_block_type_t functionBlockId,
+                              AVC::Plug::EPlugAddressType plugAddressType,
+                              AVC::Plug::EPlugDirection plugDirection,
+                              AVC::plug_id_t plugId );
-
-    bool addPlug( Plug& plug );
+    virtual bool initPlugFromDescriptor( Plug& plug );
-
-    PlugVector& getPlugs()
@@ -68 +79 @@
-    Plug* getPlug(Plug::EPlugDirection direction, plug_id_t plugId);
-
+    virtual void setVerboseLevel(int l) 
+        { setDebugLevel(l);};
-
-    bool serialize( Glib::ustring basePath, Util::IOSerialize& ser ) const;
-    static Subunit* deserialize( Glib::ustring basePath,
-
-
+
- protected:
-    Subunit();
@@ -81 +93 @@
-                                   Util::IODeserialize& deser,
-                                   Unit& avDevice ) = 0;
+    bool discoverPlugs();
+    bool discoverPlugs(Plug::EPlugDirection plugDirection,
+                       AVC::plug_id_t plugMaxId );
-
- protected:

branches/echoaudio/src/libavc/general/avc_unit.cpp

@@ -50 +50 @@
-    , m_activeSyncInfo( 0 )
-{
-
+
+
-}
-
@@ -81 +82 @@
-}
-
+Plug *
+Unit::createPlug( Unit* unit,
+                     Subunit* subunit,
+                     function_block_type_t functionBlockType,
+                     function_block_type_t functionBlockId,
+                     Plug::EPlugAddressType plugAddressType,
+                     Plug::EPlugDirection plugDirection,
+                     plug_id_t plugId )
+{
+
+    return new Plug( unit,
+                     subunit,
+                     functionBlockType,
+                     functionBlockId,
+                     plugAddressType,
+                     plugDirection,
+                     plugId );
+}
+
+Subunit* 
+Unit::createSubunit(Unit& unit,
+                    ESubunitType type,
+                    subunit_t id ) 
+{
+    switch (type) {
+        case eST_Audio:
+            return new SubunitAudio(unit, id );
+        case eST_Music:
+            return new SubunitMusic(unit, id );
+        default:
+            return NULL;
+    }
+}
+
-void
-Unit::setVerboseLevel(int l)
@@ -93 +128 @@
-    if ( !enumerateSubUnits() ) {
-        debugError( "Could not enumarate sub units\n" );
+        return false;
+    }
+
+    if ( !discoverPlugs() ) {
+        debugError( "Detecting plugs failed\n" );
+        return false;
+    }
+
+    if ( !discoverPlugConnections() ) {
+        debugError( "Detecting plug connections failed\n" );
+        return false;
+    }
+
+    if ( !discoverSubUnitsPlugConnections() ) {
+        debugError( "Detecting subunit plug connnections failed\n" );
+        return false;
+    }
+
+    if ( !m_pPlugManager->tidyPlugConnections(m_plugConnections) ) {
+        debugError( "Tidying of plug connnections failed\n" );
+        return false;
+    }
+
+    if ( !discoverSyncModes() ) {
+        debugError( "Detecting sync modes failed\n" );
+        return false;
+    }
+
+    if ( !propagateClusterInfos() ) {
+        debugError( "Failed to propagate cluster info's\n" );
-        return false;
-    }
@@ -135 +200 @@
-        switch( subunit_type ) {
-        case eST_Audio:
-
-
+
-            if ( !subunit ) {
-                debugFatal( "Could not allocate SubunitAudio\n" );
-                return false;
-            }
+            
+            subunit->setVerboseLevel(getDebugLevel());
-            
-            if ( !subunit->discover() ) {
@@ -156 +222 @@
-            break;
-        case eST_Music:
-
-
+
-            if ( !subunit ) {
-                debugFatal( "Could not allocate SubunitMusic\n" );
-                return false;
-            }
+            
+            subunit->setVerboseLevel(getDebugLevel());
+            
-            if ( !subunit->discover() ) {
-                debugError( "enumerateSubUnits: Could not discover "
@@ -225 +293 @@
-}
-
+bool
+Unit::discoverPlugs()
+{
+    debugOutput( DEBUG_LEVEL_NORMAL, "Discovering plugs...\n");
+
+    //////////////////////////////////////////////
+    // Get number of available isochronous input
+    // and output plugs of unit
+
+    PlugInfoCmd plugInfoCmd( get1394Service() );
+    plugInfoCmd.setNodeId( getConfigRom().getNodeId() );
+    plugInfoCmd.setCommandType( AVCCommand::eCT_Status );
+    plugInfoCmd.setVerbose( getDebugLevel() );
+
+    if ( !plugInfoCmd.fire() ) {
+        debugError( "plug info command failed\n" );
+        return false;
+    }
+
+    debugOutput( DEBUG_LEVEL_NORMAL, "number of iso input plugs = %d\n",
+                 plugInfoCmd.m_serialBusIsochronousInputPlugs );
+    debugOutput( DEBUG_LEVEL_NORMAL, "number of iso output plugs = %d\n",
+                 plugInfoCmd.m_serialBusIsochronousOutputPlugs );
+    debugOutput( DEBUG_LEVEL_NORMAL, "number of external input plugs = %d\n",
+                 plugInfoCmd.m_externalInputPlugs );
+    debugOutput( DEBUG_LEVEL_NORMAL, "number of external output plugs = %d\n",
+                 plugInfoCmd.m_externalOutputPlugs );
+
+    if ( !discoverPlugsPCR( Plug::eAPD_Input,
+                            plugInfoCmd.m_serialBusIsochronousInputPlugs ) )
+    {
+        debugError( "pcr input plug discovering failed\n" );
+        return false;
+    }
+
+    if ( !discoverPlugsPCR( Plug::eAPD_Output,
+                            plugInfoCmd.m_serialBusIsochronousOutputPlugs ) )
+    {
+        debugError( "pcr output plug discovering failed\n" );
+        return false;
+    }
+
+    if ( !discoverPlugsExternal( Plug::eAPD_Input,
+                                 plugInfoCmd.m_externalInputPlugs ) )
+    {
+        debugError( "external input plug discovering failed\n" );
+        return false;
+    }
+
+    if ( !discoverPlugsExternal( Plug::eAPD_Output,
+                                 plugInfoCmd.m_externalOutputPlugs ) )
+    {
+        debugError( "external output plug discovering failed\n" );
+        return false;
+    }
+
+    return true;
+}
+
+bool
+Unit::discoverPlugsPCR( Plug::EPlugDirection plugDirection,
+                            plug_id_t plugMaxId )
+{
+    debugOutput( DEBUG_LEVEL_NORMAL, "Discovering PCR plugs, direction %d...\n",plugDirection);
+    for ( int plugId = 0;
+          plugId < plugMaxId;
+          ++plugId )
+    {
+        Plug* plug  = createPlug( this,
+                                NULL,
+                                0xff,
+                                0xff,
+                                Plug::eAPA_PCR,
+                                plugDirection,
+                                plugId );
+        if ( !plug || !plug->discover() ) {
+            debugError( "plug discovering failed\n" );
+            delete plug;
+            return false;
+        }
+
+        debugOutput( DEBUG_LEVEL_NORMAL, "plug '%s' found\n",
+                     plug->getName() );
+        m_pcrPlugs.push_back( plug );
+    }
+
+    return true;
+}
+
+bool
+Unit::discoverPlugsExternal( Plug::EPlugDirection plugDirection,
+                                 plug_id_t plugMaxId )
+{
+    debugOutput( DEBUG_LEVEL_NORMAL, "Discovering External plugs, direction %d...\n",plugDirection);
+    for ( int plugId = 0;
+          plugId < plugMaxId;
+          ++plugId )
+    {
+        Plug* plug  = createPlug( this, NULL,
+                                0xff,
+                                0xff,
+                                Plug::eAPA_ExternalPlug,
+                                plugDirection,
+                                plugId );
+        if ( !plug || !plug->discover() ) {
+            debugError( "plug discovering failed\n" );
+            return false;
+        }
+
+        debugOutput( DEBUG_LEVEL_NORMAL, "plug '%s' found\n",
+                     plug->getName() );
+        m_externalPlugs.push_back( plug );
+    }
+
+    return true;
+}
+
+bool
+Unit::discoverPlugConnections()
+{
+    debugOutput( DEBUG_LEVEL_NORMAL, "Discovering PCR plug connections...\n");
+    for ( PlugVector::iterator it = m_pcrPlugs.begin();
+          it != m_pcrPlugs.end();
+          ++it )
+    {
+        Plug* plug = *it;
+        if ( !plug->discoverConnections() ) {
+            debugError( "Could not discover PCR plug connections\n" );
+            return false;
+        }
+    }
+    debugOutput( DEBUG_LEVEL_NORMAL, "Discovering External plug connections...\n");
+    for ( PlugVector::iterator it = m_externalPlugs.begin();
+          it != m_externalPlugs.end();
+          ++it )
+    {
+        Plug* plug = *it;
+        if ( !plug->discoverConnections() ) {
+            debugError( "Could not discover External plug connections\n" );
+            return false;
+        }
+    }
+
+    return true;
+}
+
+bool
+Unit::discoverSubUnitsPlugConnections()
+{
+    for ( SubunitVector::iterator it = m_subunits.begin();
+          it != m_subunits.end();
+          ++it )
+    {
+        Subunit* subunit = *it;
+
+        if ( !subunit->discoverConnections() ) {
+            debugError( "Subunit '%s'  plug connections failed\n",
+                        subunit->getName() );
+            return false;
+        }
+    }
+    return true;
+}
+
+bool
+Unit::propagateClusterInfos()
+{
+    debugOutput( DEBUG_LEVEL_NORMAL, "Propagating info to PCR plugs...\n");
+    for ( PlugVector::iterator it = m_pcrPlugs.begin();
+          it != m_pcrPlugs.end();
+          ++it )
+    {
+        Plug* plug = *it;
+        debugOutput( DEBUG_LEVEL_NORMAL, "plug: %s\n", plug->getName());
+        if (!plug->propagateFromConnectedPlug()) {
+            debugWarning( "Could not propagate info for plug '%s'\n", plug->getName());
+        }
+    }
+    debugOutput( DEBUG_LEVEL_NORMAL, "Propagating info to External plugs...\n");
+    for ( PlugVector::iterator it = m_externalPlugs.begin();
+          it != m_externalPlugs.end();
+          ++it )
+    {
+        Plug* plug = *it;
+        debugOutput( DEBUG_LEVEL_NORMAL, "plug: %s\n", plug->getName());
+        if (!plug->propagateFromConnectedPlug()) {
+            debugWarning( "Could not propagate info for plug '%s'\n", plug->getName());
+        }
+    }
+
+    return true;
+
+}
+
+
-PlugConnection*
-Unit::getPlugConnection( Plug& srcPlug ) const
@@ -288 +551 @@
-    return 0;
-}
+
+bool
+Unit::discoverSyncModes()
+{
+    // Following possible sync plugs exists:
+    // - Music subunit sync output plug = internal sync (CSP)
+    // - Unit input plug 0 = SYT match
+    // - Unit input plut 1 = Sync stream
+    //
+    // If last sync mode is reported it is mostelikely not
+    // implemented *sic*
+    //
+    // Following sync sources are device specific:
+    // - All unit external input plugs which have a
+    //   sync information (WS, SPDIF, ...)
+
+    // First we have to find the sync input and output plug
+    // in the music subunit.
+
+    // Note PCR input means 1394bus-to-device where as
+    // MSU input means subunit-to-device
+
+    PlugVector syncPCRInputPlugs = getPlugsByType( m_pcrPlugs,
+                                                     Plug::eAPD_Input,
+                                                     Plug::eAPT_Sync );
+    if ( !syncPCRInputPlugs.size() ) {
+        debugWarning( "No PCR sync input plug found\n" );
+    }
+
+    PlugVector syncPCROutputPlugs = getPlugsByType( m_pcrPlugs,
+                                                      Plug::eAPD_Output,
+                                                      Plug::eAPT_Sync );
+    if ( !syncPCROutputPlugs.size() ) {
+        debugWarning( "No PCR sync output plug found\n" );
+    }
+
+    PlugVector isoPCRInputPlugs = getPlugsByType( m_pcrPlugs,
+                                                    Plug::eAPD_Input,
+                                                    Plug::eAPT_IsoStream );
+    if ( !isoPCRInputPlugs.size() ) {
+        debugWarning( "No PCR iso input plug found\n" );
+
+    }
+
+    PlugVector isoPCROutputPlugs = getPlugsByType( m_pcrPlugs,
+                                                    Plug::eAPD_Output,
+                                                    Plug::eAPT_IsoStream );
+    if ( !isoPCROutputPlugs.size() ) {
+        debugWarning( "No PCR iso output plug found\n" );
+
+    }
+
+    PlugVector digitalPCRInputPlugs = getPlugsByType( m_externalPlugs,
+                                                    Plug::eAPD_Input,
+                                                    Plug::eAPT_Digital );
+
+    PlugVector syncMSUInputPlugs = m_pPlugManager->getPlugsByType(
+        eST_Music,
+        0,
+        0xff,
+        0xff,
+        Plug::eAPA_SubunitPlug,
+        Plug::eAPD_Input,
+        Plug::eAPT_Sync );
+    if ( !syncMSUInputPlugs.size() ) {
+        debugWarning( "No sync input plug for MSU subunit found\n" );
+    }
+
+    PlugVector syncMSUOutputPlugs = m_pPlugManager->getPlugsByType(
+        eST_Music,
+        0,
+        0xff,
+        0xff,
+        Plug::eAPA_SubunitPlug,
+        Plug::eAPD_Output,
+        Plug::eAPT_Sync );
+    if ( !syncMSUOutputPlugs.size() ) {
+        debugWarning( "No sync output plug for MSU subunit found\n" );
+    }
+
+    debugOutput( DEBUG_LEVEL_VERBOSE, "PCR Sync Input Plugs:\n" );
+    showPlugs( syncPCRInputPlugs );
+    debugOutput( DEBUG_LEVEL_VERBOSE, "PCR Sync Output Plugs:\n" );
+    showPlugs( syncPCROutputPlugs );
+    debugOutput( DEBUG_LEVEL_VERBOSE, "PCR Iso Input Plugs:\n" );
+    showPlugs( isoPCRInputPlugs );
+    debugOutput( DEBUG_LEVEL_VERBOSE, "PCR Iso Output Plugs:\n" );
+    showPlugs( isoPCROutputPlugs );
+    debugOutput( DEBUG_LEVEL_VERBOSE, "PCR digital Input Plugs:\n" );
+    showPlugs( digitalPCRInputPlugs );
+    debugOutput( DEBUG_LEVEL_VERBOSE, "MSU Sync Input Plugs:\n" );
+    showPlugs( syncMSUInputPlugs );
+    debugOutput( DEBUG_LEVEL_VERBOSE, "MSU Sync Output Plugs:\n" );
+    showPlugs( syncMSUOutputPlugs );
+
+    // Check all possible PCR input to MSU input connections
+    // -> sync stream input
+    checkSyncConnectionsAndAddToList( syncPCRInputPlugs,
+                                      syncMSUInputPlugs,
+                                      "Sync Stream Input" );
+
+    // Check all possible MSU output to PCR output connections
+    // -> sync stream output
+    checkSyncConnectionsAndAddToList( syncMSUOutputPlugs,
+                                      syncPCROutputPlugs,
+                                      "Sync Stream Output" );
+
+    // Check all PCR iso input to MSU input connections
+    // -> SYT match
+    checkSyncConnectionsAndAddToList( isoPCRInputPlugs,
+                                      syncMSUInputPlugs,
+                                      "Syt Match" );
+
+    // Check all MSU sync output to MSU input connections
+    // -> CSP
+    checkSyncConnectionsAndAddToList( syncMSUOutputPlugs,
+                                      syncMSUInputPlugs,
+                                      "Internal (CSP)" );
+
+    // Check all external PCR digital input to MSU input connections
+    // -> SPDIF/ADAT sync
+    checkSyncConnectionsAndAddToList( digitalPCRInputPlugs,
+                                      syncMSUInputPlugs,
+                                      "Digital Input Sync" );
+
+    // Currently active connection signal source cmd, command type
+    // status, source unknown, destination MSU sync input plug
+
+    for ( PlugVector::const_iterator it = syncMSUInputPlugs.begin();
+          it != syncMSUInputPlugs.end();
+          ++it )
+    {
+        AVC::Plug* msuPlug = *it;
+        for ( PlugVector::const_iterator jt =
+                  msuPlug->getInputConnections().begin();
+              jt != msuPlug->getInputConnections().end();
+              ++jt )
+        {
+            AVC::Plug* plug = *jt;
+
+            for ( SyncInfoVector::iterator it = m_syncInfos.begin();
+                  it != m_syncInfos.end();
+                  ++it )
+            {
+                SyncInfo* pSyncInfo = &*it;
+                if ( ( pSyncInfo->m_source == plug )
+                     && ( pSyncInfo->m_destination == msuPlug ) )
+                {
+                    m_activeSyncInfo = pSyncInfo;
+                    break;
+                }
+            }
+            debugOutput( DEBUG_LEVEL_NORMAL,
+                         "Active Sync Connection: '%s' -> '%s'\n",
+                         plug->getName(),
+                         msuPlug->getName() );
+        }
+    }
+
+    return true;
+}
+
+bool
+Unit::checkSyncConnectionsAndAddToList( PlugVector& plhs,
+                                            PlugVector& prhs,
+                                            std::string syncDescription )
+{
+    for ( PlugVector::iterator plIt = plhs.begin();
+          plIt != plhs.end();
+          ++plIt )
+    {
+        AVC::Plug* pl = *plIt;
+        for ( PlugVector::iterator prIt = prhs.begin();
+              prIt != prhs.end();
+              ++prIt )
+        {
+            AVC::Plug* pr = *prIt;
+            if ( pl->inquireConnnection( *pr ) ) {
+                m_syncInfos.push_back( SyncInfo( *pl, *pr, syncDescription ) );
+                debugOutput( DEBUG_LEVEL_NORMAL,
+                             "Sync connection '%s' -> '%s'\n",
+                             pl->getName(),
+                             pr->getName() );
+            }
+        }
+    }
+    return true;
+}
+
+bool Unit::setActiveSync(const SyncInfo& syncInfo)
+{
+    return syncInfo.m_source->setConnection( *syncInfo.m_destination );
+}
+
-
-void

branches/echoaudio/src/libavc/general/avc_unit.h

@@ -62 +62 @@
-    
-    /// Discovers the unit's internals
-
+virtual 
-
-    PlugManager& getPlugManager()
@@ -86 +86 @@
-
-    typedef std::vector<SyncInfo> SyncInfoVector;
-
+virtual 
-        { return m_syncInfos; }
-
+virtual 
-        { return m_activeSyncInfo; }
-
+
+
-
-    bool serialize( Glib::ustring basePath, Util::IOSerialize& ser ) const;
@@ -104 +105 @@
-    Subunit* getSubunit( subunit_type_t subunitType,
-                         subunit_id_t subunitId ) const;
+
+    virtual AVC::Subunit* createSubunit(Unit& unit,
+                                        ESubunitType type,
+                                        subunit_t id );
+    virtual AVC::Plug* createPlug( AVC::Unit* unit,
+                                   AVC::Subunit* subunit,
+                                   AVC::function_block_type_t functionBlockType,
+                                   AVC::function_block_type_t functionBlockId,
+                                   AVC::Plug::EPlugAddressType plugAddressType,
+                                   AVC::Plug::EPlugDirection plugDirection,
+                                   AVC::plug_id_t plugId );
+
-protected:
-
-    virtual bool enumerateSubUnits();
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    unsigned int getNrOfSubunits( subunit_type_t subunitType ) const;
-    PlugConnection* getPlugConnection( Plug& srcPlug ) const;
-
-    Plug* getSyncPlug( int maxPlugId, Plug::EPlugDirection );
-
-    Plug* getPlugById( PlugVector& plugs,
@@ -126 +150 @@
-    void showPlugs( PlugVector& plugs ) const;
-
-//     bool checkSyncConnectionsAndAddToList( PlugVector& plhs,
-//                                            PlugVector& prhs,
-//                                            std::string syncDescription );
-
-    static bool serializeSyncInfoVector( Glib::ustring basePath,

branches/echoaudio/src/libavc/musicsubunit/avc_descriptor_music.cpp

@@ -30 +30 @@
-#include "libieee1394/ieee1394service.h"
-
+#include "../general/avc_subunit.h"
+#include "../general/avc_unit.h"
+
-#include <netinet/in.h>
-
@@ -199 +202 @@
-        }
-    }
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-// ---------
@@ -322 +337 @@
-    return result;
-}
+
+std::string 
+AVCMusicSubunitPlugInfoBlock::getName() {
+    if(m_RawTextInfoBlock.m_compound_length>0) {
+        return m_RawTextInfoBlock.m_text;
+    } else if (m_NameInfoBlock.m_compound_length>0) {
+        return m_NameInfoBlock.m_text;
+    } else {
+        return std::string("Unknown");
+    }
+}
+
-
-// ---------
@@ -431 +458 @@
-}
-
+std::string 
+AVCMusicPlugInfoBlock::getName() {
+    if(m_RawTextInfoBlock.m_compound_length>0) {
+        return m_RawTextInfoBlock.m_text;
+    } else if (m_NameInfoBlock.m_compound_length>0) {
+        return m_NameInfoBlock.m_text;
+    } else {
+        return std::string("Unknown");
+    }
+}
+
+
-// ---------
-AVCMusicRoutingStatusInfoBlock::AVCMusicRoutingStatusInfoBlock( )
@@ -568 +607 @@
-}
-
+AVCMusicSubunitPlugInfoBlock *
+AVCMusicRoutingStatusInfoBlock::getSubunitPlugInfoBlock(Plug::EPlugDirection direction, plug_id_t id) {
+    if (direction == Plug::eAPD_Input) {
+        for ( AVCMusicSubunitPlugInfoBlockVectorIterator it = mDestPlugInfoBlocks.begin();
+        it != mDestPlugInfoBlocks.end();
+        ++it )
+        {
+            AVCMusicSubunitPlugInfoBlock *b=(*it);
+            if (b->m_subunit_plug_id == id) return b;
+        }
+        debugOutput(DEBUG_LEVEL_VERBOSE, "no plug info found.\n");
+        return NULL;
+    } else if (direction == Plug::eAPD_Output) {
+        for ( AVCMusicSubunitPlugInfoBlockVectorIterator it = mSourcePlugInfoBlocks.begin();
+        it != mSourcePlugInfoBlocks.end();
+        ++it )
+        {
+            AVCMusicSubunitPlugInfoBlock *b=(*it);
+            if (b->m_subunit_plug_id == id) return b;
+        }
+        debugOutput(DEBUG_LEVEL_VERBOSE, "no plug info found.\n");
+        return NULL;
+    } else {
+        debugOutput(DEBUG_LEVEL_VERBOSE, "Invalid direction.\n");
+        return NULL;
+    }
+}
+
+AVCMusicPlugInfoBlock *
+AVCMusicRoutingStatusInfoBlock::getMusicPlugInfoBlock(plug_id_t id) {
+    for ( AVCMusicPlugInfoBlockVectorIterator it = mMusicPlugInfoBlocks.begin();
+    it != mMusicPlugInfoBlocks.end();
+    ++it )
+    {
+        AVCMusicPlugInfoBlock *b=(*it);
+        if (b->m_music_plug_id == id) return b;
+    }
+    debugOutput(DEBUG_LEVEL_VERBOSE, "no music plug info found.\n");
+    return NULL;
+}
-
-// ----------------------
-Ieee1394Service& ieee1394service, fb_nodeid_t nodeId
-ieee1394service, nodeId, eST_Music, 0x00
+Unit* unit, Subunit* subunit
+unit, subunit
-{}
-
@@ -614 +693 @@
-        
-        switch (block_type) {
- 
+
-                m_general_status_infoblock.setVerbose(getVerboseLevel());
-                result &= m_general_status_infoblock.deserialize(de);
-                break;
- 
+
-                m_output_plug_status_infoblock.setVerbose(getVerboseLevel());
-                result &= m_output_plug_status_infoblock.deserialize(de);
-                break;
-case 0x8108: 
+    case 0x8108:
-                m_routing_status_infoblock.setVerbose(getVerboseLevel());
-                result &= m_routing_status_infoblock.deserialize(de);
@@ -631 +710 @@
-                break;
-        }
-
+
-        if(blocks_done++>max_blocks) {
-            debugError("Too much info blocks in descriptor, probably a runaway parser\n");
@@ -641 +720 @@
-}
-
-
+
+
+
+
+
+
+
+
+
+
+

branches/echoaudio/src/libavc/musicsubunit/avc_descriptor_music.h

@@ -34 +34 @@
-
-#include "../general/avc_generic.h"
+#include "../general/avc_plug.h"
+
-#include "debugmodule/debugmodule.h"
-
-#include <libavc1394/avc1394.h>
+
-#include <vector>
+#include <string>
-
-class Ieee1394Service;
@@ -99 +103 @@
-        byte_t stream_location;
-    };
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
-    AVCMusicClusterInfoBlock( );
-    virtual ~AVCMusicClusterInfoBlock();
@@ -113 +121 @@
-    byte_t      m_port_type;
-    byte_t      m_nb_signals;
-std::vector<struct sSignalInfo>
+SignalInfoVector
-
-    AVCRawTextInfoBlock m_RawTextInfoBlock;
@@ -128 +136 @@
-{
-public:
+    enum AVCMusicSubunitPlugInfoBlockPlugType {
+        ePT_IsoStream   = 0x0,
+        ePT_AsyncStream = 0x1,
+        ePT_Midi        = 0x2,
+        ePT_Sync        = 0x3,
+        ePT_Analog      = 0x4,
+        ePT_Digital     = 0x5,
+
+        ePT_Unknown     = 0xff,
+    };
-
-    virtual bool serialize( IOSSerialize& se );
@@ -138 +156 @@
-        
-    virtual bool clear();
+    
+    std::string getName();
-    
-    byte_t      m_subunit_plug_id;
@@ -169 +189 @@
-    virtual const char* getInfoBlockName() const
-        {return "AVCMusicPlugInfoBlock";};
+
+    std::string getName();
-
-    byte_t      m_music_plug_type;
@@ -207 +229 @@
-        {return "AVCMusicRoutingStatusInfoBlock";};
-
+    AVCMusicSubunitPlugInfoBlock *getSubunitPlugInfoBlock(Plug::EPlugDirection, plug_id_t);
+    AVCMusicPlugInfoBlock *getMusicPlugInfoBlock(plug_id_t);
+    
-    virtual bool clear();
-
@@ -233 +258 @@
-    virtual bool deserialize( IISDeserialize& de );
-    
-Ieee1394Service& ieee1394service, fb_nodeid_t nodeId
+Unit* unit, Subunit* subunit
-    virtual ~AVCMusicStatusDescriptor() {}
-    
-    virtual const char* getDescriptorName() const
-        {return "AVCMusicStatusDescriptor";};
+        
+    AVCMusicSubunitPlugInfoBlock *getSubunitPlugInfoBlock(Plug::EPlugDirection, plug_id_t);
+    AVCMusicPlugInfoBlock *getMusicPlugInfoBlock(plug_id_t);
+    
-private:
-    // the child info blocks

branches/echoaudio/src/libavc/musicsubunit/avc_musicsubunit.cpp

@@ -34 +34 @@
-#include "../util/avc_serialize.h"
-
+#include "avc_musicsubunit.h"
+#include "avc_descriptor_music.h"
+
-#include <sstream>
-
@@ -42 +45 @@
-SubunitMusic::SubunitMusic( Unit& unit, subunit_t id )
-    : Subunit( unit, eST_Music, id )
-
+
+
+
-}
-
-SubunitMusic::SubunitMusic()
-    : Subunit()
+    , m_status_descriptor ( NULL )
-{
-}
@@ -52 +58 @@
-SubunitMusic::~SubunitMusic()
-{
+    if (m_status_descriptor) delete m_status_descriptor;
+}
+
+bool
+SubunitMusic::discover()
+{
+    debugOutput(DEBUG_LEVEL_NORMAL, "Discovering %s...\n", getName());
+    
+    // discover the AV/C generic part
+    if ( !Subunit::discover() ) {
+        return false;
+    }
+    
+    // now we have the subunit plugs
+    
+    return true;
+}
+
+bool
+SubunitMusic::initPlugFromDescriptor( Plug& plug )
+{
+    debugOutput(DEBUG_LEVEL_VERBOSE, "Loading info from descriptor for plug: \n");
+    bool result=true;
+    
+    // load the descriptor (if not already loaded)
+    if (m_status_descriptor != NULL) {
+        result &= m_status_descriptor->load();
+    }
+    
+    AVCMusicSubunitPlugInfoBlock *info;
+    info = m_status_descriptor->getSubunitPlugInfoBlock(plug.getDirection(), plug.getPlugId());
+    
+    if (info == NULL) {
+        debugError("Could not find plug info block\n");
+        return false;
+    }
+    
+    debugOutput(DEBUG_LEVEL_VERBOSE, "Found plug: %s\n",info->getName().c_str());
+    
+    // plug name
+    result &= plug.setName(info->getName());
+    
+    // plug type
+    switch (info->m_plug_type) {
+        case AVCMusicSubunitPlugInfoBlock::ePT_IsoStream:
+            result &= plug.setPlugType(Plug::eAPT_IsoStream);
+            break;
+        case AVCMusicSubunitPlugInfoBlock::ePT_AsyncStream:
+            result &= plug.setPlugType(Plug::eAPT_AsyncStream);
+            break;
+        case AVCMusicSubunitPlugInfoBlock::ePT_Midi:
+            result &= plug.setPlugType(Plug::eAPT_Midi);
+            break;
+        case AVCMusicSubunitPlugInfoBlock::ePT_Sync:
+            result &= plug.setPlugType(Plug::eAPT_Sync);
+            break;
+        case AVCMusicSubunitPlugInfoBlock::ePT_Analog:
+            result &= plug.setPlugType(Plug::eAPT_Analog);
+            break;
+        case AVCMusicSubunitPlugInfoBlock::ePT_Digital:
+            result &= plug.setPlugType(Plug::eAPT_Digital);
+            break;
+    }
+    
+    // number of channels
+    result &= plug.setNrOfChannels(info->m_nb_channels);
+    
+    
+    
+    int idx=1;
+    for ( AVCMusicClusterInfoBlockVectorIterator it = info->m_Clusters.begin();
+      it != info->m_Clusters.end();
+      ++it )
+    {
+        struct Plug::ClusterInfo cinfo;
+        
+        AVCMusicClusterInfoBlock *c=(*it);
+        
+        cinfo.m_index=idx; //FIXME: is this correct?
+        cinfo.m_portType=c->m_port_type;
+        cinfo.m_nrOfChannels=c->m_nb_signals;
+        cinfo.m_streamFormat=c->m_stream_format;
+        cinfo.m_name=c->getName();
+
+        debugOutput(DEBUG_LEVEL_VERBOSE, "Adding cluster idx=%2d type=%02X nbch=%2d fmt=%02X name=%s\n",
+            cinfo.m_index, cinfo.m_portType, cinfo.m_nrOfChannels, cinfo.m_streamFormat, cinfo.m_name.c_str());
+
+        for ( AVCMusicClusterInfoBlock::SignalInfoVectorIterator sig_it 
+              = c->m_SignalInfos.begin();
+            sig_it != c->m_SignalInfos.end();
+            ++sig_it )
+        {
+            struct AVCMusicClusterInfoBlock::sSignalInfo s=(*sig_it);
+            struct Plug::ChannelInfo sinfo;
+            
+            sinfo.m_streamPosition=s.stream_position;
+            sinfo.m_location=s.stream_location;
+            
+            AVCMusicPlugInfoBlock *mplug=m_status_descriptor->getMusicPlugInfoBlock(s.music_plug_id);
+            
+            if (mplug==NULL) {
+                debugWarning("No music plug found for this signal\n");
+                sinfo.m_name="unknown";
+            } else {
+                sinfo.m_name=mplug->getName();
+            }
+            
+            debugOutput(DEBUG_LEVEL_VERBOSE, "Adding signal pos=%2d loc=%2d name=%s\n",
+                sinfo.m_streamPosition, sinfo.m_location, mplug->getName().c_str());
+            
+            cinfo.m_channelInfos.push_back(sinfo);
+        }
+
+        idx++;
+        plug.getClusterInfos().push_back(cinfo);
+    }
+    
+    
+    return result;
+
+}
+
+bool
+SubunitMusic::loadDescriptors()
+{
+    bool result=true;
+    if (m_status_descriptor != NULL) {
+        result &= m_status_descriptor->load();
+    } else {
+        debugError("BUG: m_status_descriptor == NULL\n");
+        return false;
+    }
+    return result;
+}
+
+void SubunitMusic::setVerboseLevel(int l)
+{
+    Subunit::setVerboseLevel(l);
+    if (m_status_descriptor != NULL) {
+        m_status_descriptor->setVerboseLevel(l);
+    }
-}
-

branches/echoaudio/src/libavc/musicsubunit/avc_musicsubunit.h

@@ -32 +32 @@
-
-class Unit;
+class Plug;
+class AVCMusicStatusDescriptor;
-
-// /////////////////////////////
@@ -41 +43 @@
-    SubunitMusic();
-    virtual ~SubunitMusic();
+    
+    virtual bool discover();
+    virtual bool initPlugFromDescriptor( Plug& plug );
-
+    virtual bool loadDescriptors();
+    
+    virtual void setVerboseLevel(int l);
-    virtual const char* getName();
-
-protected:
-    virtual bool serializeChild( Glib::ustring basePath,
@@ -50 +57 @@
-                                   Util::IODeserialize& deser,
-                                   Unit& avDevice );
+
+    class AVCMusicStatusDescriptor*  m_status_descriptor;
-};
-

branches/echoaudio/src/libstreaming/PortManager.cpp

@@ -25 +25 @@
-#include "Port.h"
-#include <assert.h>
+
+#include <iostream>
+#include <sstream>
-
-
@@ -57 +60 @@
-// }
-
+bool PortManager::makeNameUnique(Port *port)
+{
+    bool done=false;
+    int idx=0;
+    std::string portname_orig=port->getName();
+    
+    while(!done && idx<10000) {
+        bool is_unique=true;
+        
+        for ( PortVectorIterator it = m_Ports.begin();
+        it != m_Ports.end();
+        ++it )
+        {
+            is_unique &= !((*it)->getName() == port->getName());
+        }
+        
+        if (is_unique) {
+            done=true;
+        } else {
+            std::ostringstream portname;
+            portname << portname_orig << idx++;
+            
+            port->setName(portname.str());
+        }
+    }
+    
+    if(idx<10000) return true;
+    else return false;
+}
+
-/**
- *
@@ -66 +99 @@
-    assert(port);
-
-
-
-
-
+
+
+
+
+
+
+
+
+
-}
-

branches/echoaudio/src/libstreaming/PortManager.h

@@ -48 +48 @@
-    virtual ~PortManager();
-
+    virtual bool makeNameUnique(Port *port);
-    virtual bool addPort(Port *port);
-    virtual bool deletePort(Port *port);

branches/echoaudio/src/Makefile.am

@@ -71 +71 @@
-        libavc/general/avc_generic.h \
-        libavc/general/avc_connect.h \
+        libavc/general/avc_signal_format.h \
-        libavc/general/avc_extended_plug_info.h \
-        libavc/general/avc_unit.h \
@@ -112 +113 @@
-        libavc/general/avc_subunit_info.cpp \
-        libavc/general/avc_connect.cpp \
+        libavc/general/avc_signal_format.cpp \
-        libavc/general/avc_extended_cmd_generic.cpp \
-        libavc/general/avc_extended_plug_info.cpp \

branches/echoaudio/tests/Makefile.am

@@ -24 +24 @@
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-
-#
+
-
-INCLUDES = -I$(top_srcdir) -I$(top_srcdir)/src $(LIBXML_CFLAGS) \

branches/echoaudio/tests/streaming/testmidistreaming1.c

@@ -45 +45 @@
-#include <alsa/asoundlib.h>
-
-reebob/freebob_streaming
+fado/ffado
-
-#include "debugtools.h"
@@ -68 +68 @@
-        snd_midi_event_t *parser;
-        snd_seq_t *seq_handle;
-reebob
+fado
-
-typedef struct {
-        snd_seq_t *seq_handle;
-        int nb_seq_ports;
-reebob
-reebob
+fado
+fado
-
-int open_seq(snd_seq_t **seq_handle, int in_ports[], int out_ports[], int num_in, int num_out);
@@ -113 +113 @@
-}
-
-reebob
+fado
-        snd_seq_event_t ev;
-        if ((snd_midi_event_encode_byte(port->parser,byte, &ev)) > 0) {
@@ -127 +127 @@
-}
-
-reebob
+fado
-        return 0;
-}
@@ -140 +140 @@
-        int retval=0;
-        int i=0;
+        int start_flag = 0;
-
-        int nb_periods=0;
-
-reebob
-reebob
-reebob
+fado
+fado
+fado
-        
-        run=1;
-
-reebob
+fado
-
-        signal (SIGINT, sighandler);
-        signal (SIGPIPE, sighandler);
-
-reebob
-
-reebob
+fado
+
+fado
-
-        dev_options.sample_rate=-1; // -1 = detect from discovery
@@ -169 +170 @@
-        dev_options.packetizer_priority=60;
-        
-
+
+
+
+
+
+
-        if (!dev) {
-reebob
+fado
-                exit(-1);
-        }
-
-reebob
-reebob
+fado
+fado
-
-        int midi_in_nbchannels=0;
@@ -182 +188 @@
-        
-        /* allocate intermediate buffers */
-reebob
-reebob
+fado
+fado
-        for (i=0;i<nb_in_channels;i++) {
-reebob
-reebob
+fado
+fado
-                        
-reebob
-reebob
+fado
+fado
-                                /* assign the audiobuffer to the stream */
-reebob
-reebob_streaming_set_capture_buffer_type(dev, i, freebob
+fado
+fado_streaming_set_capture_buffer_type(dev, i, ffado
-                                break;
-                                
-                        // this is done with read/write routines because the nb of bytes can differ.
-reebob
+fado
-                                midi_in_nbchannels++;
-                        default:
@@ -203 +209 @@
-        }
-        
-reebob
+fado
-        
-        for (i=0;i<nb_out_channels;i++) {
-reebob
-reebob
+fado
+fado
-                                if (i<nb_in_channels) {
-                                        /* assign the audiobuffer to the stream */
-reebob
-reebob_streaming_set_playback_buffer_type(dev, i, freebob
+fado
+fado_streaming_set_playback_buffer_type(dev, i, ffado
-                                } else {
-reebob
-reebob_streaming_set_playback_buffer_type(dev, i, freebob
+fado
+fado_streaming_set_playback_buffer_type(dev, i, ffado
-                                }
-                                break;
-                                // this is done with read/write routines because the nb of bytes can differ.
-reebob
+fado
-                                midi_out_nbchannels++;
-                        default:
@@ -235 +241 @@
-                fid_out[i]=fopen(name,"w");
-
-reebob
+fado
-                fprintf(fid_out[i],"Channel name: %s\n",name);
-reebob
-reebob
+fado
+fado
-                        fprintf(fid_out[i],"Channel type: audio\n");
-                        break;
-reebob
+fado
-                        fprintf(fid_out[i],"Channel type: midi\n");
-                        break;
-reebob
+fado
-                        fprintf(fid_out[i],"Channel type: unknown\n");
-                        break;
-                default:
-reebob
+fado
-                        fprintf(fid_out[i],"Channel type: invalid\n");
-                        break;
@@ -258 +264 @@
-                fid_in[i]=fopen(name,"w");
-
-reebob
-
-reebob
-reebob
+fado
+, name
+fado
+fado
-                        fprintf(fid_in[i], "Channel type: audio\n");
-                        break;
-reebob
+fado
-                        fprintf(fid_in[i], "Channel type: midi\n");
-                        break;
-reebob
+fado
-                        fprintf(fid_in[i],"Channel type: unknown\n");
-                        break;
-                default:
-reebob
+fado
-                        fprintf(fid_in[i],"Channel type: invalid\n");
-                        break;
@@ -288 +294 @@
-        }
-
-reebob
-reebob
+fado
+fado
-        
-        int cnt=0;
-        
-        for (i=0;i<nb_out_channels;i++) {
-reebob
-reebob
-reebob
+fado
+fado
+fado
-                                midi_out_portmap[i]=NULL;
-                                break;
-reebob
-reebob
+fado
+fado
-                                if(!midi_out_port) {
-                                        fprintf(stderr, "Could not allocate memory for MIDI OUT port %d\n",i);
@@ -314 +320 @@
-                                }
-                                break;
+                        default: break;
-                }
-        }
@@ -319 +326 @@
-        cnt=0;
-        for (i=0;i<nb_in_channels;i++) {
-reebob
-reebob
-reebob
+fado
+fado
+fado
-                                midi_in_portmap[i]=NULL;
-                                break;
-reebob
+fado
-                
-reebob
+fado
-                                if(!midi_in_port) {
-                                        fprintf(stderr, "Could not allocate memory for MIDI IN port %d\n",i);
@@ -340 +347 @@
-                                        midi_in_portmap[i]=midi_in_port;
-                                }
-
+
+
-                }
-        }       
-        
-        // start the streaming layer
-freebob
+start_flag = ffado
-
-        fprintf(stderr,"Entering receive loop (%d,%d)\n",nb_in_channels,nb_out_channels);
-
-reebob
+ && start_flag==0
+fado
-                if (retval < 0) {
-                        fprintf(stderr,"Xrun\n");
-reebob
+fado
-                        continue;
-                }
-                
-reebob
-reebob
-reebob
+fado
+fado
+fado
-                
-                nb_periods++;
@@ -369 +377 @@
-                        int s;
-                        
-reebob
-reebob
+fado
+fado
-                                // no need to get the buffers manually, we have set the API internal buffers to the audiobuffer[i]'s
-reebob
+fado
-                                samplesread=PERIOD_SIZE;
-                                break;
-reebob
-reebob
+fado
+fado
-                                quadlet_t *buff=(quadlet_t *)audiobuffers_in[i];
-                                for (s=0;s<samplesread;s++) {
@@ -385 +393 @@
-                                if(samplesread>0) {
-                                        fprintf(fid_in[i], "---- Period read (%d samples) ----\n",samplesread);
-
-
-
+
+
+
+
-                        }
-//                      fprintf(fid_in[i], "---- Period read (%d samples) ----\n",samplesread);
-reebob
+fado
-        
-                }
-
-                for(i=0;i<nb_out_channels;i++) {
-reebob
+fado
-                        int b=0;
-                        unsigned char* byte_buff;
@@ -405 +414 @@
-                        }
-                        
-reebob
-reebob
-reebob
+fado
+fado
+fado
-//                              sampleswritten=PERIOD_SIZE;
-                                break;
-reebob
+fado
-                                
-                                #define max_midi_bytes_to_write PERIOD_SIZE/8
@@ -418 +427 @@
-                                
-                                for(b=0;b<sampleswritten;b++) {
-reebob
-reebob
+fado
+fado
-                                }
-                                
-                                
-                                fprintf(fid_out[i], "---- Period write (%d samples) ----\n",sampleswritten);
-
-
+
+
+
-                        }
-                }
@@ -435 +445 @@
-        fprintf(stderr,"Exiting receive loop\n");
-        
-reebob
-
-reebob
+fado
+
+fado
-
-        for (i=0;i<nb_out_channels;i++) {
@@ -457 +467 @@
-        // free the MIDI to seq parsers and port structures
-        for(i=0;i<midi_in_nbchannels;i++) {
-reebob
+fado
-                
-                if(midi_in_port) {
@@ -466 +476 @@
-        // free the MIDI to seq parsers and port structures
-        for(i=0;i<midi_out_nbchannels;i++) {
-reebob
+fado
-
-                if(midi_out_port) {

branches/echoaudio/tests/streaming/teststreaming.c

@@ -36 +36 @@
-#include <signal.h>
-
-reebob/freebob_streaming
+fado/ffado
-
-#include "debugtools.h"
@@ -56 +56 @@
-        int retval=0;
-        int i=0;
+        int start_flag = 0;
-
-        int nb_periods=0;
-
-reebob
-reebob
+fado
+fado
-        
-        run=1;
-
-reebob
+fado
-
-        signal (SIGINT, sighandler);
-        signal (SIGPIPE, sighandler);
-
-reebob
-
-reebob
+fado
+
+fado
-
-        dev_options.sample_rate=44100;
@@ -83 +84 @@
-        dev_options.realtime=0;
-        dev_options.packetizer_priority=60;
-
-
+
+
+
+
+
+
+
-        if (!dev) {
-reebob
+FADO
-                exit(-1);
-        }
-
-reebob
-reebob
+fado
+fado
-
-        /* allocate intermediate buffers */
-reebob
-
-reebob
-
-
-reebob
+fado
+
+fado
+
+
+fado
-        
-        /* open the files to write to*/
@@ -111 +117 @@
-                fid_out[i]=fopen(name,"w");
-
-reebob
+fado
-                fprintf(fid_out[i],"Channel name: %s\n",name);
-reebob
-reebob
+fado
+fado
-                        fprintf(fid_out[i],"Channel type: audio\n");
-                        break;
-reebob
+fado
-                        fprintf(fid_out[i],"Channel type: midi\n");
-                        break;
-reebob
+fado
-                        fprintf(fid_out[i],"Channel type: unknown\n");
-                        break;
-                default:
-reebob
+fado
-                        fprintf(fid_out[i],"Channel type: invalid\n");
-                        break;
@@ -134 +140 @@
-                fid_in[i]=fopen(name,"w");
-
-reebob
+fado
-                fprintf(fid_in[i], "Channel name: %s\n",name);
-reebob
-reebob
+fado
+fado
-                        fprintf(fid_in[i], "Channel type: audio\n");
-                        break;
-reebob
+fado
-                        fprintf(fid_in[i], "Channel type: midi\n");
-                        break;
-reebob
+fado
-                        fprintf(fid_in[i],"Channel type: unknown\n");
-                        break;
-                default:
-reebob
+fado
-                        fprintf(fid_in[i],"Channel type: invalid\n");
-                        break;
@@ -153 +159 @@
-        }
-
-reebob
-freebob
+fado
+start_flag = ffado
-
-        fprintf(stderr,"Entering receive loop (%d,%d)\n",nb_in_channels,nb_out_channels);
-
-reebob
+ && start_flag==0
+fado
-                if (retval < 0) {
-                        fprintf(stderr,"Xrun\n");
-reebob
+fado
-                        continue;
-                }
-
-reebob
-reebob
-reebob
+fado
+fado
+fado
-                
-                nb_periods++;
@@ -176 +182 @@
-
-                for(i=0;i<nb_in_channels;i++) {
-reebob
-reebob
-reebob
-
-reebob
-reebob
+fado
+fado
+fado
+
+fado
+fado
-                                break;
-                        default:
@@ -187 +193 @@
-                        }
-//                      fprintf(fid_in[i], "---- Period read  (%d samples) ----\n",samplesread);
-reebob
+fado
-                }
-
-                for(i=0;i<nb_out_channels;i++) {
-reebob
+fado
-                        if (i<nb_in_channels) {
-                                buff=audiobuffer[i];
@@ -198 +204 @@
-                        }
-                        
-reebob
-reebob
-reebob
-
-reebob
-reebob
+fado
+fado
+fado
+
+fado
+fado
-                                break;
-                        default:
@@ -209 +215 @@
-                        }
-//                      fprintf(fid_out[i], "---- Period write (%d samples) ----\n",sampleswritten);
-reebob
+fado
-                }
-
@@ -218 +224 @@
-        fprintf(stderr,"Exiting receive loop\n");
-        
-reebob
-
-reebob
+fado
+
+fado
-
-        for (i=0;i<nb_out_channels;i++) {

branches/echoaudio/tests/streaming/teststreaming2.c

@@ -38 +38 @@
-#include <signal.h>
-
-reebob/freebob_streaming
+fado/ffado
-
-#include "debugtools.h"
@@ -58 +58 @@
-        int retval=0;
-        int i=0;
+        int start_flag=0;
-
-        int nb_periods=0;
-
-reebob
-reebob
+fado
+fado
-        
-        run=1;
-
-reebob
+fado
-
-        signal (SIGINT, sighandler);
-        signal (SIGPIPE, sighandler);
-
-reebob
-
-reebob
+fado
+
+fado
-
-        dev_options.sample_rate=44100;
@@ -85 +86 @@
-        dev_options.realtime=1;
-        dev_options.packetizer_priority=60;
-
-
+
+
+
+
+
+
+
-        if (!dev) {
-reebob
+fado
-                exit(-1);
-        }
-
-reebob
-reebob
+fado
+fado
-
-        /* allocate intermediate buffers */
-reebob
-
-reebob
-
-reebob
-reebob
+fado
+
+fado
+
+fado
+fado
-                                /* assign the audiobuffer to the stream */
-reebob
-reebob_streaming_set_capture_buffer_type(dev, i, freebob
+fado
+fado_streaming_set_capture_buffer_type(dev, i, ffado
-                                break;
-                                // this is done with read/write routines because the nb of bytes can differ.
-reebob
+fado
-                        default:
-                                break;
@@ -113 +119 @@
-        }
-        
-reebob
+fado
-
-#if 1
-        for (i=0;i<nb_out_channels;i++) {
-reebob
-reebob
+fado
+fado
-                                if (i<nb_in_channels) {
-                                        /* assign the audiobuffer to the stream */
-reebob
+fado
-                                } else {
-reebob
+fado
-                                }
-reebob_streaming_set_playback_buffer_type(dev, i, freebob
+fado_streaming_set_playback_buffer_type(dev, i, ffado
-                                break;
-                                // this is done with read/write routines because the nb of bytes can differ.
-reebob
+fado
-                        default:
-                                break;
@@ -145 +151 @@
-                fid_out[i]=fopen(name,"w");
-
-reebob
+fado
-                fprintf(fid_out[i],"Channel name: %s\n",name);
-reebob
-reebob
+fado
+fado
-                        fprintf(fid_out[i],"Channel type: audio\n");
-                        break;
-reebob
+fado
-                        fprintf(fid_out[i],"Channel type: midi\n");
-                        break;
-reebob
+fado
-                        fprintf(fid_out[i],"Channel type: unknown\n");
-                        break;
-                default:
-reebob
+fado
-                        fprintf(fid_out[i],"Channel type: invalid\n");
-                        break;
@@ -168 +174 @@
-                fid_in[i]=fopen(name,"w");
-
-reebob
+fado
-                fprintf(fid_in[i], "Channel name: %s\n",name);
-reebob
-reebob
+fado
+fado
-                        fprintf(fid_in[i], "Channel type: audio\n");
-                        break;
-reebob
+fado
-                        fprintf(fid_in[i], "Channel type: midi\n");
-                        break;
-reebob
+fado
-                        fprintf(fid_in[i],"Channel type: unknown\n");
-                        break;
-                default:
-reebob
+fado
-                        fprintf(fid_in[i],"Channel type: invalid\n");
-                        break;
@@ -190 +196 @@
-
-        // prepare and start the streaming layer
-reebob
-freebob
+fado
+start_flag = ffado
-
-        fprintf(stderr,"Entering receive loop (%d,%d)\n",nb_in_channels,nb_out_channels);
-
-reebob
+ && start_flag==0
+fado
-                if (retval < 0) {
-                        fprintf(stderr,"Xrun\n");
-reebob
+fado
-                        continue;
-                }
-                
-                for (i=0;i<nb_in_channels;i++) {
-reebob
-
-
-reebob
-reebob
-reebob
+fado
+
+
+fado
+fado
+fado
-                
-                nb_periods++;
@@ -219 +225 @@
-                        
-                        
-reebob
-reebob
+fado
+fado
-                                // no need to get the buffers manually, we have set the API internal buffers to the audiobuffer[i]'s
-reebob
+fado
-                                samplesread=PERIOD_SIZE;
-                                break;
-reebob
-reebob
+fado
+fado
-                                break;
-                        default:
@@ -233 +239 @@
-        
-//                      fprintf(fid_in[i], "---- Period read  (%d samples) ----\n",samplesread);
-reebob
+fado
-// FIXME: Dump analog1 as raw data to a separate binary file for testing
-//if (i==2) {
-reebob
+fado
-//}
-                }
-
-                for(i=0;i<nb_out_channels;i++) {
-reebob
+fado
-                        if (i<nb_in_channels) {
-                                buff=audiobuffer[i];
@@ -248 +254 @@
-                        }
-                        
-reebob
-reebob
-reebob
+fado
+fado
+fado
-//// Just mirror the read case since it seems to work.
-reebob
+fado
-                                sampleswritten=PERIOD_SIZE;
-                                break;
-reebob
-reebob
+fado
+fado
-                                break;
-                        default:
@@ -262 +268 @@
-                        }
-//                      fprintf(fid_out[i], "---- Period write (%d samples) ----\n",sampleswritten);
-reebob
+fado
-                }
-
@@ -271 +277 @@
-        fprintf(stderr,"Exiting receive loop\n");
-        
-reebob
-
-reebob
+fado
+
+fado
-fclose(of);
-

branches/echoaudio/tests/streaming/teststreaming3.c

@@ -38 +38 @@
-#include <signal.h>
-
-reebob/freebob_streaming
+fado/ffado
-
-#include "debugtools.h"
@@ -59 +59 @@
-        int retval=0;
-        int i=0;
+        int start_flag = 0;
-
-        int nb_periods=0;
-
-        float **audiobuffers_in;
-reebob
-reebob
+fado
+fado
-        
-        run=1;
-
-reebob
+fado
-
-        signal (SIGINT, sighandler);
-        signal (SIGPIPE, sighandler);
-
-reebob
-
-reebob
+fado
+
+fado
-
-        dev_options.sample_rate=44100;
@@ -88 +89 @@
-        dev_options.packetizer_priority=70;
-        
-
+
+
+
+
+
+
-        if (!dev) {
-reebob
+fado
-                exit(-1);
-        }
-
-reebob
-reebob
+fado
+fado
-
-        /* allocate intermediate buffers */
-        audiobuffers_in=calloc(nb_in_channels,sizeof(float *));
-reebob
+fado
-        for (i=0;i<nb_in_channels;i++) {
-                audiobuffers_in[i]=calloc(PERIOD_SIZE+1,sizeof(float));
-reebob
-
-reebob
-reebob
+fado
+
+fado
+fado
-                                /* assign the audiobuffer to the stream */
-reebob
-reebob_streaming_set_capture_buffer_type(dev, i, freebob
+fado
+fado_streaming_set_capture_buffer_type(dev, i, ffado
-                                break;
-                                // this is done with read/write routines because the nb of bytes can differ.
-reebob
+fado
-                        default:
-                                break;
@@ -117 +123 @@
-        }
-        
-reebob
+fado
-        
-        for (i=0;i<nb_out_channels;i++) {
-reebob
-reebob
+fado
+fado
-                                if (i<nb_in_channels) {
-                                        /* assign the audiobuffer to the stream */
-reebob
-reebob_streaming_set_playback_buffer_type(dev, i, freebob
+fado
+fado_streaming_set_playback_buffer_type(dev, i, ffado
-                                } else {
-reebob
-reebob_streaming_set_playback_buffer_type(dev, i, freebob
+fado
+fado_streaming_set_playback_buffer_type(dev, i, ffado
-                                }
-                                break;
-                                // this is done with read/write routines because the nb of bytes can differ.
-reebob
+fado
-                        default:
-                                break;
@@ -148 +154 @@
-                fid_out[i]=fopen(name,"w");
-
-reebob
+fado
-                fprintf(fid_out[i],"Channel name: %s\n",name);
-reebob
-reebob
+fado
+fado
-                        fprintf(fid_out[i],"Channel type: audio\n");
-                        break;
-reebob
+fado
-                        fprintf(fid_out[i],"Channel type: midi\n");
-                        break;
-reebob
+fado
-                        fprintf(fid_out[i],"Channel type: unknown\n");
-                        break;
-                default:
-reebob
+fado
-                        fprintf(fid_out[i],"Channel type: invalid\n");
-                        break;
@@ -171 +177 @@
-                fid_in[i]=fopen(name,"w");
-
-reebob
-
-reebob
-reebob
+fado
+,name
+fado
+fado
-                        fprintf(fid_in[i], "Channel type: audio\n");
-                        break;
-reebob
+fado
-                        fprintf(fid_in[i], "Channel type: midi\n");
-                        break;
-reebob
+fado
-                        fprintf(fid_in[i],"Channel type: unknown\n");
-                        break;
-                default:
-reebob
+fado
-                        fprintf(fid_in[i],"Channel type: invalid\n");
-                        break;
@@ -191 +197 @@
-
-        // start the streaming layer
-
+
+
-
-        fprintf(stderr,"Entering receive loop (%d,%d)\n",nb_in_channels,nb_out_channels);
-
-reebob
+ && start_flag==0
+fado
-                if (retval < 0) {
-                        fprintf(stderr,"Xrun\n");
-reebob
+fado
-                        continue;
-                }
-                
-reebob
-reebob
-reebob
+fado
+fado
+fado
-                
-                nb_periods++;
@@ -215 +222 @@
-                        
-                        
-reebob
-reebob
+fado
+fado
-                                // no need to get the buffers manually, we have set the API internal buffers to the audiobuffer[i]'s
-//                              //samplesread=freebob_streaming_read(dev, i, audiobuffer[i], PERIOD_SIZE);
-                                samplesread=PERIOD_SIZE;
-                                break;
-
-
-
+
+
+
+
-                        }
-        
@@ -231 +239 @@
-
-                for(i=0;i<nb_out_channels;i++) {
-reebob
+fado
-                        int sampleswritten=0;
-                        if (i<nb_in_channels) {
@@ -239 +247 @@
-                        }
-                        
-reebob
-reebob
+fado
+fado
-//                              sampleswritten=freebob_streaming_write(dev, i, buff, PERIOD_SIZE);
-                                sampleswritten=PERIOD_SIZE;
-                                break;
-reebob
+fado
-//                              sampleswritten=freebob_streaming_write(dev, i, buff, PERIOD_SIZE);
-                                break;
+                        default: break;
-                        }
-//                      fprintf(fid_out[i], "---- Period write (%d samples) ----\n",sampleswritten);
-reebob
+fado
-                }
-
@@ -258 +267 @@
-        fprintf(stderr,"Exiting receive loop\n");
-        
-reebob
-
-reebob
+fado
+
+fado
-
-        for (i=0;i<nb_out_channels;i++) {