Changeset 242 for branches

Show
Ignore:
Timestamp:
06/03/06 13:39:12 (16 years ago)
Author:
pieterpalmers
Message:

- made the bounce device actually work

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • branches/libfreebob-2.0/src/bebob_light/bebob_light_avdevice.cpp

    r234 r242  
    10931093AvDevice::enumerateSubUnits() 
    10941094{ 
     1095    bool musicSubunitFound=false; 
     1096    bool audioSubunitFound=false; 
     1097 
    10951098    SubUnitInfoCmd subUnitInfoCmd( m_1394Service ); 
    10961099    //subUnitInfoCmd.setVerbose( 1 ); 
     
    11051108    if ( !subUnitInfoCmd.fire() ) { 
    11061109        debugError( "Subunit info command failed\n" ); 
     1110        // shouldn't this be an error situation? 
     1111        return false; 
    11071112    } 
    11081113 
     
    11271132                return false; 
    11281133            } 
     1134            m_subunits.push_back( subunit ); 
     1135            audioSubunitFound=true; 
    11291136            break; 
    11301137        case AVCCommand::eST_Music: 
     
    11341141                return false; 
    11351142            } 
     1143            m_subunits.push_back( subunit ); 
     1144            musicSubunitFound=true; 
    11361145            break; 
    11371146        default: 
     
    11431152        } 
    11441153 
    1145         m_subunits.push_back( subunit ); 
    1146     } 
    1147  
    1148     return true
     1154    } 
     1155     
     1156    // a BeBoB always has an audio and a music subunit 
     1157    return (musicSubunitFound && audioSubunitFound)
    11491158} 
    11501159 
  • branches/libfreebob-2.0/src/bebob_light/bebob_light_avdevice.h

    r234 r242  
    139139        int m_transmitProcessorBandwidth; 
    140140         
    141         // FIXME: remove this debug line 
    142         FreebobStreaming::AmdtpReceiveStreamProcessor *m_receiveProcessor2; 
    143         int m_receiveProcessor2Bandwidth; 
    144  
    145  
    146141    DECLARE_DEBUG_MODULE; 
    147142}; 
  • branches/libfreebob-2.0/src/bounce/bounce_avdevice.cpp

    r199 r242  
    2323#include "configrom.h" 
    2424 
     25#include "libfreebobavc/avc_plug_info.h" 
     26#include "libfreebobavc/avc_extended_plug_info.h" 
     27#include "libfreebobavc/avc_subunit_info.h" 
     28#include "libfreebobavc/avc_extended_stream_format.h" 
     29#include "libfreebobavc/serialize.h" 
    2530#include "libfreebobavc/ieee1394service.h" 
    2631#include "libfreebobavc/avc_definitions.h" 
     
    2833#include "debugmodule/debugmodule.h" 
    2934 
     35#include <iostream>      
     36#include <sstream> 
     37#include <stdint.h> 
     38 
    3039#include <string> 
    31 #include <stdint.h> 
    32 #include <iostream> 
    3340#include <netinet/in.h> 
    3441 
    3542namespace Bounce { 
    3643 
    37 IMPL_DEBUG_MODULE( BounceDevice, BounceDevice, DEBUG_LEVEL_NORMAL ); 
     44IMPL_DEBUG_MODULE( BounceDevice, BounceDevice, DEBUG_LEVEL_VERBOSE ); 
    3845 
    3946BounceDevice::BounceDevice( Ieee1394Service& ieee1394service, 
     
    4350    , m_nodeId( nodeId ) 
    4451    , m_verboseLevel( verboseLevel ) 
    45 
    46     if ( m_verboseLevel ) { 
    47         setDebugLevel( DEBUG_LEVEL_VERBOSE ); 
    48     } 
     52    , m_samplerate (44100) 
     53    , m_id(0) 
     54    , m_receiveProcessor ( 0 ) 
     55    , m_receiveProcessorBandwidth ( -1 ) 
     56    , m_transmitProcessor ( 0 ) 
     57    , m_transmitProcessorBandwidth ( -1 ) 
     58
     59    setDebugLevel( m_verboseLevel ); 
     60     
    4961    debugOutput( DEBUG_LEVEL_VERBOSE, "Created Bounce::BounceDevice (NodeID %d)\n", 
    5062                 nodeId ); 
     
    7082        quadlet_t request[6]; 
    7183        quadlet_t *resp; 
     84         
     85    debugOutput( DEBUG_LEVEL_VERBOSE, "Discovering...\n" ); 
    7286 
    7387        std::string vendor=std::string(FREEBOB_BOUNCE_SERVER_VENDORNAME); 
     
    7892                return false; 
    7993        } 
    80  
     94/* 
    8195// AVC1394_COMMAND_INPUT_PLUG_SIGNAL_FORMAT 
    8296        request[0] = htonl( AVC1394_CTYPE_STATUS | (AVC1394_SUBUNIT_TYPE_FREEBOB_BOUNCE_SERVER << 19) | (0 << 16) 
     
    91105        if(resp) { 
    92106                char *buffer=(char *)&resp[1]; 
     107                resp[resp_len-1]=0; 
    93108                xmlDescription=buffer; 
    94109//              hexDump((unsigned char *)resp,6*4); 
    95110        } 
    96  
     111*/ 
    97112        return true; 
    98113} 
    99114 
    100 bool 
    101 BounceDevice::setSamplingFrequency( ESamplingFrequency samplingFrequency ) 
    102 
     115int BounceDevice::getSamplingFrequency( ) { 
     116    return m_samplerate; 
     117
     118 
     119bool BounceDevice::setSamplingFrequency( ESamplingFrequency samplingFrequency ) { 
     120    int retval=convertESamplingFrequency( samplingFrequency ); 
     121    if (retval) { 
     122        m_samplerate=retval; 
     123        return true; 
     124    } else return false; 
     125
     126 
     127bool BounceDevice::setId( unsigned int id) { 
     128    debugOutput( DEBUG_LEVEL_VERBOSE, "Set id to %d...\n", id); 
     129    m_id=id; 
    103130    return true; 
    104131} 
     
    107134BounceDevice::showDevice() const 
    108135{ 
    109     printf( "\nI am the bouncedevice, the bouncedevice I am...\n" ); 
    110     printf( "Vendor            :  %s\n", m_configRom->getVendorName().c_str()); 
    111     printf( "Model             :  %s\n", m_configRom->getModelName().c_str()); 
    112     printf( "Node              :  %d\n", m_nodeId); 
    113     printf( "GUID              :  0x%016llX\n", m_configRom->getGuid()); 
    114     printf( "ACV test response :  %s\n", xmlDescription.c_str()); 
    115     printf( "\n" ); 
     136    debugOutput(DEBUG_LEVEL_NORMAL, "\nI am the bouncedevice, the bouncedevice I am...\n" ); 
     137    debugOutput(DEBUG_LEVEL_NORMAL, "Vendor            :  %s\n", m_configRom->getVendorName().c_str()); 
     138    debugOutput(DEBUG_LEVEL_NORMAL, "Model             :  %s\n", m_configRom->getModelName().c_str()); 
     139    debugOutput(DEBUG_LEVEL_NORMAL, "Node              :  %d\n", m_nodeId); 
     140    debugOutput(DEBUG_LEVEL_NORMAL, "GUID              :  0x%016llX\n", m_configRom->getGuid()); 
     141    debugOutput(DEBUG_LEVEL_NORMAL, "AVC test response :  %s\n", xmlDescription.c_str()); 
     142    debugOutput(DEBUG_LEVEL_NORMAL, "\n" ); 
    116143} 
    117144 
     
    119146BounceDevice::addXmlDescription( xmlNodePtr deviceNode ) 
    120147{ 
    121  
    122         xmlDocPtr doc; 
    123         xmlNodePtr cur; 
    124         xmlNodePtr copy; 
    125  
    126         doc = xmlParseFile("freebob_bouncedevice.xml"); 
    127          
    128         if (doc == NULL ) { 
    129                 debugError( "freebob_bouncedevice.xml not parsed successfully. \n"); 
     148     
     149    return false; 
     150 
     151
     152 
     153#define BOUNCE_NR_OF_CHANNELS 2 
     154 
     155bool 
     156BounceDevice::addPortsToProcessor( 
     157        FreebobStreaming::StreamProcessor *processor,  
     158        FreebobStreaming::AmdtpAudioPort::E_Direction direction) { 
     159         
     160    debugOutput(DEBUG_LEVEL_VERBOSE,"Adding ports to processor\n"); 
     161         
     162    int i=0; 
     163    for (i=0;i<BOUNCE_NR_OF_CHANNELS;i++) { 
     164        char *buff; 
     165        asprintf(&buff,"dev%d%s_Port%d",m_id,direction==FreebobStreaming::AmdtpAudioPort::E_Playback?"p":"c",i); 
     166         
     167        FreebobStreaming::Port *p=NULL; 
     168        p=new FreebobStreaming::AmdtpAudioPort( 
     169                buff, 
     170                direction,  
     171                // \todo: streaming backend expects indexing starting from 0 
     172                // but bebob reports it starting from 1. Decide where 
     173                // and how to handle this (pp: here) 
     174                i,  
     175                0,  
     176                FreebobStreaming::AmdtpPortInfo::E_MBLA,  
     177                0 
     178        ); 
     179     
     180        if (!p) { 
     181            debugOutput(DEBUG_LEVEL_VERBOSE, "Skipped port %s\n",buff); 
     182        } else { 
     183     
     184            if (!processor->addPort(p)) { 
     185                debugWarning("Could not register port with stream processor\n"); 
     186                free(buff); 
     187                return false; 
     188            } else { 
     189                debugOutput(DEBUG_LEVEL_VERBOSE, "Added port %s\n",buff); 
     190             
     191            } 
     192        } 
     193         
     194        free(buff); 
     195         
     196     } 
     197 
     198        return true; 
     199
     200 
     201bool 
     202BounceDevice::prepare() { 
     203 
     204    debugOutput(DEBUG_LEVEL_NORMAL, "Preparing BounceDevice...\n" ); 
     205 
     206        m_receiveProcessor=new FreebobStreaming::AmdtpReceiveStreamProcessor( 
     207                                 m_1394Service->getPort(), 
     208                                 m_samplerate, 
     209                                 BOUNCE_NR_OF_CHANNELS); 
     210                                  
     211        if(!m_receiveProcessor->init()) { 
     212                debugFatal("Could not initialize receive processor!\n"); 
    130213                return false; 
    131         } 
    132          
    133         cur = xmlDocGetRootElement(doc); 
    134          
    135         if (cur == NULL) { 
    136                 debugError( "empty document\n"); 
    137                 xmlFreeDoc(doc); 
     214         
     215        } 
     216 
     217        if (!addPortsToProcessor(m_receiveProcessor,  
     218                FreebobStreaming::AmdtpAudioPort::E_Capture)) { 
     219                debugFatal("Could not add ports to processor!\n"); 
     220                return false; 
     221        } 
     222 
     223        // do the transmit processor 
     224        m_transmitProcessor=new FreebobStreaming::AmdtpTransmitStreamProcessor( 
     225                                 m_1394Service->getPort(), 
     226                                 m_samplerate, 
     227                                 BOUNCE_NR_OF_CHANNELS); 
     228                                  
     229        m_transmitProcessor->setVerboseLevel(getDebugLevel()); 
     230         
     231        if(!m_transmitProcessor->init()) { 
     232                debugFatal("Could not initialize transmit processor!\n"); 
    138233                return false; 
    139         } 
    140          
    141         if (xmlStrcmp(cur->name, (const xmlChar *) "FreeBobBounceDevice")) { 
    142                 debugError( "document of the wrong type, root node != FreeBobBounceDevice\n"); 
    143                 xmlFreeDoc(doc); 
    144                 return false; 
    145         } 
    146          
    147         cur = cur->xmlChildrenNode; 
    148         while (cur != NULL) { 
    149                 char *result; 
    150                  
    151                 copy=xmlCopyNode(cur,1); 
    152                  
    153 //              debugOutput(DEBUG_LEVEL_NORMAL,"copying %s\n",cur->name); 
    154                  
    155                  
    156                 if (!copy || !xmlAddChild(deviceNode, copy)) { 
    157                         debugError( "could not add child node\n"); 
    158                         cur = cur->next; 
    159                         continue; 
    160                 } 
    161                  
    162                 // add the node id 
    163 //              if (xmlStrcmp(copy->name, (const xmlChar *) "ConnectionSet")) { 
    164 //                      asprintf( &result, "%d",  m_nodeId); 
    165 //                      if ( !xmlNewChild( copy,  0, 
    166 //                            BAD_CAST "Node",  BAD_CAST result ) ) { 
    167 //                                    debugError( "Couldn't create 'Node' node\n" ); 
    168 //                                    return false; 
    169 //                                    free(result); 
    170 //                      } 
    171 //                      free(result); 
    172 //              } 
    173                  
    174                 cur = cur->next; 
    175         } 
    176          
    177         xmlFreeDoc(doc); 
    178  
    179     return true; 
    180 
    181  
    182 
     234         
     235        } 
     236 
     237        if (!addPortsToProcessor(m_transmitProcessor,  
     238                FreebobStreaming::AmdtpAudioPort::E_Playback)) { 
     239                debugFatal("Could not add ports to processor!\n"); 
     240                return false; 
     241        } 
     242         
     243        return true; 
     244
     245 
     246int  
     247BounceDevice::getStreamCount() { 
     248        return 2; // one receive, one transmit 
     249
     250 
     251FreebobStreaming::StreamProcessor * 
     252BounceDevice::getStreamProcessorByIndex(int i) { 
     253        switch (i) { 
     254        case 0: 
     255                return m_receiveProcessor; 
     256        case 1: 
     257                return m_transmitProcessor; 
     258        default: 
     259                return NULL; 
     260        } 
     261        return 0; 
     262
     263 
     264int 
     265BounceDevice::startStreamByIndex(int i) { 
     266//      int iso_channel=0; 
     267//      int plug=0; 
     268//      int hostplug=-1; 
     269//       
     270        switch (i) { 
     271        case 0: 
     272//              // do connection management: make connection 
     273//              iso_channel = iec61883_cmp_connect( 
     274//                      m_1394Service->getHandle(),  
     275//                      m_nodeId | 0xffc0,  
     276//                      &plug, 
     277//                      raw1394_get_local_id (m_1394Service->getHandle()),  
     278//                      &hostplug,  
     279//                      &m_receiveProcessorBandwidth); 
     280//               
     281//              // set the channel obtained by the connection management 
     282                m_receiveProcessor->setChannel(1); 
     283                break; 
     284        case 1: 
     285//              // do connection management: make connection 
     286//              iso_channel = iec61883_cmp_connect( 
     287//                      m_1394Service->getHandle(),  
     288//                      raw1394_get_local_id (m_1394Service->getHandle()),  
     289//                      &hostplug,  
     290//                      m_nodeId | 0xffc0,  
     291//                      &plug, 
     292//                      &m_transmitProcessorBandwidth); 
     293//               
     294//              // set the channel obtained by the connection management 
     295// //           m_receiveProcessor2->setChannel(iso_channel); 
     296                m_transmitProcessor->setChannel(0); 
     297                break; 
     298        default: 
     299                return -1; 
     300        } 
     301 
     302        return 0; 
     303 
     304
     305 
     306int 
     307BounceDevice::stopStreamByIndex(int i) { 
     308        // do connection management: break connection 
     309 
     310//      int plug=0; 
     311//      int hostplug=-1; 
     312//  
     313//      switch (i) { 
     314//      case 0: 
     315//              // do connection management: break connection 
     316//              iec61883_cmp_disconnect( 
     317//                      m_1394Service->getHandle(),  
     318//                      m_nodeId | 0xffc0,  
     319//                      plug, 
     320//                      raw1394_get_local_id (m_1394Service->getHandle()),  
     321//                      hostplug,  
     322//                      m_receiveProcessor->getChannel(), 
     323//                      m_receiveProcessorBandwidth); 
     324//  
     325//              break; 
     326//      case 1: 
     327//              // do connection management: break connection 
     328//              iec61883_cmp_disconnect( 
     329//                      m_1394Service->getHandle(),  
     330//                      raw1394_get_local_id (m_1394Service->getHandle()),  
     331//                      hostplug,  
     332//                      m_nodeId | 0xffc0,  
     333//                      plug, 
     334//                      m_transmitProcessor->getChannel(), 
     335//                      m_transmitProcessorBandwidth); 
     336//  
     337//              // set the channel obtained by the connection management 
     338// //           m_receiveProcessor2->setChannel(iso_channel); 
     339//              break; 
     340//      default: 
     341//              return 0; 
     342//      } 
     343 
     344        return 0; 
     345
     346 
     347 
     348 
     349
  • branches/libfreebob-2.0/src/bounce/bounce_avdevice.h

    r199 r242  
    2323#define BOUNCEDEVICE_H 
    2424 
    25 #include "iavdevice.h" 
    26  
    2725#include "debugmodule/debugmodule.h" 
    2826#include "libfreebobavc/avc_definitions.h" 
    2927#include "libfreebobavc/avc_extended_cmd_generic.h" 
    3028#include "libfreebob/xmlparser.h" 
     29 
     30#include "bebob_light/bebob_light_avplug.h" 
     31#include "bebob_light/bebob_light_avdevicesubunit.h" 
     32 
     33#include "libstreaming/AmdtpStreamProcessor.h" 
     34#include "libstreaming/AmdtpPort.h" 
     35#include "libstreaming/AmdtpPortInfo.h" 
     36 
     37#include "iavdevice.h" 
    3138#include "libfreebob/freebob_bounce.h" 
    3239 
     
    4552    virtual bool discover(); 
    4653    virtual ConfigRom& getConfigRom() const; 
     54     
    4755    virtual bool addXmlDescription( xmlNodePtr deviceNode ); 
     56     
    4857    virtual bool setSamplingFrequency( ESamplingFrequency samplingFrequency ); 
     58        virtual int getSamplingFrequency( ); 
     59     
     60    virtual bool setId(unsigned int id); 
     61         
     62        virtual bool prepare(); 
     63         
     64        virtual int getStreamCount(); 
     65         
     66        virtual FreebobStreaming::StreamProcessor *getStreamProcessorByIndex(int i); 
     67         
     68        virtual int startStreamByIndex(int i); 
     69         
     70        virtual int stopStreamByIndex(int i); 
     71     
    4972    virtual void showDevice() const; 
    5073 
     
    5881        std::string xmlDescription; 
    5982 
     83    unsigned int m_samplerate; 
     84    unsigned int m_id; 
     85 
     86        // streaming stuff 
     87        FreebobStreaming::AmdtpReceiveStreamProcessor *m_receiveProcessor; 
     88        int m_receiveProcessorBandwidth; 
     89         
     90        FreebobStreaming::AmdtpTransmitStreamProcessor *m_transmitProcessor; 
     91        int m_transmitProcessorBandwidth; 
     92 
     93    bool addPortsToProcessor( 
     94           FreebobStreaming::StreamProcessor *processor,  
     95           FreebobStreaming::AmdtpAudioPort::E_Direction direction); 
     96 
    6097 
    6198    DECLARE_DEBUG_MODULE; 
  • branches/libfreebob-2.0/src/debugmodule/debugmodule.cpp

    r233 r242  
    5858             << endl; 
    5959    } 
     60     
    6061} 
    6162 
  • branches/libfreebob-2.0/src/debugmodule/debugmodule.h

    r233 r242  
    3131 
    3232/* MB_NEXT() relies on the fact that MB_BUFFERS is a power of two */ 
    33 #define MB_BUFFERS      128 
     33#define MB_BUFFERS      1024 
    3434#define MB_NEXT(index) ((index+1) & (MB_BUFFERS-1)) 
    3535#define MB_BUFFERSIZE   256             /* message length limit */ 
  • branches/libfreebob-2.0/src/devicemanager.cpp

    r234 r242  
    3333 
    3434#include <iostream> 
     35#include <unistd.h> 
    3536 
    3637using namespace std; 
     
    4243{ 
    4344//      m_probeList.push_back( probeMotu ); 
    44     m_probeList.push_back( probeBeBoB ); 
    45 //      m_probeList.push_back( probeBounce ); 
     45    m_probeList.push_back( probeBeBoB ); 
     46    m_probeList.push_back( probeBounce ); 
    4647} 
    4748 
     
    147148    if ( !avDevice->discover() ) { 
    148149        delete avDevice; 
     150        debugOutput( DEBUG_LEVEL_VERBOSE, "Not a BeBoB device...\n" ); 
     151       return NULL; 
     152    } 
     153    debugOutput( DEBUG_LEVEL_VERBOSE, "BeBoB device discovered...\n" ); 
     154    return avDevice; 
     155} 
     156 
     157IAvDevice* 
     158DeviceManager::probeBounce(Ieee1394Service& service, int id, int level) 
     159{ 
     160    IAvDevice* avDevice = new Bounce::BounceDevice( service, id, level ); 
     161    if ( !avDevice ) { 
    149162        return NULL; 
    150163    } 
     164 
     165    if ( !avDevice->discover() ) { 
     166        debugOutput( DEBUG_LEVEL_VERBOSE, "Not a Bounce device...\n"); 
     167     
     168        delete avDevice; 
     169        return NULL; 
     170    } 
     171    debugOutput( DEBUG_LEVEL_VERBOSE, "Bounce device discovered...\n"); 
     172     
    151173    return avDevice; 
    152174} 
    153175 
    154 // IAvDevice* 
    155 // DeviceManager::probeBounce(Ieee1394Service& service, int id, int level) 
    156 // { 
    157 //     IAvDevice* avDevice = new Bounce::BounceDevice( service, id, level ); 
    158 //     if ( !avDevice ) { 
    159 //         return NULL; 
    160 //     } 
    161 //  
    162 //     if ( !avDevice->discover() ) { 
    163 //         delete avDevice; 
    164 //         return NULL; 
    165 //     } 
    166 //     return avDevice; 
    167 // } 
    168 //  
    169176// IAvDevice* 
    170177// DeviceManager::probeMotu(Ieee1394Service& service, int id, int level) 
     
    288295        { 
    289296            debugError( "Couldn't create 'NodeId' node" ); 
     297            free(result); 
    290298            return false; 
    291299        } 
     
    303311            xmlFreeDoc( doc ); 
    304312            xmlCleanupParser(); 
     313            free(result); 
    305314            return 0; 
    306315        } 
     
    315324            xmlFreeDoc( doc ); 
    316325            xmlCleanupParser(); 
     326            free(result); 
    317327            return 0; 
    318328        } 
     
    327337            xmlFreeDoc( doc ); 
    328338            xmlCleanupParser(); 
     339            free(result); 
    329340            return 0; 
    330341        } 
     
    338349            xmlFreeDoc( doc ); 
    339350            xmlCleanupParser(); 
     351            free(result); 
    340352            return false; 
    341353        } 
     
    345357            xmlFreeDoc( doc ); 
    346358            xmlCleanupParser(); 
    347             return 0; 
    348         } 
     359            free(result); 
     360            return 0; 
     361        } 
     362         
     363        free(result); 
    349364    } 
    350365 
  • branches/libfreebob-2.0/src/freebob.cpp

    r233 r242  
    5454{ 
    5555    delete DebugModuleManager::instance(); 
     56 
    5657} 
    5758#ifdef __cplusplus 
  • branches/libfreebob-2.0/src/libfreebobavc/avc_generic.cpp

    r185 r242  
    5050              getSubunitType(), getSubunitId() ); 
    5151    se.write( m_subunit, buf ); 
     52    free(buf); 
    5253    se.write( m_opcode, "AVCCommand opcode" ); 
    5354    return true; 
  • branches/libfreebob-2.0/src/libfreebobavc/ieee1394service.cpp

    r185 r242  
    3737Ieee1394Service::~Ieee1394Service() 
    3838{ 
     39    if (m_handle) { 
     40        raw1394_destroy_handle(m_handle); 
     41    } 
    3942} 
    4043 
  • branches/libfreebob-2.0/src/libstreaming/AmdtpStreamProcessor.cpp

    r235 r242  
    718718                      unsigned char channel, unsigned char tag, unsigned char sy,  
    719719                          unsigned int cycle, unsigned int dropped) { 
    720  
     720     
    721721        enum raw1394_iso_disposition retval=RAW1394_ISO_OK; 
    722722         
     
    724724        assert(packet); 
    725725         
     726        // how are we going to get this right??? 
     727        m_running=true; 
     728         
    726729        if((packet->fmt == 0x10) && (packet->fdf != 0xFF) && (packet->dbs>0) && (length>=2*sizeof(quadlet_t))) { 
    727730                unsigned int nevents=((length / sizeof (quadlet_t)) - 2)/packet->dbs; 
    728731                 
    729732                // signal that we're running 
    730               if(nevents) m_running=true; 
     733//            if(nevents) m_running=true; 
    731734                 
    732735                // don't process the stream when it is not enabled. 
     
    734737                        return (int)RAW1394_ISO_OK; 
    735738                } 
    736                  
    737739                 
    738740                unsigned int write_size=nevents*sizeof(quadlet_t)*m_dimension; 
  • branches/libfreebob-2.0/src/libstreaming/freebob_streaming.cpp

    r235 r242  
    117117 
    118118        // discover the devices on the bus 
    119         if(!dev->m_deviceManager->discover(DEBUG_LEVEL_NORMAL)) { 
     119        if(!dev->m_deviceManager->discover(DEBUG_LEVEL_VERBOSE)) { 
    120120                debugOutput(DEBUG_LEVEL_VERBOSE, "Could not discover devices\n"); 
    121121                return 0; 
     
    134134                for(j=0; j<device->getStreamCount();j++) { 
    135135                        StreamProcessor *streamproc=device->getStreamProcessorByIndex(j); 
    136  
    137136                        debugOutput(DEBUG_LEVEL_VERBOSE, "Registering stream processor %d of device %d with processormanager\n",j,i); 
    138137                        if (!dev->processorManager->registerProcessor(streamproc)) { 
  • branches/libfreebob-2.0/src/Makefile.am

    r222 r242  
    3030        fbtypes.h                                       \ 
    3131        bebob_light/bebob_light_avdevice.h              \ 
    32         bebob_light/bebob_light_avdevicesubunit.h        
     32        bebob_light/bebob_light_avdevicesubunit.h       \ 
    3333        bebob_light/bebob_light_avplug.h                \ 
     34        bounce/bounce_avdevice.h                         
    3435#       bebob/bebob_avdevice.h                          \ 
    3536#       bebob/bebob_avdevice_subunit.h                  \ 
    3637#       bebob/bebob_avplug.h                            \ 
    3738#       bebob/bebob_functionblock.h                     \ 
    38 #       bounce/bounce_avdevice.h                        \ 
    3939#       motu/motu_avdevice.h                             
    4040 
     
    4747        bebob_light/bebob_light_avdevice.cpp            \ 
    4848        bebob_light/bebob_light_avdevicesubunit.cpp     \ 
    49         bebob_light/bebob_light_avplug.cpp               
     49        bebob_light/bebob_light_avplug.cpp              \ 
     50        bounce/bounce_avdevice.cpp                       
    5051#       bebob/bebob_avdevice.cpp                        \ 
    5152#       bebob/bebob_avdevice_xml.cpp                    \ 
     
    5455#       bebob/bebob_avplug_xml.cpp                      \ 
    5556#       bebob/bebob_functionblock.cpp                   \ 
    56 #       bounce/bounce_avdevice.cpp                      \ 
    5757#       motu/motu_avdevice.cpp 
    5858