Changeset 385

Timestamp:

02/01/07 15:02:24 (16 years ago)

Author:

pieterpalmers

Message:

- fixed issues with SYT timestamp processing
- SYT based sync works if syncing to the received stream

Files:

• branches/streaming-rework/src/debugmodule/debugmodule.cpp (modified) (1 diff)
• branches/streaming-rework/src/libstreaming/AmdtpStreamProcessor.cpp (modified) (23 diffs)
• branches/streaming-rework/src/libstreaming/cycletimer.h (modified) (1 diff)
• branches/streaming-rework/src/libstreaming/freebob_streaming.cpp (modified) (3 diffs)
• branches/streaming-rework/src/libstreaming/IsoHandler.cpp (modified) (1 diff)
• branches/streaming-rework/src/libstreaming/IsoHandlerManager.cpp (modified) (4 diffs)
• branches/streaming-rework/src/libstreaming/StreamProcessor.cpp (modified) (12 diffs)
• branches/streaming-rework/src/libstreaming/StreamProcessor.h (modified) (6 diffs)
• branches/streaming-rework/src/libstreaming/StreamProcessorManager.cpp (modified) (17 diffs)

branches/streaming-rework/src/debugmodule/debugmodule.cpp

@@ -276 +276 @@
-        /* called WITHOUT the mb_write_lock */
-        while (mb_outbuffer != mb_inbuffer) {
-out
+err
-                mb_outbuffer = MB_NEXT(mb_outbuffer);
-        }

branches/streaming-rework/src/libstreaming/AmdtpStreamProcessor.cpp

