Changeset 230

Show
Ignore:
Timestamp:
05/28/06 10:40:49 (16 years ago)
Author:
pieterpalmers
Message:

- xrun handling now works

Files:

Legend:

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

    r227 r230  
    19121912 
    19131913} 
     1914 
    19141915int 
    19151916AvDevice::stopStreamByIndex(int i) { 
  • branches/libfreebob-2.0/src/libstreaming/AmdtpStreamProcessor.cpp

    r228 r230  
    119119                 
    120120                // signal underrun 
    121                 // FIXME: underrun signaling turned off!! 
    122121                m_xruns++; 
    123122 
     
    141140        // update the frame counter 
    142141        m_framecounter+=nevents; 
     142    if(m_framecounter>m_period) { 
     143       retval=RAW1394_ISO_DEFER; 
     144    } 
    143145 
    144146        return (int)retval; 
     
    153155        freebob_ringbuffer_reset(m_event_buffer); 
    154156         
     157        // we should prefill the event buffer 
     158        int i=m_nb_buffers; 
     159        while(i--) { 
     160                if(!transferSilence()) { 
     161                        debugFatal("Could not prefill transmit stream\n"); 
     162                        return false; 
     163                } 
     164        } 
     165         
    155166        // reset all non-device specific stuff 
    156167        // i.e. the iso stream and the associated ports 
    157         return TransmitStreamProcessor::reset(); 
     168        if(!TransmitStreamProcessor::reset()) { 
     169                debugFatal("Could not do base class reset\n"); 
     170                return false; 
     171        } 
     172        return true; 
    158173} 
    159174 
     
    318333 
    319334        // we should prefill the event buffer 
    320         // FIXME: i have to solve this otherwise because the ports aren't ready yet 
    321         // especially if there are no internal buffers=> segfault 
    322335        int i=m_nb_buffers; 
    323336        while(i--) { 
     
    399412                         
    400413                if(vec[0].len==0) { // this indicates a full event buffer 
    401                         debugError("Event buffer overrun in processor %d\n",this); 
     414                        debugError("XMT: Event buffer overrun in processor %p\n",this); 
    402415                        break; 
    403416                } 
     
    416429                        if(xrun<0) { 
    417430                                // xrun detected 
    418                                 debugError("Frame buffer underrun in processor %d\n",this); 
     431                                debugError("XMT: Frame buffer underrun in processor %p\n",this); 
    419432                                break; 
    420433                        } 
     
    444457                        if(xrun<0) { 
    445458                                        // xrun detected 
    446                                 debugError("Frame buffer underrun in processor %d\n",this); 
     459                                debugError("XMT: Frame buffer underrun in processor %p\n",this); 
    447460                                break; 
    448461                        } 
     
    720733                if (freebob_ringbuffer_write(m_event_buffer,(char *)(data+8),write_size) < write_size)  
    721734                { 
    722                         debugWarning("Buffer overrun!\n");  
     735                    debugWarning("Receive buffer overrun (cycle %d, FC=%d, PC=%d)\n",  
     736                             cycle, m_framecounter, m_handler->getPacketCount()); 
    723737                        m_xruns++; 
    724738 
     
    730744                        if (!decodePacketPorts((quadlet_t *)(data+8), nevents, packet->dbc)) { 
    731745                                debugWarning("Problem decoding Packet Ports\n"); 
     746                    retval=RAW1394_ISO_DEFER; 
    732747                        } 
    733748                } 
     
    745760                // update the frame counter 
    746761                m_framecounter+=nevents; 
     762                if(m_framecounter>m_period) { 
     763               retval=RAW1394_ISO_DEFER; 
     764                } 
    747765                 
    748766        } else { 
     
    770788        // reset all non-device specific stuff 
    771789        // i.e. the iso stream and the associated ports 
    772         return ReceiveStreamProcessor::reset(); 
     790        if(!ReceiveStreamProcessor::reset()) { 
     791                debugFatal("Could not do base class reset\n"); 
     792                return false; 
     793        } 
     794        return true; 
    773795} 
    774796 
     
    951973                         
    952974                if(vec[0].len==0) { // this indicates an empty event buffer 
    953                         debugError("Frame buffer underrun in processor %d\n",this); 
     975                        debugError("RCV: Event buffer underrun in processor %p\n",this); 
    954976                        break; 
    955977                } 
     
    969991                        if(xrun<0) { 
    970992                                // xrun detected 
    971                                 debugError("Frame buffer underrun in processor %d\n",this); 
     993                                debugError("RCV: Frame buffer overrun in processor %p\n",this); 
    972994                                break; 
    973995                        } 
     
    9891011                        if(xrun<0) { 
    9901012                                        // xrun detected 
    991                                 debugError("Frame buffer underrun in processor %d\n",this); 
     1013                                debugError("RCV: Frame buffer overrun in processor %p\n",this); 
    9921014                                break; 
    9931015                        } 
  • branches/libfreebob-2.0/src/libstreaming/FreebobPosixThread.cpp

    r210 r230  
    116116            return -1; 
    117117        } 
     118         
    118119        return 0; 
    119120    } 
  • branches/libfreebob-2.0/src/libstreaming/FreebobPosixThread.h

    r203 r230  
    7878        pthread_t GetThreadID(); 
    7979 
     80        void setVerboseLevel(int l) {setDebugLevel(l);}; 
    8081        protected: 
    8182 
  • branches/libfreebob-2.0/src/libstreaming/freebob_streaming.cpp

    r227 r230  
    229229int freebob_streaming_reset(freebob_device_t *dev) { 
    230230        debugOutput(DEBUG_LEVEL_VERBOSE,"------------- Reset -------------\n"); 
    231         /*  
    232          * Reset means: 
    233          * 1) Stopping the packetizer thread 
    234          * 2) Bringing all buffers & connections into a know state 
    235          *    - Clear all capture buffers 
    236          *    - Put nb_periods*period_size of null frames into the playback buffers 
    237          * 3) Restarting the packetizer thread 
    238          */ 
    239 //      dev->thread->Stop(); 
    240 //  
    241 //      dev->processorManager->stop(); 
    242 //       
     231 
    243232//      dev->processorManager->reset(); 
    244 //       
    245 //      dev->processorManager->start(); 
    246 //       
    247 //      dev->thread->Start(); 
    248233 
    249234        return 0; 
     
    251236 
    252237int freebob_streaming_wait(freebob_device_t *dev) { 
    253  
    254         static int periods=0; 
     238        static int periods=0; 
    255239        static int periods_print=0; 
     240        static int xruns=0; 
     241                 
    256242                periods++; 
    257243                if(periods>periods_print) { 
    258244                        debugOutput(DEBUG_LEVEL_VERBOSE, "\n"); 
    259245                        debugOutput(DEBUG_LEVEL_VERBOSE, "============================================\n"); 
     246                        debugOutput(DEBUG_LEVEL_VERBOSE, "Xruns: %d\n",xruns); 
     247                        debugOutput(DEBUG_LEVEL_VERBOSE, "============================================\n"); 
    260248                        dev->processorManager->dumpInfo(); 
    261                         debugOutput(DEBUG_LEVEL_VERBOSE, "--------------------------------------------\n"); 
    262                         quadlet_t *addr=(quadlet_t*)(dev->processorManager->getPortByIndex(0, Port::E_Capture)->getBufferAddress()); 
    263                         if (addr) hexDumpQuadlets(addr,10); 
    264                         debugOutput(DEBUG_LEVEL_VERBOSE, "============================================\n"); 
     249//                      debugOutput(DEBUG_LEVEL_VERBOSE, "--------------------------------------------\n"); 
     250/*                      quadlet_t *addr=(quadlet_t*)(dev->processorManager->getPortByIndex(0, Port::E_Capture)->getBufferAddress()); 
     251                        if (addr) hexDumpQuadlets(addr,10);*/ 
    265252                        debugOutput(DEBUG_LEVEL_VERBOSE, "\n"); 
    266253                        periods_print+=100; 
    267254                } 
    268         dev->processorManager->waitForPeriod(); 
    269         return dev->options.period_size; 
     255        if(dev->processorManager->waitForPeriod()) { 
     256                return dev->options.period_size; 
     257        } else { 
     258                debugWarning("XRUN detected\n"); 
     259                // do xrun recovery 
     260                 
     261                dev->processorManager->handleXrun(); 
     262                xruns++; 
     263                return -1; 
     264        } 
    270265} 
    271266 
  • branches/libfreebob-2.0/src/libstreaming/IsoHandlerManager.cpp

    r225 r230  
    194194bool IsoHandlerManager::registerStream(IsoStream *stream) 
    195195{ 
    196         debugOutput( DEBUG_LEVEL_VERBOSE, "enter...\n"); 
     196        debugOutput( DEBUG_LEVEL_VERBOSE, "Registering stream %p\n",stream); 
    197197        assert(stream); 
    198198 
     
    327327bool IsoHandlerManager::unregisterStream(IsoStream *stream) 
    328328{ 
    329         debugOutput( DEBUG_LEVEL_VERBOSE, "enter...\n"); 
     329        debugOutput( DEBUG_LEVEL_VERBOSE, "Unregistering stream %p\n",stream); 
    330330        assert(stream); 
    331331 
     
    420420                debugOutput( DEBUG_LEVEL_VERBOSE, " stopping handler (%p)\n",*it); 
    421421                if(!(*it)->stop()){ 
    422                         debugOutput( DEBUG_LEVEL_VERBOSE, " could not start handler (%p)\n",*it); 
     422                        debugOutput( DEBUG_LEVEL_VERBOSE, " could not stop handler (%p)\n",*it); 
    423423                        return false; 
    424424                } 
  • branches/libfreebob-2.0/src/libstreaming/IsoHandlerManager.h

    r225 r230  
    7979 
    8080                bool registerStream(IsoStream *); ///< register an iso stream with the manager 
    81                 bool unregisterStream(IsoStream *); ///< unregister an iso stream with the manager 
     81                bool unregisterStream(IsoStream *); ///< unregister an iso stream from the manager 
    8282 
    8383                bool startHandlers(); ///< start the managed ISO handlers  
  • branches/libfreebob-2.0/src/libstreaming/IsoStream.cpp

    r225 r230  
    107107 
    108108void IsoStream::setHandler(IsoHandler *h) { 
    109         debugOutput( DEBUG_LEVEL_VERBOSE, "setting hanlder of isostream %p to %p\n", this,h); 
     109        debugOutput( DEBUG_LEVEL_VERBOSE, "setting handler of isostream %p to %p\n", this,h); 
    110110        m_handler=h; 
    111111} 
    112112 
     113void IsoStream::clearHandler() { 
     114        debugOutput( DEBUG_LEVEL_VERBOSE, "clearing handler of isostream %p\n", this); 
     115 
     116    m_handler=0; 
     117 
     118}; 
    113119} 
  • branches/libfreebob-2.0/src/libstreaming/IsoStream.h

    r225 r230  
    9898 
    9999                void setHandler( IsoHandler * h) ; 
    100                 void clearHandler() {m_handler=0;}
     100                void clearHandler()
    101101 
    102102                enum EStreamType m_type; 
  • branches/libfreebob-2.0/src/libstreaming/Port.cpp

    r228 r230  
    111111} 
    112112 
     113bool Port::reset() { 
     114        if (m_BufferType==E_RingBuffer) { 
     115                freebob_ringbuffer_reset(m_ringbuffer); 
     116        } 
     117        return true; 
     118}; 
     119 
     120 
    113121void Port::setVerboseLevel(int l) { 
    114122        setDebugLevel(l); 
  • branches/libfreebob-2.0/src/libstreaming/Port.h

    r228 r230  
    127127         
    128128        bool prepare() {return true;}; 
    129         bool reset() {return true;}
     129        bool reset()
    130130 
    131131        std::string getName() {return m_Name;}; 
  • branches/libfreebob-2.0/src/libstreaming/StreamProcessor.cpp

    r225 r230  
    4141StreamProcessor::StreamProcessor(enum IsoStream::EStreamType type, int port, int framerate)  
    4242        : IsoStream(type, port) 
     43        , m_nb_buffers(0) 
    4344        , m_manager(0) 
    44         , m_nb_buffers(0) 
    4545        , m_period(0) 
    4646        , m_xruns(0) 
     
    5757} 
    5858 
    59 int StreamProcessor::putPacket(unsigned char *data, unsigned int length,  
    60                               unsigned char channel, unsigned char tag, unsigned char sy,  
    61                                   unsigned int cycle, unsigned int dropped) { 
    62  
    63         debugWarning("BUG: received packet in StreamProcessor base class!\n"); 
    64  
    65         return -1; 
    66 } 
    67  
    68 int StreamProcessor::getPacket(unsigned char *data, unsigned int *length, 
    69                               unsigned char *tag, unsigned char *sy, 
    70                               int cycle, unsigned int dropped, unsigned int max_length) { 
    71          
    72         debugWarning("BUG: packet requested from StreamProcessor base class!\n"); 
    73  
    74         return -1; 
    75 } 
    76  
    7759void StreamProcessor::dumpInfo() 
    7860{ 
     
    10284        resetFrameCounter(); 
    10385 
     86        resetXrunCounter(); 
     87 
    10488        // loop over the ports to reset them 
    10589        if (!PortManager::resetPorts()) { 
     
    11397                return false; 
    11498        } 
    115  
     99        return true; 
     100         
    116101} 
    117102 
     
    178163void StreamProcessor::resetFrameCounter() { 
    179164        ZERO_ATOMIC((SInt32 *)&m_framecounter); 
     165}; 
     166 
     167/** 
     168 * Resets the xrun counter, in a atomic way. This 
     169 * is thread safe. 
     170 */ 
     171void StreamProcessor::resetXrunCounter() { 
     172        ZERO_ATOMIC((SInt32 *)&m_xruns); 
    180173}; 
    181174 
     
    196189} 
    197190 
    198 int ReceiveStreamProcessor::putPacket(unsigned char *data, unsigned int length,  
    199                               unsigned char channel, unsigned char tag, unsigned char sy,  
    200                                   unsigned int cycle, unsigned int dropped) { 
    201  
    202         debugOutput( DEBUG_LEVEL_VERY_VERBOSE, 
    203                      "received packet: length=%d, channel=%d, cycle=%d\n", 
    204                      length, channel, cycle ); 
    205  
    206         return 0; 
    207 } 
    208  
    209191void ReceiveStreamProcessor::setVerboseLevel(int l) { 
    210192        setDebugLevel(l); 
     
    223205} 
    224206 
    225 int TransmitStreamProcessor::getPacket(unsigned char *data, unsigned int *length, 
    226                       unsigned char *tag, unsigned char *sy, 
    227                       int cycle, unsigned int dropped, unsigned int max_length) { 
    228         *length=0; 
    229         *tag = 1; 
    230         *sy = 0; 
    231  
    232         return 0; 
    233 } 
    234  
    235207void TransmitStreamProcessor::setVerboseLevel(int l) { 
    236208        setDebugLevel(l); 
  • branches/libfreebob-2.0/src/libstreaming/StreamProcessor.h

    r225 r230  
    6363                putPacket(unsigned char *data, unsigned int length,  
    6464                      unsigned char channel, unsigned char tag, unsigned char sy,  
    65                           unsigned int cycle, unsigned int dropped)
     65                          unsigned int cycle, unsigned int dropped) = 0
    6666        virtual int  
    6767                getPacket(unsigned char *data, unsigned int *length, 
    6868                      unsigned char *tag, unsigned char *sy, 
    69                       int cycle, unsigned int dropped, unsigned int max_length)
     69                      int cycle, unsigned int dropped, unsigned int max_length) = 0
    7070 
    7171        virtual enum EProcessorType getType() =0; 
     
    7373        bool xrunOccurred() { return (m_xruns>0);}; 
    7474 
    75         bool isOnePeriodReady() { return (m_framecounter > m_period); }; 
     75        bool isOnePeriodReady() { return (m_framecounter > (int)m_period); }; 
    7676        unsigned int getNbPeriodsReady() { if(m_period) return m_framecounter/m_period; else return 0;}; 
    7777        void decrementFrameCounter(); 
     78         
     79        // move to private? 
    7880        void resetFrameCounter(); 
     81    void resetXrunCounter(); 
    7982 
    8083        bool isRunning(); ///< returns true if there is some stream data processed 
     
    133136 
    134137        virtual enum EProcessorType getType() {return E_Receive;}; 
    135  
     138         
     139        virtual int  
     140                getPacket(unsigned char *data, unsigned int *length, 
     141                      unsigned char *tag, unsigned char *sy, 
     142                      int cycle, unsigned int dropped, unsigned int max_length) {return 0;}; 
     143                       
    136144        virtual int putPacket(unsigned char *data, unsigned int length,  
    137145                      unsigned char channel, unsigned char tag, unsigned char sy,  
    138                           unsigned int cycle, unsigned int dropped)
     146                          unsigned int cycle, unsigned int dropped) = 0
    139147        virtual void setVerboseLevel(int l); 
    140148 
     
    160168 
    161169        virtual int  
     170                putPacket(unsigned char *data, unsigned int length,  
     171                      unsigned char channel, unsigned char tag, unsigned char sy,  
     172                          unsigned int cycle, unsigned int dropped) {return 0;}; 
     173                           
     174        virtual int  
    162175                getPacket(unsigned char *data, unsigned int *length, 
    163176                      unsigned char *tag, unsigned char *sy, 
    164                       int cycle, unsigned int dropped, unsigned int max_length)
     177                      int cycle, unsigned int dropped, unsigned int max_length) = 0
    165178        virtual void setVerboseLevel(int l); 
    166179 
  • branches/libfreebob-2.0/src/libstreaming/StreamProcessorManager.cpp

    r227 r230  
    151151 
    152152        // and the tread that runs the runner 
    153         streamingThread=new FreebobPosixThread(this); 
    154         if(!streamingThread) { 
     153        m_streamingThread=new FreebobPosixThread(this); 
     154        if(!m_streamingThread) { 
    155155                debugFatal("Could not create streaming thread\n"); 
    156156                return false; 
    157157        } 
     158         
     159        m_streamingThread->setVerboseLevel(getDebugLevel()); 
    158160 
    159161        m_isoManager=new IsoHandlerManager(); 
     
    164166        } 
    165167         
     168        m_isoManager->setVerboseLevel(getDebugLevel()); 
     169         
    166170        if(!m_isoManager->Init()) { 
    167171                debugFatal("Could not init IsoHandlerManager\n"); 
    168172                return false; 
    169173        } 
     174 
     175        return true; 
     176} 
     177 
     178bool StreamProcessorManager::Init() 
     179{ 
     180        debugOutput( DEBUG_LEVEL_VERBOSE, "Initializing runner...\n"); 
     181         
     182        // no xrun has occurred (yet) 
     183        m_xrun_happened=false; 
    170184 
    171185        if(sem_init(&m_period_semaphore, 0, 0)) { 
     
    173187                debugFatal( " Error: %s\n",strerror(errno)); 
    174188                return false; 
    175         } else { 
    176                 debugOutput( DEBUG_LEVEL_VERBOSE,"Successfull init of packet transfer semaphore\n"); 
    177         } 
    178  
    179         return true; 
    180 
    181  
    182 bool StreamProcessorManager::Init() 
    183 
    184         debugOutput( DEBUG_LEVEL_VERBOSE, "enter...\n"); 
    185  
     189    } 
     190  
    186191        return true; 
    187192} 
     
    218223bool StreamProcessorManager::Execute() 
    219224{ 
     225 
     226        bool period_ready=true; 
     227    bool xrun_has_occured=false; 
     228         
    220229        debugOutput( DEBUG_LEVEL_VERY_VERBOSE, "enter...\n"); 
    221230        if(!m_isoManager->Execute()) { 
     
    223232                return false; 
    224233        } 
    225  
    226         bool period_ready=true; 
    227         m_xrun_has_occured=false; 
    228  
     234         
    229235        debugOutput( DEBUG_LEVEL_VERY_VERBOSE, " RCV PROC: "); 
    230236        for ( StreamProcessorVectorIterator it = m_ReceiveProcessors.begin(); 
     
    232238                ++it ) { 
    233239                period_ready = period_ready && (*it)->isOnePeriodReady(); 
    234                 m_xrun_has_occured = m_xrun_has_occured || (*it)->xrunOccurred(); 
    235                 debugOutputShort( DEBUG_LEVEL_VERY_VERBOSE, "(%d/%d/%d) ", period_ready, m_xrun_has_occured,(*it)->m_framecounter); 
     240                xrun_has_occured = xrun_has_occured || (*it)->xrunOccurred(); 
     241                debugOutputShort( DEBUG_LEVEL_VERY_VERBOSE, "(%d/%d/%d) ", period_ready, xrun_has_occured,(*it)->m_framecounter); 
    236242        } 
    237243        debugOutputShort( DEBUG_LEVEL_VERY_VERBOSE, "\n"); 
     
    242248                ++it ) { 
    243249                period_ready = period_ready && (*it)->isOnePeriodReady(); 
    244                 m_xrun_has_occured = m_xrun_has_occured || (*it)->xrunOccurred(); 
    245                 debugOutputShort( DEBUG_LEVEL_VERY_VERBOSE, "(%d/%d/%d) ", period_ready, m_xrun_has_occured,(*it)->m_framecounter); 
     250                xrun_has_occured = xrun_has_occured || (*it)->xrunOccurred(); 
     251                debugOutputShort( DEBUG_LEVEL_VERY_VERBOSE, "(%d/%d/%d) ", period_ready, xrun_has_occured,(*it)->m_framecounter); 
    246252        } 
    247253        debugOutputShort( DEBUG_LEVEL_VERY_VERBOSE, "\n"); 
    248254 
    249         if(m_xrun_has_occured) { 
     255        if(xrun_has_occured) { 
    250256                // do xrun signaling/handling 
     257                debugWarning("Streaming thread detected xrun\n"); 
    251258                m_xruns++; 
     259                m_xrun_happened=true; 
    252260                sem_post(&m_period_semaphore); 
    253                 return false; 
     261                return false; // stop thread 
    254262        } 
    255263 
     
    311319 
    312320        debugOutput( DEBUG_LEVEL_VERBOSE, "Starting IsoHandler...\n"); 
    313         if (!m_isoManager->startHandlers()) { 
     321        if (!m_isoManager->startHandlers(0)) { 
    314322                debugFatal("Could not start handlers...\n"); 
    315323                return false; 
     
    319327         
    320328        // start the runner thread 
    321         streamingThread->Start(); 
     329        m_streamingThread->Start(); 
    322330         
    323331        debugOutput( DEBUG_LEVEL_VERBOSE, "Waiting for all StreamProcessors to start running...\n"); 
     
    382390                } 
    383391                 
    384                 (*it)->resetFrameCounter(); 
    385         } 
    386          
    387         for ( StreamProcessorVectorIterator it = m_TransmitProcessors.begin(); 
    388                 it != m_TransmitProcessors.end(); 
    389                 ++it ) { 
     392                (*it)->reset(); 
    390393                 
    391394                if(getDebugLevel()>=DEBUG_LEVEL_VERBOSE) { 
     
    393396                } 
    394397                 
    395                 (*it)->resetFrameCounter(); 
     398        } 
     399         
     400        for ( StreamProcessorVectorIterator it = m_TransmitProcessors.begin(); 
     401                it != m_TransmitProcessors.end(); 
     402                ++it ) { 
     403                 
     404                if(getDebugLevel()>=DEBUG_LEVEL_VERBOSE) { 
     405                        (*it)->dumpInfo(); 
     406                } 
     407                 
     408                (*it)->reset(); 
     409                 
     410                if(getDebugLevel()>=DEBUG_LEVEL_VERBOSE) { 
     411                        (*it)->dumpInfo(); 
     412                } 
    396413        } 
    397414         
     
    415432        } 
    416433         
     434        return true; 
     435         
    417436} 
    418437 
    419438bool StreamProcessorManager::stop() { 
    420         debugOutput( DEBUG_LEVEL_VERBOSE, "enter...\n"); 
     439        debugOutput( DEBUG_LEVEL_VERBOSE, "Stopping...\n"); 
    421440        assert(m_isoManager); 
    422         assert(streamingThread); 
    423          
    424         streamingThread->Stop(); 
    425          
    426         return m_isoManager->stopHandlers(); 
     441        assert(m_streamingThread); 
     442        debugOutput( DEBUG_LEVEL_VERBOSE, "Stopping thread...\n"); 
     443         
     444        m_streamingThread->Stop(); 
     445         
     446        debugOutput( DEBUG_LEVEL_VERBOSE, "Stopping handlers...\n"); 
     447        if(!m_isoManager->stopHandlers()) { 
     448           debugFatal("Could not stop ISO handlers\n"); 
     449           return false; 
     450        } 
     451         
     452        debugOutput( DEBUG_LEVEL_VERBOSE, "Unregistering processors from handlers...\n"); 
     453    // now unregister all streams from iso manager 
     454        debugOutput( DEBUG_LEVEL_VERBOSE, " Receive processors...\n"); 
     455        for ( StreamProcessorVectorIterator it = m_ReceiveProcessors.begin(); 
     456                it != m_ReceiveProcessors.end(); 
     457                ++it ) { 
     458                        if (!m_isoManager->unregisterStream(*it)) { 
     459                                debugOutput(DEBUG_LEVEL_VERBOSE,"Could not unregister receive stream processor (%p) from the Iso manager\n",*it); 
     460                                return false; 
     461                        } 
     462                         
     463                         
     464                } 
     465 
     466        debugOutput( DEBUG_LEVEL_VERBOSE, " Transmit processors...\n"); 
     467        for ( StreamProcessorVectorIterator it = m_TransmitProcessors.begin(); 
     468                it != m_TransmitProcessors.end(); 
     469                ++it ) { 
     470                        if (!m_isoManager->unregisterStream(*it)) { 
     471                                debugOutput(DEBUG_LEVEL_VERBOSE,"Could not unregister transmit stream processor (%p) from the Iso manager\n",*it); 
     472                                return false; 
     473                        } 
     474                         
     475                } 
     476     
     477         
     478        return true; 
    427479         
    428480} 
     
    435487        sem_wait(&m_period_semaphore); 
    436488         
    437         if(m_xrun_has_occured) return false; 
    438          
    439         return true; 
    440  
    441 
    442  
    443 bool StreamProcessorManager::reset() { 
    444  
    445         debugOutput( DEBUG_LEVEL_VERBOSE, "Resetting processors...\n"); 
     489        if(m_xrun_happened) { 
     490           debugWarning("Detected underrun\n"); 
     491           dumpInfo(); 
     492           return false; 
     493        } 
     494         
     495        return true; 
     496 
     497
     498 
     499bool StreamProcessorManager::handleXrun() { 
     500 
     501        debugOutput( DEBUG_LEVEL_VERBOSE, "Handling Xrun ...\n"); 
    446502 
    447503        /*  
    448504         * Reset means: 
    449          * Bringing all buffers & connections into a know state 
    450          *   - Clear all capture buffers 
    451          *   - Put nb_periods*period_size of null frames into the playback buffers 
    452          *  => implemented by a reset() call, implementation dependant on the type 
     505         * 1) Stopping the packetizer thread 
     506         * 2) Bringing all buffers & streamprocessors into a know state 
     507         *    - Clear all capture buffers 
     508         *    - Put nb_periods*period_size of null frames into the playback buffers 
     509         * 3) Restarting the packetizer thread 
    453510         */ 
    454          
    455 //      debugOutputShort( DEBUG_LEVEL_VERY_VERBOSE, " Receive processors...\n"); 
    456         for ( StreamProcessorVectorIterator it = m_ReceiveProcessors.begin(); 
    457                 it != m_ReceiveProcessors.end(); 
    458                 ++it ) { 
    459                 if(!(*it)->reset()) { 
    460                         debugFatal("could not reset stream processor (%p)",*it); 
    461                         return false; 
    462                 } 
    463         } 
    464  
    465 //      debugOutputShort( DEBUG_LEVEL_VERY_VERBOSE, " Transmit processors...\n"); 
    466         for ( StreamProcessorVectorIterator it = m_TransmitProcessors.begin(); 
    467                 it != m_TransmitProcessors.end(); 
    468                 ++it ) { 
    469                 if(!(*it)->reset()) { 
    470                         debugFatal("could not reset stream processor (%p)",*it); 
    471                         return false; 
    472                 } 
    473         } 
     511        debugOutput( DEBUG_LEVEL_VERBOSE, "Stopping processormanager...\n"); 
     512        if(!stop()) { 
     513           debugFatal("Could not stop.\n"); 
     514           return false; 
     515        } 
     516 
     517        debugOutput( DEBUG_LEVEL_VERBOSE, "Resetting Processors...\n"); 
     518         
     519        // now we reset the frame counters 
     520        for ( StreamProcessorVectorIterator it = m_ReceiveProcessors.begin(); 
     521                it != m_ReceiveProcessors.end(); 
     522                ++it ) { 
     523                 
     524                if(getDebugLevel()>=DEBUG_LEVEL_VERBOSE) { 
     525                        (*it)->dumpInfo(); 
     526                } 
     527                 
     528                (*it)->reset(); 
     529                 
     530                if(getDebugLevel()>=DEBUG_LEVEL_VERBOSE) { 
     531                        (*it)->dumpInfo(); 
     532                } 
     533                 
     534        } 
     535         
     536        for ( StreamProcessorVectorIterator it = m_TransmitProcessors.begin(); 
     537                it != m_TransmitProcessors.end(); 
     538                ++it ) { 
     539                 
     540                if(getDebugLevel()>=DEBUG_LEVEL_VERBOSE) { 
     541                        (*it)->dumpInfo(); 
     542                } 
     543                 
     544                (*it)->reset(); 
     545                 
     546                if(getDebugLevel()>=DEBUG_LEVEL_VERBOSE) { 
     547                        (*it)->dumpInfo(); 
     548                } 
     549        } 
     550 
     551        debugOutput( DEBUG_LEVEL_VERBOSE, "Starting processormanager...\n"); 
     552 
     553        if(!start()) { 
     554           debugFatal("Could not start.\n"); 
     555           return false; 
     556        } 
     557 
     558 
     559        debugOutput( DEBUG_LEVEL_VERBOSE, "Xrun handled...\n"); 
     560         
     561         
    474562        return true; 
    475563} 
     
    482570        // penalty for the virtual functions (to be checked) 
    483571 
    484 //      debugOutputShort( DEBUG_LEVEL_VERY_VERBOSE, " Receive processors...\n"); 
    485572        for ( StreamProcessorVectorIterator it = m_ReceiveProcessors.begin(); 
    486573                it != m_ReceiveProcessors.end(); 
     
    492579        } 
    493580 
    494 //      debugOutputShort( DEBUG_LEVEL_VERY_VERBOSE, " Transmit processors...\n"); 
    495581        for ( StreamProcessorVectorIterator it = m_TransmitProcessors.begin(); 
    496582                it != m_TransmitProcessors.end(); 
     
    511597        // a static cast could make sure that there is no performance 
    512598        // penalty for the virtual functions (to be checked) 
    513  
    514 //      debugOutputShort( DEBUG_LEVEL_VERY_VERBOSE, " Receive processors...\n"); 
    515599        if (t==StreamProcessor::E_Receive) { 
    516600                for ( StreamProcessorVectorIterator it = m_ReceiveProcessors.begin(); 
     
    523607                } 
    524608        } else { 
    525 //      debugOutputShort( DEBUG_LEVEL_VERY_VERBOSE, " Transmit processors...\n"); 
    526609                for ( StreamProcessorVectorIterator it = m_TransmitProcessors.begin(); 
    527610                        it != m_TransmitProcessors.end(); 
     
    538621 
    539622void StreamProcessorManager::dumpInfo() { 
     623        debugOutputShort( DEBUG_LEVEL_NORMAL, "----------------------------------------------------\n"); 
    540624        debugOutputShort( DEBUG_LEVEL_NORMAL, "Dumping StreamProcessorManager information...\n"); 
    541625 
     
    556640        debugOutputShort( DEBUG_LEVEL_NORMAL, "Iso handler info:\n"); 
    557641        m_isoManager->dumpInfo(); 
     642        debugOutputShort( DEBUG_LEVEL_NORMAL, "----------------------------------------------------\n"); 
    558643 
    559644} 
     
    561646void StreamProcessorManager::setVerboseLevel(int l) { 
    562647        setDebugLevel(l); 
    563          
     648 
    564649        if (m_isoManager) m_isoManager->setVerboseLevel(l); 
     650        if (m_streamingThread) m_streamingThread->setVerboseLevel(l); 
    565651 
    566652        debugOutput( DEBUG_LEVEL_VERBOSE, " Receive processors...\n"); 
  • branches/libfreebob-2.0/src/libstreaming/StreamProcessorManager.h

    r227 r230  
    9191        bool transfer(enum StreamProcessor::EProcessorType); ///< transfer the buffer contents from/to client (single processor type) 
    9292 
    93         bool reset(); ///< reset the streams & buffers (e.g. after xrun) 
     93        bool handleXrun(); ///< reset the streams & buffers after xrun 
    9494 
    9595        bool start(); 
     
    105105        // thread sync primitives 
    106106        sem_t m_period_semaphore; 
    107         // this may only be written by the packet thread, and read by  
    108         // the waiting thread. The packet thread terminates if this is 
    109         // true, therefore it will never by updated again. 
    110         // it can only be set to true before the period semaphore is  
    111         // signalled, which the waiting thread is waiting for. Therefore 
    112         // this variable is protected by the semaphore. 
    113         bool m_xrun_has_occured;  
     107 
     108        bool m_xrun_happened;  
    114109 
    115110        // processor list 
     
    123118        IsoHandlerManager *m_isoManager; 
    124119 
    125         FreebobPosixThread *streamingThread; 
     120        FreebobPosixThread *m_streamingThread; 
    126121 
    127122    DECLARE_DEBUG_MODULE;