Changeset 207

Show
Ignore:
Timestamp:
05/21/06 11:39:59 (16 years ago)
Author:
pieterpalmers
Message:

- temp commit

Files:

Legend:

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

    r206 r207  
    205205        } 
    206206 
     207        m_Client->setHandler(this); 
     208 
    207209        return 0; 
    208210 
     
    216218        if(stream != m_Client) return -1; //not registered 
    217219 
     220        m_Client->clearHandler(); 
    218221        m_Client=0; 
    219222        return 0; 
     
    344347        } 
    345348 
     349        m_Client->setHandler(this); 
     350 
    346351        return 0; 
    347352 
     
    355360        if(stream != m_Client) return -1; //not registered 
    356361 
     362        m_Client->clearHandler(); 
    357363        m_Client=0; 
    358364        return 0; 
  • branches/libfreebob-2.0/src/libstreaming/IsoHandler.h

    r206 r207  
    104104                virtual int registerStream(IsoStream *) = 0; 
    105105                virtual int unregisterStream(IsoStream *) = 0; 
     106 
     107                int getLocalNodeId() {return raw1394_get_local_id( m_handle );}; 
    106108 
    107109        protected: 
  • branches/libfreebob-2.0/src/libstreaming/IsoStream.cpp

    r206 r207  
    6363} 
    6464 
     65int IsoStream::getNodeId() { 
     66        if (m_handler) { 
     67                return m_handler->getLocalNodeId(); 
     68        } 
     69        return -1; 
     70} 
     71 
     72 
    6573void IsoStream::dumpInfo() 
    6674{ 
     
    7381}; 
    7482 
     83void IsoStream::reset() { 
     84 
     85} 
     86 
     87void IsoStream::prepare() { 
     88} 
     89 
     90int IsoStream::init() { 
     91        return 0; 
     92 
     93} 
     94 
    7595/* buffered variant of the ISO stream */ 
    7696IsoStreamBuffered::~IsoStreamBuffered() { 
     
    80100} 
    81101 
    82 int IsoStreamBuffered::initialize() { 
     102int IsoStreamBuffered::init() { 
    83103        debugOutput( DEBUG_LEVEL_VERBOSE, "enter...\n"); 
    84104        buffer=new PacketBuffer(m_headersize, m_buffersize, m_max_packetsize); 
  • branches/libfreebob-2.0/src/libstreaming/IsoStream.h

    r206 r207  
    3131#include <libraw1394/raw1394.h> 
    3232#include "../debugmodule/debugmodule.h" 
     33#include "IsoHandler.h" 
    3334 
    3435namespace FreebobStreaming 
     
    4344class IsoStream 
    4445{ 
     46        friend class IsoHandler; 
     47        friend class IsoRecvHandler; 
     48        friend class IsoXmitHandler; 
    4549 
    4650    public: 
     
    5155                }; 
    5256 
    53         IsoStream(enum EStreamType type, int channel) : m_type(type), m_channel(channel), m_port(0) 
     57        IsoStream(enum EStreamType type, int channel)  
     58                   : m_type(type), m_channel(channel), m_port(0), m_handler(0) 
    5459        {}; 
    55         IsoStream(enum EStreamType type, int channel, int port) : m_type(type), m_channel(channel), m_port(port) 
     60        IsoStream(enum EStreamType type, int channel, int port)  
     61                   : m_type(type), m_channel(channel), m_port(port), m_handler(0) 
    5662        {}; 
    5763        virtual ~IsoStream() 
     
    6571                enum EStreamType getType() { return m_type;}; 
    6672 
    67                 virtual int initialize() {return 0;}
     73                virtual int init()
    6874 
    6975                virtual int  
     
    7783 
    7884                void dumpInfo(); 
    79          
     85 
     86                int getNodeId(); 
     87                         
     88 
     89                void reset(); 
     90                void prepare();  
     91 
    8092        protected: 
     93 
     94                void setHandler( IsoHandler * h) {m_handler=h;}; 
     95                void clearHandler() {m_handler=0;}; 
     96 
    8197                enum EStreamType m_type; 
    8298                int m_channel; 
    8399                int m_port; 
     100 
     101                IsoHandler *m_handler; 
    84102 
    85103                DECLARE_DEBUG_MODULE; 
     
    99117                void setVerboseLevel(int l); 
    100118 
    101                 int initialize(); 
     119                int init(); 
    102120 
    103121                int  
  • branches/libfreebob-2.0/src/libstreaming/Makefile.am

    r203 r207  
    2020 
    2121libstreaming_la_SOURCES =       \ 
    22         messagebuffer.c messagebuffer.h
     22        messagebuffer.c messagebuffer.h cip.h cip.c
    2323        debug.h \ 
    2424        FreebobPosixThread.cpp  FreebobPosixThread.h \ 
     
    4444        StreamProcessorManager.cpp \ 
    4545        StreamProcessorManager.h \ 
     46        AmdtpPortInfo.cpp AmdtpPortInfo.h \ 
     47        AmdtpPort.cpp \ 
     48        AmdtpPort.h \ 
     49        AmdtpStreamProcessor.cpp \ 
     50        AmdtpStreamProcessor.h \ 
    4651        StreamRunner.cpp StreamRunner.h 
    4752 
  • branches/libfreebob-2.0/src/libstreaming/PortManager.cpp

    r206 r207  
    108108} 
    109109 
     110void PortManager::reset() { 
     111 
    110112} 
     113 
     114void PortManager::prepare() { 
     115} 
     116 
     117} 
  • branches/libfreebob-2.0/src/libstreaming/PortManager.h

    r206 r207  
    4949        virtual int deletePort(Port *port); 
    5050 
     51        void reset(); 
     52        void prepare();  
     53 
     54        void setVerboseLevel(int l) { setDebugLevel( l ); }; 
     55 
    5156protected: 
    5257        PortVector m_PacketPorts; 
  • branches/libfreebob-2.0/src/libstreaming/StreamProcessor.cpp

    r206 r207  
    2828 
    2929#include "StreamProcessor.h" 
     30#include "StreamProcessorManager.h" 
    3031 
    3132namespace FreebobStreaming { 
    3233 
    3334IMPL_DEBUG_MODULE( StreamProcessor, StreamProcessor, DEBUG_LEVEL_NORMAL ); 
    34 IMPL_DEBUG_MODULE( ReceiveStreamProcessor, ReceiveStreamProcessor, DEBUG_LEVEL_NORMAL ); 
    35 IMPL_DEBUG_MODULE( TransmitStreamProcessor, TransmitStreamProcessor, DEBUG_LEVEL_NORMAL ); 
     35// IMPL_DEBUG_MODULE( ReceiveStreamProcessor, ReceiveStreamProcessor, DEBUG_LEVEL_NORMAL ); 
     36// IMPL_DEBUG_MODULE( TransmitStreamProcessor, TransmitStreamProcessor, DEBUG_LEVEL_NORMAL ); 
    3637 
    37 StreamProcessor::StreamProcessor(enum IsoStream::EStreamType type, int channel, int port)  
    38         : IsoStream(type, channel, port)
     38StreamProcessor::StreamProcessor(enum IsoStream::EStreamType type, int channel, int port, int framerate)  
     39        : IsoStream(type, channel, port), m_framerate(framerate), m_manager(0)
    3940 
    4041} 
     
    6667 
    6768        debugOutputShort( DEBUG_LEVEL_NORMAL, " StreamProcessor information\n"); 
     69        debugOutputShort( DEBUG_LEVEL_NORMAL, "  Iso stream info:\n"); 
    6870         
    6971        ((IsoStream*)this)->dumpInfo(); 
     72        debugOutputShort( DEBUG_LEVEL_NORMAL, "  Frame counter  : %d\n", m_framecounter); 
     73        debugOutputShort( DEBUG_LEVEL_NORMAL, "  Xruns          : %d\n", m_xruns); 
     74         
    7075}; 
    7176 
     77int StreamProcessor::init() 
     78{ 
     79        debugOutput( DEBUG_LEVEL_VERY_VERBOSE, "enter...\n"); 
     80        if(!m_manager) { 
     81                debugFatal("Not attached to a manager!\n"); 
     82                return -1; 
     83        } 
    7284 
    73 ReceiveStreamProcessor::ReceiveStreamProcessor(int channel, int port)  
    74         : StreamProcessor(IsoStream::EST_Receive, channel, port) { 
     85        m_nb_buffers=m_manager->getNbBuffers(); 
     86        debugOutputShort( DEBUG_LEVEL_VERBOSE, "Setting m_nb_buffers  : %d\n", m_nb_buffers); 
     87 
     88        m_period=m_manager->getPeriodSize(); 
     89        debugOutputShort( DEBUG_LEVEL_VERBOSE, "Setting m_period      : %d\n", m_period); 
     90 
     91 
     92        return ((IsoStream *)this)->init(); 
     93
     94 
     95void StreamProcessor::reset() { 
     96 
     97        debugOutput( DEBUG_LEVEL_VERBOSE, "Resetting...\n"); 
     98 
     99        m_framecounter=0; 
     100 
     101        // loop over the ports to reset them 
     102        ((PortManager *)this)->reset(); 
     103 
     104        // reset the iso stream 
     105        ((IsoStream *)this)->reset(); 
     106 
     107
     108 
     109void StreamProcessor::prepare() { 
     110 
     111        debugOutput( DEBUG_LEVEL_VERBOSE, "Preparing...\n"); 
     112// TODO: implement 
     113        // loop over the ports to reset them 
     114        ((PortManager *)this)->prepare(); 
     115 
     116        // reset the iso stream 
     117        ((IsoStream *)this)->prepare(); 
     118 
     119
     120 
     121int StreamProcessor::transfer() { 
     122 
     123        debugOutput( DEBUG_LEVEL_VERY_VERBOSE, "Transferring period...\n"); 
     124// TODO: implement 
     125 
     126        return 0; 
     127
     128 
     129void StreamProcessor::setVerboseLevel(int l) { 
     130        setDebugLevel(l); 
     131        ((IsoStream *)this)->setVerboseLevel(l); 
     132        ((PortManager *)this)->setVerboseLevel(l); 
     133 
     134
     135 
     136 
     137ReceiveStreamProcessor::ReceiveStreamProcessor(int channel, int port, int framerate)  
     138        : StreamProcessor(IsoStream::EST_Receive, channel, port, framerate) { 
    75139 
    76140} 
     
    91155} 
    92156 
    93 void ReceiveStreamProcessor::reset() { 
    94  
    95         debugOutput( DEBUG_LEVEL_VERBOSE, "Resetting processors...\n"); 
    96          
    97         // reset the boundary counter 
    98         m_framecounter = 0; 
    99  
    100 
    101  
    102 int ReceiveStreamProcessor::transfer() { 
    103  
    104         debugOutput( DEBUG_LEVEL_VERY_VERBOSE, "Transferring period...\n"); 
    105 // TODO: implement 
    106  
    107         return 0; 
    108 
     157// void ReceiveStreamProcessor::setVerboseLevel(int l) { 
     158//      setDebugLevel(l); 
     159//  
     160// /*   StreamProcessor *parent; 
     161//      parent=dynamic_cast<StreamProcessor *>(this); 
     162//  
     163//      assert(parent); 
     164//  
     165//      parent->setVerboseLevel(l); 
     166//      ((StreamProcessor *)this)->setVerboseLevel(l); 
     167// */ 
     168// } 
    109169 
    110170 
    111 TransmitStreamProcessor::TransmitStreamProcessor(int channel, int port)  
    112         : StreamProcessor(IsoStream::EST_Transmit, channel, port) { 
     171TransmitStreamProcessor::TransmitStreamProcessor(int channel, int port, int framerate)  
     172        : StreamProcessor(IsoStream::EST_Transmit, channel, port, framerate) { 
    113173 
    114174} 
     
    121181                      unsigned char *tag, unsigned char *sy, 
    122182                      int cycle, unsigned int dropped, unsigned int max_length) { 
    123         memcpy(data,&cycle,sizeof(cycle)); 
    124         *length=sizeof(cycle); 
     183        *length=0; 
    125184        *tag = 1; 
    126185        *sy = 0; 
     
    128187        return 0; 
    129188} 
     189/* 
     190void TransmitStreamProcessor::setVerboseLevel(int l) { 
     191        setDebugLevel(l); 
     192        ((StreamProcessor *)this)->setVerboseLevel(l); 
    130193 
    131 void TransmitStreamProcessor::reset() { 
    132  
    133         debugOutput( DEBUG_LEVEL_VERBOSE, "Resetting processors...\n"); 
    134 // TODO: implement 
     194}*/ 
    135195 
    136196} 
    137  
    138 int TransmitStreamProcessor::transfer() { 
    139  
    140         debugOutput( DEBUG_LEVEL_VERY_VERBOSE, "Transferring period...\n"); 
    141 // TODO: implement 
    142  
    143         return 0; 
    144 } 
    145  
    146  
    147 } 
  • branches/libfreebob-2.0/src/libstreaming/StreamProcessor.h

    r206 r207  
    3636namespace FreebobStreaming { 
    3737 
     38class StreamProcessorManager; 
     39 
    3840class StreamProcessor : public IsoStream,  
    3941                        public PortManager { 
     42 
     43        friend class StreamProcessorManager; 
    4044 
    4145public: 
     
    4549        }; 
    4650 
    47         StreamProcessor(enum IsoStream::EStreamType type, int channel, int port); 
     51        StreamProcessor(enum IsoStream::EStreamType type, int channel, int port, int framerate); 
    4852        virtual ~StreamProcessor(); 
    4953 
    50         int  
     54        virtual int  
    5155                putPacket(unsigned char *data, unsigned int length,  
    5256                      unsigned char channel, unsigned char tag, unsigned char sy,  
    5357                          unsigned int cycle, unsigned int dropped); 
    54         int  
     58        virtual int  
    5559                getPacket(unsigned char *data, unsigned int *length, 
    5660                      unsigned char *tag, unsigned char *sy, 
     
    5963        virtual enum EProcessorType getType() =0; 
    6064 
    61         void setPeriodSize(unsigned int period); 
    62         void setPeriodSize(unsigned int period, unsigned int nb_buffers); 
    63         int getPeriodSize() {return m_period;}; 
    64  
    65         void setNbBuffers(unsigned int nb_buffers); 
    66         int getNbBuffers() {return m_nb_buffers;}; 
    67  
    6865        bool xrunOccurred() { return (m_xruns>0);}; 
    6966 
     
    7168        unsigned int getNbPeriodsReady() { if(m_period) return m_framecounter/m_period; else return 0;}; 
    7269 
    73         virtual int transfer() =0; // transfer the buffer contents from/to client 
     70        virtual int transfer(); // transfer the buffer contents from/to client 
    7471 
    75         virtual void reset() =0; // reset the streams & buffers (e.g. after xrun) 
     72        virtual void reset(); // reset the streams & buffers (e.g. after xrun) 
    7673 
    77         void dumpInfo(); 
     74        virtual void prepare(); // prepare the streams & buffers (e.g. prefill) 
     75 
     76        virtual void dumpInfo(); 
     77 
     78        virtual int init(); 
     79 
     80        void setVerboseLevel(int l); 
    7881 
    7982protected: 
    8083         
    81         unsigned int m_nb_buffers; 
    82         unsigned int m_period; 
     84 
     85        void setManager(StreamProcessorManager *manager) {m_manager=manager;}; 
     86        void clearManager() {m_manager=0;}; 
     87 
     88        unsigned int m_nb_buffers; // cached from manager->getNbBuffers() 
     89        unsigned int m_period; // cached from manager->getPeriod() 
    8390 
    8491        unsigned int m_xruns; 
    8592        unsigned int m_framecounter; 
    8693 
    87     DECLARE_DEBUG_MODULE; 
     94        unsigned int m_framerate; 
     95 
     96        StreamProcessorManager *m_manager; 
     97 
     98     DECLARE_DEBUG_MODULE; 
    8899 
    89100 
     
    93104 
    94105public: 
    95         ReceiveStreamProcessor(int channel, int port); 
     106        ReceiveStreamProcessor(int channel, int port, int framerate); 
    96107 
    97108        virtual ~ReceiveStreamProcessor(); 
     
    100111        virtual enum EProcessorType getType() {return E_Receive;}; 
    101112 
    102         int putPacket(unsigned char *data, unsigned int length,  
     113        virtual int putPacket(unsigned char *data, unsigned int length,  
    103114                      unsigned char channel, unsigned char tag, unsigned char sy,  
    104115                          unsigned int cycle, unsigned int dropped); 
    105  
    106         int transfer(); // transfer the buffer contents from/to client 
    107  
    108         void reset(); // reset the streams & buffers (e.g. after xrun) 
     116//      virtual void setVerboseLevel(int l); 
    109117 
    110118protected: 
    111119 
    112     DECLARE_DEBUG_MODULE; 
     120//     DECLARE_DEBUG_MODULE; 
    113121 
    114122 
     
    118126 
    119127public: 
    120         TransmitStreamProcessor(int channel, int port); 
     128        TransmitStreamProcessor(int channel, int port, int framerate); 
    121129 
    122130        virtual ~TransmitStreamProcessor(); 
     
    124132        virtual enum EProcessorType getType() {return E_Transmit;}; 
    125133 
    126         int  
     134        virtual int  
    127135                getPacket(unsigned char *data, unsigned int *length, 
    128136                      unsigned char *tag, unsigned char *sy, 
    129137                      int cycle, unsigned int dropped, unsigned int max_length); 
    130  
    131         int transfer(); // transfer the buffer contents from/to client 
    132  
    133         void reset(); // reset the streams & buffers (e.g. after xrun) 
     138//      virtual void setVerboseLevel(int l); 
    134139 
    135140protected: 
    136141 
    137     DECLARE_DEBUG_MODULE; 
     142//     DECLARE_DEBUG_MODULE; 
    138143 
    139144 
  • branches/libfreebob-2.0/src/libstreaming/StreamProcessorManager.cpp

    r206 r207  
    5151        if (processor->getType()==StreamProcessor::E_Receive) { 
    5252                m_ReceiveProcessors.push_back(processor); 
     53                processor->setManager(this); 
    5354                return 0; 
    5455        } 
     
    5657        if (processor->getType()==StreamProcessor::E_Transmit) { 
    5758                m_TransmitProcessors.push_back(processor); 
     59                processor->setManager(this); 
    5860                return 0; 
    5961        } 
     
    7577                        if ( *it == processor ) {  
    7678                                        m_ReceiveProcessors.erase(it); 
     79                                        processor->clearManager(); 
    7780                                        return 0; 
    7881                                } 
     
    8790                        if ( *it == processor ) {  
    8891                                        m_TransmitProcessors.erase(it); 
     92                                        processor->clearManager(); 
    8993                                        return 0; 
    9094                                } 
     
    106110                debugOutput( DEBUG_LEVEL_VERBOSE,"FREEBOB: successfull init of packet transfer semaphore\n"); 
    107111        } 
     112 
     113//      debugOutputShort( DEBUG_LEVEL_VERY_VERBOSE, " Receive processors...\n"); 
     114        for ( StreamProcessorVectorIterator it = m_ReceiveProcessors.begin(); 
     115                it != m_ReceiveProcessors.end(); 
     116                ++it ) { 
     117                if((*it)->init()) { 
     118                        debugFatal("Could not initialize receive processor\n"); 
     119                        return false; 
     120                } 
     121        } 
     122 
     123//      debugOutputShort( DEBUG_LEVEL_VERY_VERBOSE, " Transmit processors...\n"); 
     124        for ( StreamProcessorVectorIterator it = m_TransmitProcessors.begin(); 
     125                it != m_TransmitProcessors.end(); 
     126                ++it ) { 
     127                if((*it)->init()) { 
     128                        debugFatal("Could not initialize receive processor\n"); 
     129                        return false; 
     130                } 
     131        } 
     132 
    108133        return true; 
    109134} 
     
    236261} 
    237262 
     263void StreamProcessorManager::setVerboseLevel(int l) { 
     264        setDebugLevel(l); 
     265 
     266        debugOutputShort( DEBUG_LEVEL_NORMAL, " Receive processors...\n"); 
     267        for ( StreamProcessorVectorIterator it = m_ReceiveProcessors.begin(); 
     268                it != m_ReceiveProcessors.end(); 
     269                ++it ) { 
     270                (*it)->setVerboseLevel(l); 
     271        } 
     272 
     273        debugOutputShort( DEBUG_LEVEL_NORMAL, " Transmit processors...\n"); 
     274        for ( StreamProcessorVectorIterator it = m_TransmitProcessors.begin(); 
     275                it != m_TransmitProcessors.end(); 
     276                ++it ) { 
     277                (*it)->setVerboseLevel(l); 
     278        } 
     279} 
     280 
     281 
    238282} // end of namespace 
  • branches/libfreebob-2.0/src/libstreaming/StreamProcessorManager.h

    r206 r207  
    5555        int prepare(); // to be called after the processors are registered 
    5656 
    57         void setVerboseLevel(int l) { setDebugLevel( l ); }
     57        void setVerboseLevel(int l)
    5858        void dumpInfo(); 
    5959 
  • branches/libfreebob-2.0/tests/streaming/test-isohandling.cpp

    r206 r207  
    3232#include "IsoStream.h" 
    3333#include "StreamProcessorManager.h" 
    34 #include "StreamProcessor.h" 
     34#include "AmdtpStreamProcessor.h" 
    3535#include "IsoHandlerManager.h" 
    3636#include "StreamRunner.h" 
     
    5959        printf(" ISO handler tests\n"); 
    6060 
    61         IsoStream *xms = new IsoStream(IsoStream::EST_Transmit,2,2); 
    62         if(!xms) { 
    63                 printf("Could not create transmit IsoStream\n"); 
    64                 return -1; 
    65         } 
    66         xms->setVerboseLevel(DEBUG_LEVEL_VERBOSE); 
    67  
    68         IsoStream *rcs = new IsoStream(IsoStream::EST_Receive,0,2); 
    69         if(!rcs) { 
    70                 printf("Could not create receive IsoStream\n"); 
    71                 return -1; 
    72         } 
    73         rcs->setVerboseLevel(DEBUG_LEVEL_VERBOSE); 
    74  
    75         StreamProcessor *spt = new TransmitStreamProcessor(3,2); 
    76         if(!spt) { 
    77                 printf("Could not create transmit StreamProcessor\n"); 
    78                 return -1; 
    79         } 
    80         spt->setVerboseLevel(DEBUG_LEVEL_VERBOSE); 
    81  
    82         StreamProcessor *spr = new ReceiveStreamProcessor(1,2); 
    83         if(!spr) { 
    84                 printf("Could not create receive StreamProcessor\n"); 
    85                 return -1; 
    86         } 
    87         spr->setVerboseLevel(DEBUG_LEVEL_VERBOSE); 
    88  
    89         // now we have an xmit stream, attached to an xmit handler 
    90         // register it with the manager 
    91  
     61        // the first thing we need is a ISO handler manager 
    9262        IsoHandlerManager *isomanager = new IsoHandlerManager(); 
    9363        if(!isomanager) { 
     
    9868        isomanager->setVerboseLevel(DEBUG_LEVEL_VERBOSE); 
    9969        printf("----------------------\n"); 
    100         if (isomanager->registerStream(xms)) { 
    101                 printf("Could not register transmit handler with the manager\n"); 
     70 
     71        // also create a processor manager to manage the actual stream 
     72        // processors    
     73        StreamProcessorManager *procMan = new StreamProcessorManager(512,3); 
     74        if(!procMan) { 
     75                printf("Could not create StreamProcessorManager\n"); 
    10276                return -1; 
    10377        } 
    104         printf("----------------------\n"); 
     78        procMan->setVerboseLevel(DEBUG_LEVEL_VERBOSE); 
    10579 
    106         if (isomanager->registerStream(rcs)) { 
    107                 printf("Could not register receive handler with the manager\n"); 
     80        // now we can allocate the stream processors themselves 
     81 
     82//      StreamProcessor *spt = new AmdtpTransmitStreamProcessor(3,2,44100,10); 
     83//      if(!spt) { 
     84//              printf("Could not create transmit AmdtpTransmitStreamProcessor\n"); 
     85//              return -1; 
     86//      } 
     87//      spt->setVerboseLevel(DEBUG_LEVEL_VERBOSE); 
     88 
     89//      AmdtpReceiveStreamProcessor *spr = new AmdtpReceiveStreamProcessor(0,2,44100,7); 
     90        ReceiveStreamProcessor *spr = new ReceiveStreamProcessor(0,2,44100); 
     91        if(!spr) { 
     92                printf("Could not create receive AmdtpStreamProcessor\n"); 
    10893                return -1; 
    10994        } 
    110         printf("----------------------\n"); 
     95        spr->setVerboseLevel(DEBUG_LEVEL_VERBOSE); 
    11196 
    112         if (isomanager->registerStream(spt)) { 
    113                 printf("Could not register transmit stream processor with the ISO manager\n"); 
    114                 return -1; 
    115         } 
    116         printf("----------------------\n"); 
     97//      if (isomanager->registerStream(spt)) { 
     98//              printf("Could not register transmit stream processor with the ISO manager\n"); 
     99//              return -1; 
     100//      } 
     101//      printf("----------------------\n"); 
     102 
     103 
     104        // now we have an xmit stream,  
     105        // register it with the manager that assigns an iso handler 
    117106 
    118107        if (isomanager->registerStream(spr)) { 
     
    122111        printf("----------------------\n"); 
    123112 
    124         // also create a processor as a dummy for the stream runner 
    125          
    126         StreamProcessorManager *procMan = new StreamProcessorManager(512,3); 
    127         if(!procMan) { 
    128                 printf("Could not create StreamProcessor\n"); 
    129                 return -1; 
    130         } 
    131         procMan->setVerboseLevel(DEBUG_LEVEL_VERBOSE); 
    132113 
    133       printf("----------------------\n"); 
    134       if (procMan->registerProcessor(spt)) { 
    135               printf("Could not register transmit stream processor with the Processor manager\n"); 
    136               return -1; 
    137       } 
    138       printf("----------------------\n"); 
     114//    printf("----------------------\n"); 
     115//    if (procMan->registerProcessor(spt)) { 
     116//            printf("Could not register transmit stream processor with the Processor manager\n"); 
     117//            return -1; 
     118//    } 
     119//    printf("----------------------\n"); 
    139120 
     121        // also register it with the processor manager, so that it is aware of  
     122        // buffer sizes etc... 
    140123        if (procMan->registerProcessor(spr)) { 
    141124                printf("Could not register receive stream processor with the Processor manager\n"); 
     
    179162        isomanager->stopHandlers(); 
    180163 
    181         isomanager->unregisterStream(xms); 
    182         isomanager->unregisterStream(rcs); 
    183         isomanager->unregisterStream(spt); 
     164//      isomanager->unregisterStream(spt); 
    184165        isomanager->unregisterStream(spr); 
    185166 
    186       procMan->unregisterProcessor(spt); 
     167//    procMan->unregisterProcessor(spt); 
    187168        procMan->unregisterProcessor(spr); 
    188169 
     
    192173        delete isomanager; 
    193174 
    194         delete rcs; 
    195         delete xms; 
    196         delete spt; 
     175//      delete spt; 
    197176        delete spr; 
    198177