@@ -38 +38 @@
-#define RECEIVE_DLL_INTEGRATION_COEFFICIENT 0.015
-
-51200
+(10000)
-
-// in ticks
-
-
-
-
+
+
+
-
-namespace FreebobStreaming {
@@ -117 +116 @@
-    packet->fmt = IEC61883_FMT_AMDTP;
-
-
-
-
-
-
-
-
-
+
-    float ticks_per_frame=m_SyncSource->getTicksPerFrame();
-    
-    // the base timestamp is the one of the last sample in the buffer
-
-
+
+
+
+
+
+
-    
-    // meaning that the first sample in the buffer lies m_framecounter * rate
-would give
+gives
-    //   timestamp = m_last_timestamp - m_framecounter * rate
-
-
-
-
-
-
+
+
+
+
+
-    
-    // this happens if m_buffer_tail_timestamp wraps around while there are 
@@ -158 +153 @@
-    
-    // determine if we want to send a packet or not
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    
-    // we send a packet some cycles in advance, to avoid the
-    // following situation:
-    // suppose we are only a few ticks away from 
-
-
-
-
-
+
+
+
+
+
+
-    until_next -= TICKS_PER_CYCLE * TRANSMIT_ADVANCE_CYCLES;
-    
+    // we have to queue it cycle_diff * TICKS_PER_CYCLE earlier
+    until_next -= cycle_diff * TICKS_PER_CYCLE;
+
-    // the maximal difference we can allow (64secs)
-    const int64_t max=TICKS_PER_SECOND*64L;
-
+
+
-    if(!m_disabled) {
-, TPS=%10.6f, UTN=%11lld
-m_framecounter, ticks_per_frame, until_next
+
+fc
-            );
-
+
+
+
+
+
+
+
+
-
-    if(until_next > max) {
@@ -194 +242 @@
-        until_next += TICKS_PER_SECOND*128L;
-    }
-
+
+
-    if(!m_disabled) {
-  TS=%11llu, CTR=%11llu, FC=%5d, TPS=%10.6f, UTN=%11ll
-m_framecounter, ticks_per_frame, until_next
+> TS=%11llu, CTR=%11llu, FC=%5
+fc
-            );
-
-
-
+
+
+
+
+
+
+
-    // or when the next sample is not due yet.
-    
@@ -207 +260 @@
-    // that means that we'll send NODATA packets.
-    // we don't add payload because DICE devices don't like that.
-
+ || !m_running
-        // no-data packets have syt=0xFFFF
-        // and have the usual amount of events as dummy data (?)
@@ -224 +277 @@
-        *tag = IEC61883_TAG_WITH_CIP;
-        *sy = 0;
-
+
+
+
+
+
+
+
+
+
-        return RAW1394_ISO_DEFER;
-    }
-    
+    // indicate that we are now in an enabled state.
+    m_is_disabled=false;
+            
-    // construct the packet
-    nevents = m_syt_interval;
@@ -245 +309 @@
-
-        debugWarning("Transmit buffer underrun (cycle %d, FC=%d, PC=%d)\n", 
-
+
+
+
-
-        // TODO: we have to be a little smarter here
@@ -257 +323 @@
-        packet->fdf = IEC61883_FDF_NODATA;
-        packet->syt = 0xffff;
-
+
-        // this means no-data packets with payload (DICE doesn't like that)
-        *length = 2*sizeof(quadlet_t) + m_syt_interval * m_dimension * sizeof(quadlet_t);
@@ -277 +343 @@
-
-        // convert the timestamp to SYT format
-
+
+
+
+
+
+
+
+
-        packet->syt = ntohs(timestamp_SYT);
-
@@ -284 +357 @@
-    
-    // calculate the new buffer head timestamp. this is
-
-
-
-
+
+
+
-    
-    // check if it wrapped
@@ -336 +408 @@
-    uint64_t ts;
-    uint64_t fc;
-
+ // thread safe
-
-    // update the frame counter such that it reflects the buffer content,
@@ -440 +512 @@
-    
-    // add the receive processing delay
-
+// 
-    
-    if( !(m_event_buffer=freebob_ringbuffer_create(
@@ -583 +655 @@
-    uint64_t fc;
-    
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    return true;
-}
@@ -617 +724 @@
-    int xrun;
-    unsigned int offset=0;
+    
+    debugOutput(DEBUG_LEVEL_VERY_VERBOSE, "AmdtpTransmitStreamProcessor::putFrames(%d, %llu)\n",nbframes, ts);
-    
-    freebob_ringbuffer_data_t vec[2];
@@ -700 +809 @@
-
-    }
+    
+    // recalculate the buffer tail timestamp
+    float ticks_per_frame=m_SyncSource->getTicksPerFrame();
+    
+    // this makes that the last sample to be sent out on ISO
+    // has the same timestamp as the last one transfered
+    // to the client
+    // plus one frame
+    ts += (uint64_t)ticks_per_frame;
+    int64_t timestamp = ts;
+    
+    // however we have to preserve causality, meaning that we have to make
+    // sure that the worst-case buffer head timestamp still lies in the future.
+    // this worst case timestamp occurs when the xmit buffer is completely full.
+    // therefore we add m_ringbuffer_size_frames * ticks_per_frame to the timestamp.
+    // this will make sure that the buffer head timestamp lies in the future.
+    // the netto effect of this is that the system works as if the buffer processing
+    // by the client doesn't take time.
+    
+    timestamp += (int64_t)((float)m_ringbuffer_size_frames * ticks_per_frame);
+    
+    // wrap the timestamp if nescessary
+    if (timestamp >= TICKS_PER_SECOND * 128L) {
+        timestamp -= TICKS_PER_SECOND * 128L;
+    }
+
+    debugOutput(DEBUG_LEVEL_VERY_VERBOSE, "StreamProcessor::putFrames(%d, %llu)\n",nbframes, timestamp);
-
-    // update the frame counter such that it reflects the new value,
-    // and also update the buffer tail timestamp
-    // done in the SP base class
-
-
-
-
+
+
-        return false;
-    }
@@ -1029 +1163 @@
-        m_last_timestamp += CYCLE_TIMER_GET_OFFSET(syt_timestamp);
-        m_last_timestamp += cc_seconds * TICKS_PER_SECOND;
+        
+        // the receive processing delay indicates how much
+        // extra time we need as slack
+        m_last_timestamp += RECEIVE_PROCESSING_DELAY;
-
-        //=> now estimate the device frame rate
@@ -1083 +1221 @@
-        //=> don't process the stream samples when it is not enabled.
-        if(m_disabled) {
+
-            // we keep track of the timestamp here
-            // this makes sure that we will have a somewhat accurate
@@ -1091 +1230 @@
-            // SYT_INTERVAL * rate later
-            uint64_t ts=m_last_timestamp+(uint64_t)((float)m_syt_interval * m_ticks_per_frame);
+            
+            // wrap if nescessary
+            if (ts >= TICKS_PER_SECOND * 128L) {
+                ts -= TICKS_PER_SECOND * 128L;
+            }
+            // set the timestamps
-            StreamProcessor::setBufferTimestamps(ts,ts);
+            
+            // indicate that we are now in a disabled state.
+            m_is_disabled=true;
-            
-            return RAW1394_ISO_DEFER;
-        }
+        
+        // indicate that we are now in an enabled state.
+        m_is_disabled=false;
-        
-        //=> process the packet
@@ -1103 +1254 @@
-        {
-            debugWarning("Receive buffer overrun (cycle %d, FC=%d, PC=%d)\n", 
-m_framecounter
+getFrameCounter()
-            
-            m_xruns++;
@@ -1224 +1375 @@
-    // currently this is in ticks
-    
+    int64_t fc=getFrameCounter();
+    
-    int64_t next_period_boundary =  m_last_timestamp;
-
-
+
+
+
-    
-    debugOutput(DEBUG_LEVEL_VERY_VERBOSE, "=> NPD=%11lld, LTS=%11llu, FC=%5d, TPF=%f\n",
-m_framecounter
+fc
-        );
-    
@@ -1249 +1403 @@
-    
-    debugOutput(DEBUG_LEVEL_VERY_VERBOSE, "   NPD=%11lld, LTS=%11llu, FC=%5d, TPF=%f\n",
-m_framecounter
+fc
-        );
-
@@ -1283 +1437 @@
-    m_WakeupStat.reset();
-    
-
+// 
-
-    // reset all non-device specific stuff
@@ -1554 +1708 @@
-    
-    if (!StreamProcessor::getFrames(nbframes, ts)) {
-
+ 
-        return false;
-    }

branches/streaming-rework/src/libstreaming/cycletimer.h

@@ -38 +38 @@
-#define TICKS_PER_CYCLE     3072U
-#define TICKS_PER_SECOND    24576000UL
-TICKS_PER_SECOND/1000000.
+24.57600
-
-#define USECS_PER_TICK     (1.0/TICKS_PER_USEC)
+#define USECS_PER_CYCLE    (125U)
-
-#define CYCLE_TIMER_GET_SECS(x)   ((((x) & 0xFE000000U) >> 25))

branches/streaming-rework/src/libstreaming/freebob_streaming.cpp

@@ -119 +119 @@
-        // discover the devices on the bus
-        if(!dev->m_deviceManager->discover(DEBUG_LEVEL_NORMAL)) {
-Output(DEBUG_LEVEL_VERBOSE, 
+Fatal(
-                delete dev->processorManager;
-                delete dev->m_deviceManager;
@@ -132 +132 @@
-            assert(device);
-
+            debugOutput(DEBUG_LEVEL_VERBOSE, "Setting samplerate to %d for (%p)\n", 
+                        dev->options.sample_rate, device);
-            // Set the device's sampling rate to that requested
-            // FIXME: does this really belong here?  If so we need to handle errors.
-            if (!device->setSamplingFrequency(parseSampleRate(dev->options.sample_rate))) {
+                debugOutput(DEBUG_LEVEL_VERBOSE, " => Retry setting samplerate to %d for (%p)\n", 
+                            dev->options.sample_rate, device);
+            
-                // try again:
-                if (!device->setSamplingFrequency(parseSampleRate(dev->options.sample_rate))) {
@@ -252 +257 @@
-        periods++;
-        if(periods>periods_print) {
-(DEBUG_LEVEL_VERBOSE, "
-
-
-
+Short(DEBUG_LEVEL_VERBOSE, "\nfreebob_streaming_wait
+Short
+Short
+Short
-                dev->processorManager->dumpInfo();
-
+Short
-                periods_print+=100;
-        }

branches/streaming-rework/src/libstreaming/IsoHandler.cpp

@@ -877 +877 @@
-    debugOutput( DEBUG_LEVEL_VERBOSE, " Irq interval    : %d \n",m_irq_interval);
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    }
-    return true;

branches/streaming-rework/src/libstreaming/IsoHandlerManager.cpp

@@ -31 +31 @@
-#include "IsoStream.h"
-#include <assert.h>
+
+#define MINIMUM_INTERRUPTS_PER_PERIOD  4U
+#define PACKETS_PER_INTERRUPT          4U
-
-namespace FreebobStreaming
@@ -285 +288 @@
-                unsigned int packets_per_period=stream->getPacketsPerPeriod();
-                
+#if 0
-                // hardware interrupts occur when one DMA block is full, and the size of one DMA
-                // block = PAGE_SIZE. Setting the max_packet_size makes sure that the HW irq is 
-                // occurs at a period boundary (optimal CPU use)
-                
-
-
+
+
+
-                if (max_packet_size < stream->getMaxPacketSize()) {
-                        max_packet_size=stream->getMaxPacketSize();
@@ -300 +305 @@
-                        max_packet_size = getpagesize();
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
-                // hardware interrupts occur when one DMA block is full, and the size of one DMA
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-                if (max_packet_size < stream->getMaxPacketSize()) {
-                        max_packet_size=stream->getMaxPacketSize();
@@ -358 +335 @@
-                        max_packet_size = getpagesize();
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-                if(irq_interval <= 0) irq_interval=1;
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-                // the transmit buffer size should be as low as possible for latency. 
-                // note however that the raw1394 subsystem tries to keep this buffer
-                // full, so we have to make sure that we have enough events in our
-                // event buffers
-
+
+
+
+
+
+
+
+
-                
-                // NOTE: this is dangerous: what if there is not enough prefill?

branches/streaming-rework/src/libstreaming/StreamProcessor.cpp

@@ -35 +35 @@
-namespace FreebobStreaming {
-
-NORMAL
-NORMAL
-NORMAL
+VERBOSE
+VERBOSE
+VERBOSE
-
-StreamProcessor::StreamProcessor(enum IsoStream::EStreamType type, int port, int framerate) 
@@ -51 +51 @@
-        , m_running(false)
-        , m_disabled(true)
+        , m_is_disabled(true)
-{
-
@@ -61 +62 @@
-void StreamProcessor::dumpInfo()
-{
+    int64_t diff=(int64_t)m_buffer_head_timestamp - (int64_t)m_buffer_tail_timestamp;
-
-    debugOutputShort( DEBUG_LEVEL_NORMAL, " StreamProcessor information\n");
@@ -66 +68 @@
-    
-    IsoStream::dumpInfo();
-
-
-
-
+
+
+
+
+
+
+
+
+
+
-    
-//     m_PeriodStat.dumpInfo();
@@ -111 +119 @@
-    return true;
-        
+}
+    
+bool StreamProcessor::prepareForEnable() {
+    int64_t diff=(int64_t)m_buffer_head_timestamp - (int64_t)m_buffer_tail_timestamp;
+    
+    debugOutput(DEBUG_LEVEL_VERBOSE," StreamProcessor::prepareForEnable for (%p)\n",this);
+    debugOutput(DEBUG_LEVEL_VERBOSE," Frame Counter         : %05d\n",m_framecounter);
+    debugOutput(DEBUG_LEVEL_VERBOSE," Buffer head timestamp : %011llu\n",m_buffer_head_timestamp);
+    debugOutput(DEBUG_LEVEL_VERBOSE," Buffer tail timestamp : %011llu\n",m_buffer_tail_timestamp);
+    debugOutput(DEBUG_LEVEL_VERBOSE," Head - Tail           : %011lld\n",diff);
+    debugOutput(DEBUG_LEVEL_VERBOSE," Now                   : %011u\n",m_handler->getCycleTimerTicks());
+    return true;
+}
+
+bool StreamProcessor::prepareForDisable() {
+    int64_t diff=(int64_t)m_buffer_head_timestamp - (int64_t)m_buffer_tail_timestamp;
+    
+    debugOutput(DEBUG_LEVEL_VERBOSE," StreamProcessor::prepareForDisable for (%p)\n",this);
+    debugOutput(DEBUG_LEVEL_VERBOSE," Frame Counter         : %05d\n",m_framecounter);
+    debugOutput(DEBUG_LEVEL_VERBOSE," Buffer head timestamp : %011llu\n",m_buffer_head_timestamp);
+    debugOutput(DEBUG_LEVEL_VERBOSE," Buffer tail timestamp : %011llu\n",m_buffer_tail_timestamp);
+    debugOutput(DEBUG_LEVEL_VERBOSE," Head - Tail           : %011lld\n",diff);
+    debugOutput(DEBUG_LEVEL_VERBOSE," Now                   : %011u\n",m_handler->getCycleTimerTicks());
+    return true;
+
-}
-
@@ -172 +205 @@
-bool StreamProcessor::getFrames(unsigned int nbframes, int64_t ts) {
-
-...\n", nbframe
+ at (%011lld)...\n", nbframes, t
-        decrementFrameCounter(nbframes, ts);
-        return true;
@@ -181 +214 @@
-}
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-}
-
@@ -195 +266 @@
-/**
- * Decrements the frame counter, in a atomic way. This
-tail
+head
- * is thread safe.
- */
-void StreamProcessor::decrementFrameCounter(int nbframes, uint64_t new_timestamp) {
+    debugOutput(DEBUG_LEVEL_VERY_VERBOSE, "Setting buffer head timestamp for (%p) to %11llu\n",
+                this, new_timestamp);
+                
-    pthread_mutex_lock(&m_framecounter_lock);
-    m_framecounter -= nbframes;
@@ -207 +281 @@
-/**
- * Increments the frame counter, in a atomic way.
-head
+tail
- * This is thread safe.
- */
-void StreamProcessor::incrementFrameCounter(int nbframes, uint64_t new_timestamp) {
+    debugOutput(DEBUG_LEVEL_VERY_VERBOSE, "Setting buffer tail timestamp for (%p) to %11llu\n",
+                this, new_timestamp);
+    
-    pthread_mutex_lock(&m_framecounter_lock);
-    m_framecounter += nbframes;
@@ -219 +296 @@
-
-/**
- * Sets the frame counter, in a atomic way. 
- * also sets the buffer head timestamp
- * This is thread safe.
- */
-void StreamProcessor::setFrameCounter(int new_framecounter, uint64_t new_timestamp) {
-    pthread_mutex_lock(&m_framecounter_lock);
-    m_framecounter = new_framecounter;
-    m_buffer_tail_timestamp = new_timestamp;
-    pthread_mutex_unlock(&m_framecounter_lock);
-}
-
-/**
- * Sets the buffer tail timestamp (in usecs)
- * This is thread safe.
- */
-void StreamProcessor::setBufferTailTimestamp(uint64_t new_timestamp) {
+    debugOutput(DEBUG_LEVEL_VERY_VERBOSE, "Setting buffer tail timestamp for (%p) to %11llu\n",
+                this, new_timestamp);
+    
-    pthread_mutex_lock(&m_framecounter_lock);
-    m_buffer_tail_timestamp = new_timestamp;
@@ -245 +313 @@
- */
-void StreamProcessor::setBufferHeadTimestamp(uint64_t new_timestamp) {
+    debugOutput(DEBUG_LEVEL_VERY_VERBOSE, "Setting buffer head timestamp for (%p) to %11llu\n",
+                this, new_timestamp);
+
-    pthread_mutex_lock(&m_framecounter_lock);
-    m_buffer_head_timestamp = new_timestamp;
@@ -256 +327 @@
- */
-void StreamProcessor::setBufferTimestamps(uint64_t new_head, uint64_t new_tail) {
+    debugOutput(DEBUG_LEVEL_VERY_VERBOSE, "Setting buffer head timestamp for (%p) to %11llu\n",
+                this, new_head);
+    debugOutput(DEBUG_LEVEL_VERY_VERBOSE, "    and buffer tail timestamp for (%p) to %11llu\n",
+                this, new_tail);
+   
-    pthread_mutex_lock(&m_framecounter_lock);
-    m_buffer_head_timestamp = new_head;

branches/streaming-rework/src/libstreaming/StreamProcessor.h

@@ -80 +80 @@
-
-    bool isRunning(); ///< returns true if there is some stream data processed
-void
-void disable() {m_disabled=true;}
-
+bool
+bool disable()
+is_
-
-    virtual bool putFrames(unsigned int nbframes, int64_t ts); ///< transfer the buffer contents from client
@@ -100 +100 @@
-    virtual bool prepareForStart() {return true;};
-    
- {return true;}
- {return true;}
+
+
-
-protected:
@@ -120 +120 @@
-    bool m_running;
-    bool m_disabled;
-
+
+
-    StreamStatistics m_PacketStat;
-    StreamStatistics m_PeriodStat;
@@ -147 +148 @@
-        void decrementFrameCounter(int nbframes, uint64_t new_timestamp);
-        void incrementFrameCounter(int nbframes, uint64_t new_timestamp);
-        void setFrameCounter(int new_framecounter, uint64_t new_timestamp);
-        void resetFrameCounter();
-        
@@ -193 +193 @@
-        float getTicksPerFrame() {return m_ticks_per_frame;};
-    
-otected
+ivate
-        // the framecounter gives the number of frames in the buffer
-        signed int m_framecounter;
@@ -205 +205 @@
-        uint64_t   m_buffer_head_timestamp;
-        
-    
+protected:
-        StreamProcessor *m_SyncSource;
-        

branches/streaming-rework/src/libstreaming/StreamProcessorManager.cpp

@@ -33 +33 @@
-#include <assert.h>
-
+#include "libstreaming/cycletimer.h"
+
+#define CYCLES_TO_SLEEP_AFTER_RUN_SIGNAL 50
-
-namespace FreebobStreaming {
@@ -403 +406 @@
-        }
-
+        // we want to make sure that everything is running well, 
+        // so wait for a while
+        usleep(USECS_PER_CYCLE * CYCLES_TO_SLEEP_AFTER_RUN_SIGNAL);
+
-        debugOutput( DEBUG_LEVEL_VERBOSE, "StreamProcessors running...\n");
-frame 
+
-        
-        // now we reset the frame counters
@@ -411 +418 @@
-                ++it ) {
-                
+                debugOutput( DEBUG_LEVEL_VERBOSE, "Before:\n");
+                
-                if(getDebugLevel()>=DEBUG_LEVEL_VERBOSE) {
-                        (*it)->dumpInfo();
-                }
-
-
+
+
+
-
-                if(getDebugLevel()>=DEBUG_LEVEL_VERBOSE) {
@@ -427 +438 @@
-                ++it ) {
-                
+                debugOutput( DEBUG_LEVEL_VERBOSE, "Before:\n");
+                
-                if(getDebugLevel()>=DEBUG_LEVEL_VERBOSE) {
-                        (*it)->dumpInfo();
@@ -432 +445 @@
-                
-                (*it)->reset();
+                
+                debugOutput( DEBUG_LEVEL_VERBOSE, "After:\n");
-                
-                if(getDebugLevel()>=DEBUG_LEVEL_VERBOSE) {
@@ -666 +681 @@
-bool StreamProcessorManager::waitForPeriod() {
-    int time_till_next_period;
-
+
+
-    debugOutput( DEBUG_LEVEL_VERY_VERBOSE, "enter...\n");
-
@@ -679 +695 @@
-        usleep(time_till_next_period);
-        
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        time_till_next_period=m_SyncSource->getTimeUntilNextPeriodUsecs();
-    }
-    
-
+-
-    
-    // this is to notify the client of the delay 
@@ -696 +727 @@
-    //       and the receive processors should have done their transfer.
-    m_time_of_transfer=m_SyncSource->getTimeAtPeriod();
-
+Y_VER
-        m_time_of_transfer);
+    
+    xrun_occurred=false;
-    
-    // check if xruns occurred on the Iso side.
-    // also check if xruns will occur should we transfer() now
-    bool xrun_occurred=false;
-    
-    for ( StreamProcessorVectorIterator it = m_ReceiveProcessors.begin();
@@ -741 +773 @@
-    }
-    
+    m_nbperiods++;
+    
-    // now we can signal the client that we are (should be) ready
-    return !xrun_occurred;
@@ -772 +806 @@
-
-bool StreamProcessorManager::transfer(enum StreamProcessor::EProcessorType t) {
-    int64_t time_of_transfer;
-    debugOutput( DEBUG_LEVEL_VERY_VERBOSE, "Transferring period...\n");
-    
-    // first we should find out on what time this transfer is
-    // supposed to be happening. this time will become the time
-    // stamp for the transmitted buffer.
-    // NOTE: maybe we should include the transfer delay here, that
-    //       would make it equal for all types of SP's
-    time_of_transfer=m_time_of_transfer;
-    
-    // a static cast could make sure that there is no performance
@@ -788 +814 @@
-                it != m_ReceiveProcessors.end();
-                ++it ) {
-            uint64_t buffer_tail_ts;
-            uint64_t fc;
-            int64_t ts;
-        
-            (*it)->getBufferTailTimestamp(&buffer_tail_ts,&fc);
-            ts =  buffer_tail_ts;
-            ts += (int64_t)((-(int64_t)fc) * m_SyncSource->getTicksPerFrame());
-            // NOTE: ts can be negative due to wraparound, it is the responsability of the 
-            //       SP to deal with that.
-            
-
-
-
-
-
-
-
-
+
+
-            {
-                uint64_t ts_tail=0;
@@ -823 +834 @@
-                }
-                
-*  HEAD: TS=%llu, FC=%llu | TAIL: TS=%llu, FC=%
-tail, fc_tail, ts_head, fc_head
+=> HEAD: TS=%11llu, FC=%5llu | TAIL: TS=%11llu, FC=%5
+head, fc_head, ts_tail, fc_tail
-            }
-            #endif
-    
-ts
-
-
+(int64_t)m_time_of_transfer
+, %11llu
+ m_time_of_transfer,
-                    return false; // buffer underrun
-            }
-            
-
+
+
-            {
-                uint64_t ts_tail=0;
@@ -852 +864 @@
-                }
-                
-> HEAD: TS=%llu, FC=%llu | TAIL: TS=%llu, FC=%
-tail, fc_tail, ts_head, fc_head, cnt);            
+ > HEAD: TS=%11llu, FC=%5llu | TAIL: TS=%11llu, FC=%5
+head, fc_head, ts_tail, fc_tail, cnt);
-            }
-            #endif
@@ -863 +875 @@
-                ++it ) {
-                
-
+
+
-            {
-                uint64_t ts_tail=0;
@@ -881 +894 @@
-                }
-                
-*  HEAD: TS=%llu, FC=%llu | TAIL: TS=%llu, FC=%
-tail, fc_tail, ts_head, fc_head
+=> HEAD: TS=%11llu, FC=%5llu | TAIL: TS=%11llu, FC=%5
+head, fc_head, ts_tail, fc_tail
-            }
-            #endif
-                
-
+ (int64_t)m_
-                debugOutput(DEBUG_LEVEL_VERBOSE, "could not putFrames(%u,%llu) to stream processor (%p)",
-
+m_
-                return false; // buffer overrun
-            }
-            
-
+
+
-            {
-                uint64_t ts_tail=0;
@@ -910 +924 @@
-                }
-                
-> HEAD: TS=%llu, FC=%llu | TAIL: TS=%llu, FC=%
-tail, fc_tail, ts_head, fc_head, cnt);            
+ > HEAD: TS=%11llu, FC=%5llu | TAIL: TS=%11llu, FC=%5
+head, fc_head, ts_tail, fc_tail, cnt);
-            }
-            #endif
@@ -923 +937 @@
-        debugOutputShort( DEBUG_LEVEL_NORMAL, "----------------------------------------------------\n");
-        debugOutputShort( DEBUG_LEVEL_NORMAL, "Dumping StreamProcessorManager information...\n");
-
+6
-
-        debugOutputShort( DEBUG_LEVEL_NORMAL, " Receive processors...\n");