Changeset 204

Show
Ignore:
Timestamp:
05/19/06 11:16:51 (16 years ago)
Author:
pieterpalmers
Message:

- ISO streaming infrastructure starts to look good
- client side infrastructure unexistant

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • branches/libfreebob-2.0/src/libstreaming/FreebobPosixThread.cpp

    r203 r204  
    5252    } 
    5353 
    54     debugPrint(DEBUG_LEVEL_THREADS, "ThreadHandler: start\n"); 
     54    debugOutput( DEBUG_LEVEL_VERBOSE, "ThreadHandler: start\n"); 
    5555 
    5656    // If Init succeed start the thread loop 
     
    6161    } 
    6262 
    63     debugPrint(DEBUG_LEVEL_THREADS, "ThreadHandler: exit\n"); 
     63    debugOutput( DEBUG_LEVEL_VERBOSE, "ThreadHandler: exit\n"); 
    6464    return 0; 
    6565} 
     
    7272    if (fRealTime) { 
    7373 
    74         debugPrint(DEBUG_LEVEL_THREADS, "Create RT thread\n"); 
     74        debugOutput( DEBUG_LEVEL_VERBOSE, "Create RT thread\n"); 
    7575 
    7676        /* Get the client thread to run as an RT-FIFO 
     
    108108        return 0; 
    109109    } else { 
    110         debugPrint(DEBUG_LEVEL_THREADS, "Create non RT thread\n"); 
     110        debugOutput( DEBUG_LEVEL_VERBOSE, "Create non RT thread\n"); 
    111111 
    112112        if ((res = pthread_create(&fThread, 0, ThreadHandler, this))) { 
     
    121121{ 
    122122    if (fThread) { // If thread has been started 
    123         debugPrint(DEBUG_LEVEL_THREADS, "FreebobPosixThread::Kill\n"); 
     123        debugOutput( DEBUG_LEVEL_VERBOSE, "FreebobPosixThread::Kill\n"); 
    124124        void* status; 
    125125        pthread_cancel(fThread); 
     
    134134{ 
    135135    if (fThread) { // If thread has been started 
    136                 debugPrint(DEBUG_LEVEL_THREADS, "FreebobPosixThread::Stop\n"); 
     136                debugOutput( DEBUG_LEVEL_VERBOSE, "FreebobPosixThread::Stop\n"); 
    137137                void* status; 
    138138        fRunning = false; // Request for the thread to stop 
  • branches/libfreebob-2.0/src/libstreaming/IsoHandler.cpp

    r201 r204  
    9494}; 
    9595 
     96void IsoHandler::dumpInfo() 
     97{ 
     98        debugOutput( DEBUG_LEVEL_NORMAL, "  Stream type  : %s\n", 
     99             (this->getType()==EHT_Receive ? "Receive" : "Transmit")); 
     100        debugOutput( DEBUG_LEVEL_NORMAL, "  Packet count : %d\n",this->getPacketCount()); 
     101 
     102}; 
     103 
    96104/* Child class implementations */ 
    97105 
    98106IsoRecvHandler::IsoRecvHandler(int port) 
    99                 : IsoHandler(port), m_Client(0) 
     107                : IsoHandler(port) 
    100108{ 
    101109        debugOutput( DEBUG_LEVEL_VERBOSE, "enter...\n"); 
     
    111119{ 
    112120        raw1394_iso_shutdown(m_handle); 
     121        raw1394_destroy_handle(m_handle); 
    113122 
    114123} 
     
    195204 
    196205IsoXmitHandler::IsoXmitHandler(int port) 
    197                 : IsoHandler(port), m_Client(0), m_prebuffers(0) 
     206                : IsoHandler(port), m_prebuffers(0) 
    198207{ 
    199208        debugOutput( DEBUG_LEVEL_VERBOSE, "enter...\n"); 
     
    203212                               unsigned int max_packet_size, int irq) 
    204213                : IsoHandler(port, buf_packets, max_packet_size,irq), 
    205                   m_Client(0), m_speed(RAW1394_ISO_SPEED_400), m_prebuffers(0) 
     214                  m_speed(RAW1394_ISO_SPEED_400), m_prebuffers(0) 
    206215{ 
    207216        debugOutput( DEBUG_LEVEL_VERBOSE, "enter...\n"); 
     
    212221                               enum raw1394_iso_speed speed) 
    213222                : IsoHandler(port, buf_packets,max_packet_size,irq), 
    214                   m_Client(0), m_speed(speed), m_prebuffers(0) 
     223                  m_speed(speed), m_prebuffers(0) 
    215224{ 
    216225        debugOutput( DEBUG_LEVEL_VERBOSE, "enter...\n"); 
     
    222231        debugOutput( DEBUG_LEVEL_VERBOSE, "enter...\n"); 
    223232        raw1394_iso_shutdown(m_handle); 
    224  
     233        raw1394_destroy_handle(m_handle); 
    225234} 
    226235 
     
    279288        debugOutput( DEBUG_LEVEL_VERBOSE, "enter...\n"); 
    280289 
    281         if (m_Client) return -1; 
     290        if (m_Client) {  
     291                debugFatal("Already a registered client\n"); 
     292                return -1; 
     293        } 
    282294 
    283295        m_Client=stream; 
  • branches/libfreebob-2.0/src/libstreaming/IsoHandler.h

    r201 r204  
    6262                IsoHandler(int port)  
    6363                   : m_handle(0), m_port(port),  
    64                    m_buf_packets(400), m_max_packet_size(1024), m_irq_interval(-1), m_packetcount(0) 
     64                   m_buf_packets(400), m_max_packet_size(1024), m_irq_interval(-1), m_packetcount(0), m_Client(0) 
    6565                {} 
    6666 
     
    6868                   : m_handle(0), m_port(port),  
    6969                   m_buf_packets(buf_packets), m_max_packet_size( max_packet_size), m_irq_interval(irq), 
    70                    m_packetcount(0) 
     70                   m_packetcount(0), m_Client(0) 
    7171                {} 
    7272 
     
    7575 
    7676            bool initialize(); 
    77                 int iterate() { if(m_handle) return raw1394_loop_iterate(m_handle); }; 
     77                int iterate() { if(m_handle) return raw1394_loop_iterate(m_handle); else return -1; }; 
    7878                 
    7979                void setVerboseLevel(int l) { setDebugLevel( l ); }; 
     
    9292                void stop(); 
    9393                int getFileDescriptor() { return raw1394_get_fd(m_handle);}; 
     94 
     95                void dumpInfo(); 
     96 
     97                bool inUse() {return (m_Client !=0) ;}; 
     98                virtual bool isStreamRegistered(IsoStream *s) {return (m_Client == s);}; 
     99 
     100                virtual int registerStream(IsoStream *) = 0; 
     101                virtual int unregisterStream(IsoStream *) = 0; 
    94102 
    95103        protected: 
     
    101109 
    102110                int m_packetcount; 
     111 
     112                IsoStream *m_Client; 
    103113 
    104114    DECLARE_DEBUG_MODULE; 
     
    175185 
    176186        private: 
    177                 IsoStream *m_Client; 
    178187 
    179188                static enum raw1394_iso_disposition iso_transmit_handler(raw1394handle_t handle, 
  • branches/libfreebob-2.0/src/libstreaming/IsoHandlerManager.cpp

    r203 r204  
    2929#include "IsoHandlerManager.h" 
    3030#include "IsoHandler.h" 
     31#include "IsoStream.h" 
    3132 
    3233namespace FreebobStreaming 
     
    3637 
    3738IsoHandlerManager::IsoHandlerManager() : 
    38    m_poll_timeout(-1
     39   m_poll_timeout(100), m_poll_fds(0), m_poll_nfds(0
    3940{ 
    4041 
     
    4950bool IsoHandlerManager::Init() 
    5051{ 
    51         // prepare the fd map 
     52        debugOutput( DEBUG_LEVEL_VERBOSE, "enter...\n"); 
    5253 
    5354        return true; 
     
    5960        int err; 
    6061        int i=0; 
     62        debugOutput( DEBUG_LEVEL_VERY_VERBOSE, "enter...\n"); 
    6163 
    6264        err = poll (m_poll_fds, m_poll_nfds, m_poll_timeout); 
     
    8082                 
    8183                if(m_poll_fds[i].revents & (POLLIN)) { 
    82  
     84                        IsoHandler *s=m_IsoHandlers.at(i); 
     85                        assert(s); 
     86                        s->iterate(); 
    8387                } 
    8488        } 
     
    8993int IsoHandlerManager::registerHandler(IsoHandler *handler) 
    9094{ 
     95        debugOutput( DEBUG_LEVEL_VERBOSE, "enter...\n"); 
    9196        assert(handler); 
    92         IsoRecvHandler *hrx; 
    93         IsoXmitHandler *htx; 
    94  
    95         hrx=dynamic_cast<IsoRecvHandler *>(handler); 
    96  
    97         if (hrx) { 
    98                 m_IsoRecvHandlers.push_back(hrx); 
    99                 return 0; 
     97        m_IsoHandlers.push_back(handler); 
     98 
     99        // rebuild the fd map for poll()'ing. 
     100        return rebuildFdMap();   
     101 
     102
     103 
     104int IsoHandlerManager::unregisterHandler(IsoHandler *handler) 
     105
     106        debugOutput( DEBUG_LEVEL_VERBOSE, "enter...\n"); 
     107        assert(handler); 
     108 
     109    for ( IsoHandlerVectorIterator it = m_IsoHandlers.begin(); 
     110          it != m_IsoHandlers.end(); 
     111          ++it ) 
     112    { 
     113        if ( *it == handler ) { 
     114                        // erase the iso handler from the list 
     115            m_IsoHandlers.erase(it); 
     116 
     117                        // rebuild the fd map for poll()'ing. 
     118                        return rebuildFdMap(); 
     119        } 
     120    } 
     121 
     122        return -1; //not found 
     123 
     124
     125 
     126int IsoHandlerManager::rebuildFdMap() { 
     127        debugOutput( DEBUG_LEVEL_VERBOSE, "enter...\n"); 
     128        int i=0; 
     129 
     130        m_poll_nfds=0; 
     131        if(m_poll_fds) free(m_poll_fds); 
     132 
     133        // count the number of handlers 
     134        m_poll_nfds=m_IsoHandlers.size(); 
     135 
     136        // allocate the fd array 
     137        m_poll_fds   = (struct pollfd *) calloc (m_poll_nfds, sizeof (struct pollfd)); 
     138        if(!m_poll_fds) { 
     139                debugFatal("Could not allocate memory for poll FD array\n"); 
     140                return -1; 
     141        } 
     142 
     143        // fill the fd map 
     144    for ( IsoHandlerVectorIterator it = m_IsoHandlers.begin(); 
     145          it != m_IsoHandlers.end(); 
     146          ++it ) 
     147    { 
     148                m_poll_fds[i].fd=(*it)->getFileDescriptor(); 
     149                m_poll_fds[i].events = POLLIN; 
     150                i++; 
     151    } 
     152 
     153        return 0; 
     154
     155 
     156 
     157// FIXME: currently there is a one-to-one mapping 
     158//        between streams and handlers, this is not ok for  
     159//        multichannel receive 
     160int IsoHandlerManager::registerStream(IsoStream *stream) 
     161
     162        debugOutput( DEBUG_LEVEL_VERBOSE, "enter...\n"); 
     163        assert(stream); 
     164 
     165        // make sure the stream isn't already attached to a handler 
     166    for ( IsoHandlerVectorIterator it = m_IsoHandlers.begin(); 
     167          it != m_IsoHandlers.end(); 
     168          ++it ) 
     169    { 
     170                if((*it)->isStreamRegistered(stream)) { 
     171                        (*it)->unregisterStream(stream); 
     172                } 
     173    } 
     174 
     175        // clean up all handlers that aren't used 
     176        pruneHandlers(); 
     177 
     178        // allocate a handler for this stream 
     179        if (stream->getType()==IsoStream::EST_Receive) { 
     180                IsoRecvHandler *h = new IsoRecvHandler(stream->getPort()); 
     181                if(!h) { 
     182                        debugFatal("Could not create IsoRecvHandler\n"); 
     183                        return -1; 
     184                } 
     185 
     186                h->setVerboseLevel(getDebugLevel()); 
     187 
     188                // init the handler 
     189                if(!h->initialize()) { 
     190                        debugFatal("Could not initialize receive handler\n"); 
     191                        return -1; 
     192                } 
     193 
     194                // register the stream with the handler 
     195                if(h->registerStream(stream)) { 
     196                        debugFatal("Could not register receive stream with handler\n"); 
     197                        return -1; 
     198                } 
     199 
     200                // register the handler with the manager 
     201                if(this->registerHandler(h)) { 
     202                        debugFatal("Could not register receive handler with manager\n"); 
     203                        return -1; 
     204                } 
    100205        } 
    101206         
    102         htx=dynamic_cast<IsoXmitHandler *>(handler); 
    103  
    104         if (htx) { 
    105                 m_IsoXmitHandlers.push_back(htx); 
    106                 return 0; 
    107         } 
    108  
    109         return -1; 
    110  
    111 
    112  
    113 int IsoHandlerManager::unregisterHandler(IsoHandler *handler) 
    114 
    115         assert(handler); 
    116  
    117     for ( IsoRecvHandlerVectorIterator it = m_IsoRecvHandlers.begin(); 
    118           it != m_IsoRecvHandlers.end(); 
    119           ++it ) 
    120     { 
    121                 // FIXME: how do I compare these two pointers? 
    122         IsoHandler* s = dynamic_cast<IsoHandler *>(*it); 
    123         if ( s == handler ) {  
    124             m_IsoRecvHandlers.erase(it); 
     207        if (stream->getType()==IsoStream::EST_Transmit) { 
     208                IsoXmitHandler *h = new IsoXmitHandler(stream->getPort()); 
     209                if(!h) { 
     210                        debugFatal("Could not create IsoXmitHandler\n"); 
     211                        return -1; 
     212                } 
     213 
     214                h->setVerboseLevel(getDebugLevel()); 
     215 
     216                // init the handler 
     217                if(!h->initialize()) { 
     218                        debugFatal("Could not initialize transmit handler\n"); 
     219                        return -1; 
     220                } 
     221 
     222                // register the stream with the handler 
     223                if(h->registerStream(stream)) { 
     224                        debugFatal("Could not register transmit stream with handler\n"); 
     225                        return -1; 
     226                } 
     227 
     228                // register the handler with the manager 
     229                if(this->registerHandler(h)) { 
     230                        debugFatal("Could not register transmit handler with manager\n"); 
     231                        return -1; 
     232                } 
     233 
     234        } 
     235 
     236        m_IsoStreams.push_back(stream); 
     237 
     238        return 0; 
     239
     240 
     241int IsoHandlerManager::unregisterStream(IsoStream *stream) 
     242
     243        debugOutput( DEBUG_LEVEL_VERBOSE, "enter...\n"); 
     244        assert(stream); 
     245 
     246        // make sure the stream isn't attached to a handler anymore 
     247    for ( IsoHandlerVectorIterator it = m_IsoHandlers.begin(); 
     248          it != m_IsoHandlers.end(); 
     249          ++it ) 
     250    { 
     251                if((*it)->isStreamRegistered(stream)) { 
     252                        (*it)->unregisterStream(stream); 
     253                } 
     254    } 
     255 
     256        // clean up all handlers that aren't used 
     257        pruneHandlers(); 
     258 
     259        // remove the stream from the registered streams list 
     260    for ( IsoStreamVectorIterator it = m_IsoStreams.begin(); 
     261          it != m_IsoStreams.end(); 
     262          ++it ) 
     263    { 
     264        if ( *it == stream ) {  
     265            m_IsoStreams.erase(it); 
    125266                        return 0; 
    126267        } 
    127268    } 
    128269 
    129     for ( IsoXmitHandlerVectorIterator it = m_IsoXmitHandlers.begin(); 
    130           it != m_IsoXmitHandlers.end(); 
    131           ++it ) 
    132     { 
    133                 // FIXME: how do I compare these two pointers? 
    134         IsoHandler* s = dynamic_cast<IsoHandler *>(*it); 
    135         if ( s == handler ) {  
    136             m_IsoXmitHandlers.erase(it); 
    137                         return 0; 
    138         } 
    139     } 
    140  
    141270        return -1; //not found 
    142271 
    143272} 
    144273 
    145  
    146 
     274void IsoHandlerManager::pruneHandlers() { 
     275        debugOutput( DEBUG_LEVEL_VERBOSE, "enter...\n"); 
     276        IsoHandlerVector toUnregister; 
     277 
     278        // find all handlers that are not in use 
     279    for ( IsoHandlerVectorIterator it = m_IsoHandlers.begin(); 
     280          it != m_IsoHandlers.end(); 
     281          ++it ) 
     282    { 
     283                if(!((*it)->inUse())) { 
     284                        toUnregister.push_back(*it); 
     285                } 
     286    } 
     287        // delete them 
     288    for ( IsoHandlerVectorIterator it = toUnregister.begin(); 
     289          it != toUnregister.end(); 
     290          ++it ) 
     291    { 
     292                unregisterHandler(*it); 
     293    } 
     294 
     295
     296 
     297int IsoHandlerManager::startHandlers() { 
     298        return startHandlers(-1); 
     299
     300 
     301int IsoHandlerManager::startHandlers(int cycle) { 
     302        debugOutput( DEBUG_LEVEL_VERBOSE, "enter...\n"); 
     303 
     304    for ( IsoHandlerVectorIterator it = m_IsoHandlers.begin(); 
     305          it != m_IsoHandlers.end(); 
     306          ++it ) 
     307    { 
     308                (*it)->start(cycle); 
     309    } 
     310        return 0; 
     311
     312 
     313void IsoHandlerManager::stopHandlers() { 
     314        debugOutput( DEBUG_LEVEL_VERBOSE, "enter...\n"); 
     315 
     316    for ( IsoHandlerVectorIterator it = m_IsoHandlers.begin(); 
     317          it != m_IsoHandlers.end(); 
     318          ++it ) 
     319    { 
     320                (*it)->stop(); 
     321    } 
     322 
     323
     324 
     325 
     326void IsoHandlerManager::dumpInfo() { 
     327        debugOutput( DEBUG_LEVEL_NORMAL, "Dumping IsoHandlerManager Stream handler information...\n"); 
     328        int i=0; 
     329 
     330        // fill the fd map 
     331    for ( IsoHandlerVectorIterator it = m_IsoHandlers.begin(); 
     332          it != m_IsoHandlers.end(); 
     333          ++it ) 
     334    { 
     335                debugOutput( DEBUG_LEVEL_NORMAL, " Stream %d\n",i++); 
     336 
     337                (*it)->dumpInfo(); 
     338    } 
     339 
     340
     341 
     342} // end of namespace FreebobStreaming 
     343 
  • branches/libfreebob-2.0/src/libstreaming/IsoHandlerManager.h

    r203 r204  
    4848 
    4949class IsoHandler; 
    50 class IsoXmitHandler; 
    51 class IsoRecvHandler; 
     50class IsoStream; 
    5251 
    53 typedef std::vector<IsoXmitHandler *> IsoXmitHandlerVector; 
    54 typedef std::vector<IsoXmitHandler *>::iterator IsoXmitHandlerVectorIterator; 
    55 typedef std::vector<IsoRecvHandler *> IsoRecvHandlerVector; 
    56 typedef std::vector<IsoRecvHandler *>::iterator IsoRecvHandlerVectorIterator; 
     52typedef std::vector<IsoHandler *> IsoHandlerVector; 
     53typedef std::vector<IsoHandler *>::iterator IsoHandlerVectorIterator; 
     54 
     55typedef std::vector<IsoStream *> IsoStreamVector; 
     56typedef std::vector<IsoStream *>::iterator IsoStreamVectorIterator; 
    5757 
    5858 
     
    6666        virtual ~IsoHandlerManager(); 
    6767 
    68                 int registerHandler(IsoHandler *); 
    69                 int unregisterHandler(IsoHandler *); 
    70  
    7168                void setPollTimeout(int t) {m_poll_timeout=t;}; 
    7269                int getPollTimeout() {return m_poll_timeout;}; 
     70 
     71                void setVerboseLevel(int l) { setDebugLevel( l ); }; 
     72 
     73                void dumpInfo(); 
     74 
     75                int registerStream(IsoStream *); 
     76                int unregisterStream(IsoStream *); 
     77 
     78                int startHandlers(); 
     79                int startHandlers(int cycle); 
     80                void stopHandlers(); 
    7381 
    7482        protected: 
     
    7785                bool Init(); 
    7886 
    79                 IsoXmitHandlerVector m_IsoXmitHandlers; 
    80                 IsoRecvHandlerVector m_IsoRecvHandlers; 
     87                // note: there is a disctinction between streams and handlers 
     88                // because one handler can serve multiple streams (in case of  
     89                // multichannel receive) 
    8190 
     91                // only streams are allowed to be registered externally. 
     92                // we allocate a handler if we need one, otherwise the stream 
     93                // is assigned to another handler 
     94 
     95                // the collection of handlers 
     96                IsoHandlerVector m_IsoHandlers; 
     97 
     98                int registerHandler(IsoHandler *); 
     99                int unregisterHandler(IsoHandler *); 
     100                void pruneHandlers(); 
     101 
     102                // the collection of streams 
     103                IsoStreamVector m_IsoStreams; 
     104 
     105                // poll stuff 
    82106                int m_poll_timeout; 
    83                 int                  m_poll_nfds; 
    84                 struct pollfd        *m_poll_fds; 
     107                struct pollfd *m_poll_fds; 
     108                int m_poll_nfds; 
     109 
     110                int rebuildFdMap(); 
     111 
    85112 
    86113            DECLARE_DEBUG_MODULE; 
  • branches/libfreebob-2.0/src/libstreaming/IsoStream.cpp

    r201 r204  
    121121 
    122122int IsoStreamBuffered::getBufferFillPackets() { 
     123        debugOutput( DEBUG_LEVEL_VERBOSE, "enter...\n"); 
    123124 
    124125        if(buffer) return buffer->getBufferFillPackets(); 
     
    127128} 
    128129int IsoStreamBuffered::getBufferFillPayload() { 
     130        debugOutput( DEBUG_LEVEL_VERBOSE, "enter...\n"); 
    129131 
    130132        if(buffer) return buffer->getBufferFillPayload(); 
  • branches/libfreebob-2.0/src/libstreaming/IsoStream.h

    r203 r204  
    5151                }; 
    5252 
    53         IsoStream(enum EStreamType type, int channel) : m_type(type), m_Channel(channel) 
     53        IsoStream(enum EStreamType type, int channel) : m_type(type), m_channel(channel), m_port(0) 
     54        {}; 
     55        IsoStream(enum EStreamType type, int channel, int port) : m_type(type), m_channel(channel), m_port(port) 
    5456        {}; 
    5557        virtual ~IsoStream() 
     
    5860                virtual void setVerboseLevel(int l) { setDebugLevel( l ); }; 
    5961 
    60                 int getChannel() {return m_Channel;}; 
     62                int getChannel() {return m_channel;}; 
     63                int getPort() {return m_port;}; 
    6164 
    6265                enum EStreamType getType() { return m_type;}; 
     
    7578        protected: 
    7679                enum EStreamType m_type; 
    77                 int m_Channel; 
     80                int m_channel; 
     81                int m_port; 
    7882 
    7983                DECLARE_DEBUG_MODULE; 
  • branches/libfreebob-2.0/src/libstreaming/PortManager.cpp

    r203 r204  
    4343int PortManager::addPort(Port *port) 
    4444{ 
     45        debugOutput( DEBUG_LEVEL_VERBOSE, "enter...\n"); 
    4546        assert(port); 
    4647 
     
    5253int PortManager::deletePort(Port *port) 
    5354{ 
     55        debugOutput( DEBUG_LEVEL_VERBOSE, "enter...\n"); 
    5456        assert(port); 
    5557 
  • branches/libfreebob-2.0/src/libstreaming/StreamProcessorManager.cpp

    r203 r204  
    9494bool StreamProcessorManager::Init() 
    9595{ 
     96        debugOutput( DEBUG_LEVEL_VERBOSE, "enter...\n"); 
    9697        return true; 
    9798} 
     
    100101bool StreamProcessorManager::Execute() 
    101102{ 
     103        debugOutput( DEBUG_LEVEL_VERY_VERBOSE, "enter...\n"); 
     104        return true; 
    102105 
    103106} 
  • branches/libfreebob-2.0/src/libstreaming/StreamRunner.cpp

    r203 r204  
    4040 
    4141bool StreamRunner::Execute() { 
     42        debugOutput( DEBUG_LEVEL_VERY_VERBOSE, "enter...\n"); 
    4243        // note that this is called in we while(running) loop 
    4344         
     
    5152 
    5253bool StreamRunner::Init() { 
     54        debugOutput( DEBUG_LEVEL_VERBOSE, "enter...\n"); 
    5355        if(!m_isoManager) { 
    54                 debugFatal("Not a valid IsoHandlerManager"); 
     56                debugFatal("Not a valid IsoHandlerManager\n"); 
    5557                return false; 
    5658        } 
    5759        if(!m_processorManager) { 
    58                 debugFatal("Not a valid StreamProcessorManager"); 
     60                debugFatal("Not a valid StreamProcessorManager\n"); 
    5961                return false; 
    6062        } 
    6163 
    62         if(m_isoManager->Init()) { 
    63                 debugFatal("Could not init IsoHandlerManager"); 
     64        if(!m_isoManager->Init()) { 
     65                debugFatal("Could not init IsoHandlerManager\n"); 
    6466                return false; 
    6567        } 
    6668         
    67         if(m_processorManager->Init()) { 
    68                 debugFatal("Could not init StreamProcessorManager"); 
     69        if(!m_processorManager->Init()) { 
     70                debugFatal("Could not init StreamProcessorManager\n"); 
    6971                return false; 
    7072        }