Changeset 384

Timestamp:

01/30/07 13:11:25 (17 years ago)

Author:

pieterpalmers

Message:

- temporary commit as backup measure
- rewrote synchronisation code
- receive streaming based on SYT works
- transmit streaming synced to received stream sort of works, still

have to iron out some issues.

NOTE: all devices but the bebob's are disabled in this code,

because they still have to be ported to the new sync
mechanism.

Files:

• branches/streaming-rework/config.h.in (modified) (1 diff)
• branches/streaming-rework/configure.ac (modified) (3 diffs)
• branches/streaming-rework/src/bebob/bebob_avdevice.cpp (modified) (3 diffs)
• branches/streaming-rework/src/debugmodule/debugmodule.cpp (modified) (2 diffs)
• branches/streaming-rework/src/debugmodule/debugmodule.h (modified) (1 diff)
• branches/streaming-rework/src/devicemanager.cpp (modified) (2 diffs)
• branches/streaming-rework/src/libstreaming/AmdtpStreamProcessor.cpp (modified) (36 diffs)
• branches/streaming-rework/src/libstreaming/AmdtpStreamProcessor.h (modified) (6 diffs)
• branches/streaming-rework/src/libstreaming/cycletimer.h (modified) (2 diffs)
• branches/streaming-rework/src/libstreaming/freebob_streaming.cpp (modified) (5 diffs)
• branches/streaming-rework/src/libstreaming/IsoHandler.cpp (modified) (34 diffs)
• branches/streaming-rework/src/libstreaming/IsoHandler.h (modified) (8 diffs)
• branches/streaming-rework/src/libstreaming/IsoHandlerManager.cpp (modified) (14 diffs)
• branches/streaming-rework/src/libstreaming/IsoHandlerManager.h (modified) (3 diffs)
• branches/streaming-rework/src/libstreaming/IsoStream.cpp (modified) (2 diffs)
• branches/streaming-rework/src/libstreaming/MotuStreamProcessor.cpp (modified) (8 diffs)
• branches/streaming-rework/src/libstreaming/MotuStreamProcessor.h (modified) (5 diffs)
• branches/streaming-rework/src/libstreaming/StreamProcessor.cpp (modified) (6 diffs)
• branches/streaming-rework/src/libstreaming/StreamProcessor.h (modified) (6 diffs)
• branches/streaming-rework/src/libstreaming/StreamProcessorManager.cpp (modified) (21 diffs)
• branches/streaming-rework/src/libstreaming/StreamProcessorManager.h (modified) (5 diffs)
• branches/streaming-rework/src/libutil/cycles.h (modified) (1 diff)
• branches/streaming-rework/src/libutil/SystemTimeSource.cpp (modified) (2 diffs)
• branches/streaming-rework/src/libutil/SystemTimeSource.h (modified) (1 diff)
• branches/streaming-rework/src/libutil/Time.h (modified) (1 diff)
• branches/streaming-rework/src/libutil/TimeSource.cpp (modified) (2 diffs)
• branches/streaming-rework/src/libutil/TimeSource.h (modified) (2 diffs)
• branches/streaming-rework/src/Makefile.am (modified) (3 diffs)
• branches/streaming-rework/src/motu/motu_avdevice.cpp (modified) (2 diffs)
• branches/streaming-rework/src/motu/motu_avdevice.h (modified) (2 diffs)
• branches/streaming-rework/tests/Makefile.am (modified) (2 diffs)
• branches/streaming-rework/tests/SytMonitor.cpp (modified) (5 diffs)
• branches/streaming-rework/tests/SytMonitor.h (modified) (3 diffs)
• branches/streaming-rework/tests/test-cycletimer.cpp (modified) (9 diffs)
• branches/streaming-rework/tests/test-sytmonitor.cpp (modified) (15 diffs)

branches/streaming-rework/config.h.in

@@ -84 +84 @@
-#undef const
-
- int
+
-#undef size_t
-

branches/streaming-rework/configure.ac

@@ -113 +113 @@
-
-# Check for dependencies
+PKG_CHECK_MODULES(LIBRAW1394_122, libraw1394 >= 1.2.2, libraw1394_1_2_2=yes, libraw1394_1_2_2=no)
-PKG_CHECK_MODULES(LIBRAW1394, libraw1394 >= 1.2.1)
-PKG_CHECK_MODULES(LIBIEC61883, libiec61883 >= 1.0.0)
@@ -129 +130 @@
-esac],[debug=false])
-
+if test "x$libraw1394_1_2_2" = xyes; then
+        CFLAGS="$CFLAGS -DLIBRAW1394_USE_CTRREAD_API"
+        CXXFLAGS="$CXXFLAGS -DLIBRAW1394_USE_CTRREAD_API" 
+fi
-
-dnl Check for MMX assembly
@@ -248 +253 @@
-  Source directory:     $srcdir
-  Installation prefix:  $prefix
+  C compiler:           $C $CFLAGS
-  C++ compiler:         $CXX $CXXFLAGS
-
-  libraw1394 CFLAGS:    $LIBRAW1394_CFLAGS
-  libraw1394 LIBS:      $LIBRAW1394_LIBS
+   use new cycle timer read api? $libraw1394_1_2_2
-  libiec61883 CFLAGS:   $LIBIEC61883_CFLAGS
-  libiec61883 LIBS:     $LIBIEC61883_LIBS

branches/streaming-rework/src/bebob/bebob_avdevice.cpp

@@ -993 +993 @@
-        }
-
-        // FIXME: do this the proper way!
-        m_transmitProcessor->syncmaster=m_receiveProcessor;
-
-        if (!addPlugToProcessor(*inputPlug,m_transmitProcessor,
-            FreebobStreaming::AmdtpAudioPort::E_Playback)) {
@@ -1110 +1107 @@
-}
-
+// FIXME: error checking
-int
-AvDevice::startStreamByIndex(int i) {
@@ -1171 +1169 @@
-            break;
-        default:
-0
+-1
-        }
-//     }
-
+    if (iso_channel < 0) return -1;
+    
-    return 0;
-
-}
-
+// FIXME: error checking
-int
-AvDevice::stopStreamByIndex(int i) {

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

@@ -213 +213 @@
-DebugModuleManager::registerModule( DebugModule& debugModule )
-{
+    bool already_present=false;
+    
+    for ( DebugModuleVectorIterator it = m_debugModules.begin();
+          it != m_debugModules.end();
+          ++it )
+    {
+        if ( *it == &debugModule ) {
+            already_present=true;
+            return true;
+        }
+    }
+    
+    if (already_present) {
+        cerr << "DebugModuleManager::registerModule: Module already registered: "
+            << "DebugModule (" << debugModule.getName() << ")" << endl;
+    } else {
-        m_debugModules.push_back( &debugModule );
+    }
-    return true;
-}
@@ -220 +237 @@
-DebugModuleManager::unregisterModule( DebugModule& debugModule )
-{
+    
-    for ( DebugModuleVectorIterator it = m_debugModules.begin();
-          it != m_debugModules.end();

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

@@ -136 +136 @@
-#define CHECK_PREEMPTION(onoff)
-#endif
-
-// Intel recommends that a serializing instruction 
-// should be called before and after rdtsc. 
-// CPUID is a serializing instruction. 
-#define read_rdtsc(time) \
-        __asm__ __volatile__( \
-        "pushl %%ebx\n\t" \
-        "cpuid\n\t" \
-        "rdtsc\n\t" \
-        "mov %%eax,(%0)\n\t" \
-        "cpuid\n\t" \
-        "popl %%ebx\n\t" \
-        : /* no output */ \
-        : "S"(&time) \
-        : "eax", "ecx", "edx", "memory")
-
-static inline unsigned long debugGetCurrentTSC() {
-    unsigned retval;
-    read_rdtsc(retval);
-    return retval;
-}
-
-unsigned char toAscii( unsigned char c );

branches/streaming-rework/src/devicemanager.cpp

@@ -153 +153 @@
-    }
-
+#ifdef ENABLE_MOTU
-    if ( MAudio::AvDevice::probe( *configRom.get() ) ) {
-        return new MAudio::AvDevice( configRom, *m_1394Service, id, level );
-    }
-
+
-    if ( Motu::MotuDevice::probe( *configRom.get() ) ) {
-        return new Motu::MotuDevice( configRom, *m_1394Service, id, level );
@@ -168 +170 @@
-        return new Bounce::BounceDevice( configRom, *m_1394Service, id, level );
-    }
+#endif
-
-    return 0;

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

@@ -31 +31 @@
-#include "AmdtpPort.h"
-
-count
+tim
-
-#include <netinet/in.h>
-#include <assert.h>
-
-#define RECEIVE_PROCESSING_DELAY_IN_SAMPLES 100
-#define RECEIVE_DLL_INTEGRATION_COEFFICIENT 0.015
-
-(TICKS_PER_SECOND * 2/1000)
+51200
-
-// in ticks
-
+
+
-
-//#define DO_SYT_SYNC
@@ -80 +80 @@
-        }
-        
-
-        return true;
-}
@@ -97 +96 @@
-    unsigned int nevents=0;
-    
-packet->eoh0 = 0
+debugOutput(DEBUG_LEVEL_VERY_VERBOSE,"Xmit handler for cycle %d\n",cycle)
-    
-#ifdef DEBUG
@@ -121 +120 @@
-    m_running=true;
-    
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        // no-data packets have syt=0xFFFF
-
+(?)
-        packet->fdf = IEC61883_FDF_NODATA;
-        packet->syt = 0xffff;
@@ -133 +216 @@
-        m_dbc += m_syt_interval;
-
+        // 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);
+        
+        // this means no-data packets without payload
+        //*length = 2*sizeof(quadlet_t);
+        
-        *tag = IEC61883_TAG_WITH_CIP;
-        *sy = 0;
@@ -140 +228 @@
-    }
-    
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        packet->fdf = IEC61883_FDF_NODATA;
-        packet->syt = 0xffff;
-        
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
-
-        retval=RAW1394_ISO_DEFER;
-        *length=0;
-        nevents=0;
-
-
-    } else {
-        retval=RAW1394_ISO_OK;
-        *length = read_size + 8;
-
+
-        // process all ports that should be handled on a per-packet base
-        // this is MIDI for AMDTP (due to the need of DBC)
@@ -332 +273 @@
-            debugWarning("Problem encoding Packet Ports\n");
-        }
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-    return retval;
@@ -376 +306 @@
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-}
-
-bool AmdtpTransmitStreamProcessor::prefill() {
-
-    if(!transferSilence(m_ringbuffer_size_frames)) {
-        debugFatal("Could not prefill transmit stream\n");
@@ -412 +330 @@
-    }
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        return false;
-    }
-
-
-
-
-
-
-
-
-
+
-    return true;
-    
@@ -524 +436 @@
-    m_ringbuffer_size_frames=m_nb_buffers * m_period;
-    
-
-
+
+
+
+
+
-    
-    if( !(m_event_buffer=freebob_ringbuffer_create(
-            (m_dimension * m_ringbuffer_size_frames) * sizeof(quadlet_t)))) {
-        debugFatal("Could not allocate memory event ringbuffer");
-//              return -ENOMEM;
-        return false;
-    }
@@ -539 +453 @@
-        freebob_ringbuffer_free(m_event_buffer);
-        return false;
-//              return -ENOMEM;
-    }
-
@@ -633 +546 @@
-        return false;
-    }
-
-
+
+
+
+
+
+
-    if (!prefill()) {
-        debugFatal("Could not prefill buffers\n");
@@ -652 +569 @@
-}
-
+bool AmdtpTransmitStreamProcessor::prepareForStart() {
+
+    return true;
+}
+
+bool AmdtpTransmitStreamProcessor::prepareForStop() {
+    disable();
+    return true;
+}
+
+bool AmdtpTransmitStreamProcessor::prepareForEnable() {
+    uint64_t ts;
+    uint64_t fc;
+    
+    m_SyncSource->getBufferHeadTimestamp(&ts, &fc);
+
+    setBufferTailTimestamp(ts);
+    
+    return true;
+}
+
-bool AmdtpTransmitStreamProcessor::transferSilence(unsigned int size) {
-    /* a naive implementation would look like this: */
@@ -668 +606 @@
-}
-
-
+
+
+
+
+
+
-    m_PeriodStat.mark(freebob_ringbuffer_read_space(m_event_buffer)/(4*m_dimension));
-
-    debugOutput( DEBUG_LEVEL_VERY_VERBOSE, "Transferring period...\n");
-    // TODO: improve
-/* a naive implementation would look like this:
-
-    unsigned int write_size=m_period*sizeof(quadlet_t)*m_dimension;
-    char *dummybuffer=(char *)calloc(sizeof(quadlet_t),m_period*m_dimension);
-    transmitBlock(dummybuffer, m_period, 0, 0);
-
-    if (freebob_ringbuffer_write(m_event_buffer,(char *)(dummybuffer),write_size) < write_size) {
-        debugWarning("Could not write to event buffer\n");
-    }
-
-
-    free(dummybuffer);
-*/
-/* but we're not that naive anymore... */
-    int xrun;
-    unsigned int offset=0;
@@ -693 +621 @@
-    // we received one period of frames
-    // this is period_size*dimension of events
-m_period
+nbframes
-    int bytes2write=events2write*sizeof(quadlet_t);
-
@@ -709 +637 @@
-        int byteswritten=0;
-        
-m_period
+nbframes
-        offset=frameswritten;
-        
@@ -761 +689 @@
-                    // xrun detected
-                debugError("XMT: Frame buffer underrun in processor %p\n",this);
-
+ // FIXME: return false ?
-            }
-
@@ -771 +699 @@
-        assert(bytes2write%cluster_size==0);
-
+    }
+
+    // update the frame counter such that it reflects the new value,
+    // and also update the buffer tail timestamp
+    // done in the SP base class
+    debugOutput(DEBUG_LEVEL_VERBOSE, "StreamProcessor::putFrames(%d, %llu)\n",nbframes, ts);
+    
+    if (!StreamProcessor::putFrames(nbframes, ts)) {
+        debugError("Could not do StreamProcessor::putFrames(%d, %llu)\n",nbframes, ts);
+        return false;
-    }
-
@@ -859 +797 @@
-    
-    quadlet_t *target_event=NULL;
-
+unsigned 
-    
-    for ( PortVectorIterator it = m_PacketPorts.begin();
@@ -989 +927 @@
-
-AmdtpReceiveStreamProcessor::AmdtpReceiveStreamProcessor(int port, int framerate, int dimension)
-, m_one_period_passed(false)
+
-
-
@@ -1021 +959 @@
-    struct iec61883_packet *packet = (struct iec61883_packet *) data;
-    assert(packet);
-        unsigned long in_time=debugGetCurrentTSC();
-
-#ifdef DEBUG
@@ -1029 +966 @@
-#endif
-    
-    // how are we going to get this right???
-//     m_running=true;
-    
-    if((packet->fmt == 0x10) && (packet->fdf != 0xFF) && (packet->syt != 0xFFFF) && (packet->dbs>0) && (length>=2*sizeof(quadlet_t))) {
-        unsigned int nevents=((length / sizeof (quadlet_t)) - 2)/packet->dbs;
-        
-
-
-
-
-
-
-
-
-
-
+
-        m_last_timestamp2=m_last_timestamp;
-        
+        //=> convert the SYT to ticks
-        unsigned int syt_timestamp=ntohs(packet->syt);
+        
+        debugOutput(DEBUG_LEVEL_VERY_VERBOSE,"ch%2u: CY=%4u, SYT=%08X (%3u secs + %4u cycles + %04u ticks)\n",
+            channel, cycle,syt_timestamp, CYCLE_TIMER_GET_SECS(syt_timestamp), 
+            CYCLE_TIMER_GET_CYCLES(syt_timestamp), CYCLE_TIMER_GET_OFFSET(syt_timestamp));
+        
+        // reconstruct the full cycle
+        unsigned int cc=m_handler->getCycleTimer();
+        unsigned int cc_cycles=CYCLE_TIMER_GET_CYCLES(cc);
+        unsigned int cc_seconds=CYCLE_TIMER_GET_SECS(cc);
+        
+        // the cycletimer has wrapped since this packet was received
+        // we want cc_seconds to reflect the 'seconds' at the point this 
+        // was received
+        if (cycle>cc_cycles) {
+            if (cc_seconds) {
+                cc_seconds--;
+            } else {
+                // seconds has wrapped around, so we'd better not substract 1
+                // the good value is 127
+                cc_seconds=127;
+            }
+        }
+        
-        // reconstruct the top part of the timestamp using the current cycle number
-        unsigned int now_cycle_masked=cycle & 0xF;
-COUNT
+TIM
-        
-        // if this is true, wraparound has occurred, undo this wraparound
-        if(syt_cycle<now_cycle_masked) syt_cycle += 0x10;
-        
+        // this is the difference in cycles wrt the cycle the
+        // timestamp was received
-        unsigned int delta_cycles=syt_cycle-now_cycle_masked;
-        
@@ -1060 +1011 @@
-        unsigned int new_cycles=cycle + delta_cycles;
-        
-
-
+
+
+
+
+
+
+
+
+
-            
-            new_cycles-=8000; // wrap around
-
+
+
+
-        }
-        
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
-            
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
-            }
-
@@ -1096 +1049 @@
-            float err = f / (1.0*m_syt_interval) - m_ticks_per_frame;
-            
-08X | DLL: in=%5.0
+lluticks | DLL: in=%
-
-#ifdef DEBUG
+            // this helps to detect wraparound issues
-            if(f > 1.5*((TICKS_PER_SECOND*1.0) / m_framerate)*m_syt_interval) {
-                debugWarning("Timestamp diff more than 50%% of the nominal diff too large!\n");
-
+
+
+
+
-            }
-            if(f < 0.5*((TICKS_PER_SECOND*1.0) / m_framerate)*m_syt_interval) {
-                debugWarning("Timestamp diff more than 50%% of the nominal diff too small!\n");
-08X,%08X | DLL: in=%5.0
+llu,%llu | DLL: in=%
-            }
-#endif
-
-            // integrate the error
-            m_ticks_per_frame += RECEIVE_DLL_INTEGRATION_COEFFICIENT*err;
@@ -1116 +1072 @@
-         debugOutput(DEBUG_LEVEL_VERY_VERBOSE,"R-SYT for cycle (%2d %2d)=>%2d: %5uT (%04uC + %04uT) %04X %04X %d\n",
-            cycle,now_cycle_masked,delta_cycles,
-CYCLE_COUNTER_TO_TICKS
-CYCLE_COUNTER_GET
-CYCLE_COUNTER_GET
-ntohs(packet->syt),m_last_timestamp
+   
+   TICKS_TO
+   TICKS_TO
+   ntohs(packet->syt),TICKS_TO_CYCLE_TIMER(m_last_timestamp)
-         );
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
-        if(m_disabled) {
+            // we keep track of the timestamp here
+            // this makes sure that we will have a somewhat accurate
+            // estimate as to when a period might be ready. i.e. it will not
+            // be ready earlier than this timestamp + period time
+            
+            // the next (possible) sample is not this one, but lies 
+            // SYT_INTERVAL * rate later
+            uint64_t ts=m_last_timestamp+(uint64_t)((float)m_syt_interval * m_ticks_per_frame);
+            StreamProcessor::setBufferTimestamps(ts,ts);
+            
-            return RAW1394_ISO_DEFER;
-        }
-debugOutput( DEBUG_LEVEL_VERY_VERBOSE, "put packet...\n");
-
+
+//=> process the packet
-        unsigned int write_size=nevents*sizeof(quadlet_t)*m_dimension;
+        
-        // add the data payload to the ringbuffer
-        
-        if (freebob_ringbuffer_write(m_event_buffer,(char *)(data+8),write_size) < write_size) 
-        {
-            debugWarning("Receive buffer overrun (cycle %d, FC=%d, PC=%d)\n", 
-                 cycle, m_framecounter, m_handler->getPacketCount());
+            
-            m_xruns++;
-
@@ -1159 +1116 @@
-                retval=RAW1394_ISO_DEFER;
-            }
-
-        }
-
@@ -1176 +1132 @@
-#endif
-
-
-
-
-
-
+
+
+
+
+
+
-        }
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
-    
-    return retval;
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-}
-
@@ -1424 +1279 @@
-    freebob_ringbuffer_reset(m_event_buffer);
-    
-        // reset the last timestamp
-        m_last_timestamp=0;
-        
-    m_PeriodStat.reset();
-    m_PacketStat.reset();
-    m_WakeupStat.reset();
-
-
-
-
-
-
-
-
-
-
-
+
+
-
-    // reset all non-device specific stuff
@@ -1491 +1334 @@
-
-    // prepare the framerate estimate
-m_framerate
+((float)m_framerate)
-
-    debugOutput(DEBUG_LEVEL_VERBOSE,"Initializing remote ticks/frame to %f\n",m_ticks_per_frame);
@@ -1500 +1343 @@
-    // add the processing delay
-    debugOutput(DEBUG_LEVEL_VERBOSE,"Adding %u frames of SYT slack buffering...\n",
-RECEIVE_PROCESSING_DELAY_IN_SAMPLES
-RECEIVE_PROCESSING_DELAY_IN_SAMPLES
+(uint)(RECEIVE_PROCESSING_DELAY/m_ticks_per_frame)
+(uint)(RECEIVE_PROCESSING_DELAY/m_ticks_per_frame)
-    
-    if( !(m_event_buffer=freebob_ringbuffer_create(
@@ -1601 +1444 @@
-}
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-    m_PeriodStat.mark(freebob_ringbuffer_read_space(m_event_buffer)/(4*m_dimension));
@@ -1607 +1464 @@
-        debugOutput( DEBUG_LEVEL_VERY_VERBOSE, "Transferring period...\n");
-        
-/* another naive section:       
-        unsigned int read_size=m_period*sizeof(quadlet_t)*m_dimension;
-        char *dummybuffer=(char *)calloc(sizeof(quadlet_t),m_period*m_dimension);
-        if (freebob_ringbuffer_read(m_event_buffer,(char *)(dummybuffer),read_size) < read_size) {
-                debugWarning("Could not read from event buffer\n");
-        }
-
-        receiveBlock(dummybuffer, m_period, 0);
-
-        free(dummybuffer);
-*/
-        int xrun;
-        unsigned int offset=0;
@@ -1625 +1471 @@
-        // this is period_size*dimension of events
-
-m_period
+nbframes
-        int bytes2read=events2read*sizeof(quadlet_t);
-        /* read events2read bytes from the ringbuffer 
@@ -1638 +1484 @@
-        
-        while(bytes2read>0) {
-m_period
+nbframes
-                offset=framesread;
-                
@@ -1695 +1541 @@
-                assert(bytes2read%cluster_size==0);
-        }
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-}
-
@@ -1752 +1614 @@
-        
-        quadlet_t *target_event=NULL;
-
+unsigned 
-        
-        for ( PortVectorIterator it = m_PacketPorts.begin();

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

@@ -38 +38 @@
-#include <libiec61883/iec61883.h>
-#include "ringbuffer.h"
+#include <pthread.h>
-
-#define AMDTP_MAX_PACKET_SIZE 2048
@@ -88 +89 @@
-    bool reset();
-    bool prepare();
-
-
-
-
+
+
+
+
+
+
+
+
-
-    // We have 1 period of samples = m_period
@@ -103 +108 @@
-    
-    unsigned int getMaxPacketSize() {return 4 * (2 + m_syt_interval * m_dimension);}; 
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
-    
-protected:
@@ -177 +179 @@
-        bool reset();
-        bool prepare();
-
-
-
-
-
-
+
+
+
+
+
+
+
-    // We have 1 period of samples = m_period
-    // this period takes m_period/m_framerate seconds of time
@@ -194 +197 @@
-        unsigned int getMaxPacketSize() {return 4 * (2 + m_syt_interval * m_dimension);}; 
-
-    float getTicksPerFrame() {return m_ticks_per_frame;};
-    unsigned int getPeriodTimeStamp();
-    
-    void dumpInfo();
-    
+    int64_t getTimeUntilNextPeriodUsecs();
+
+    uint64_t getTimeAtPeriodUsecs();
+    uint64_t getTimeAtPeriod();
+        
+    void setVerboseLevel(int l);
+            
-protected:
-
@@ -211 +218 @@
-    unsigned int m_syt_interval;
-    
-
-
-
-
-
-
-
+
+
+
-    
-    DECLARE_DEBUG_MODULE;

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

@@ -27 +27 @@
- */
- 
-count
+ tim
-
-COUNT
-COUNT
+TIM
+TIM
-
-#define CSR_CYCLE_TIME            0x200
-#define CSR_REGISTER_BASE  0xfffff0000000ULL
-
-
-
-(CYCLES_PER_SECOND * TICKS_PER_CYCLE)
+U
+U
+ 24576000UL
-#define TICKS_PER_USEC     (TICKS_PER_SECOND/1000000.0)
-
-#define USECS_PER_TICK     (1.0/TICKS_PER_USEC)
-
-COUNTER_GET_SECS(x)   ((((x) & 0xFE000000
-COUNTER_GET_CYCLES(x) ((((x) & 0x01FFF000
-COUNTER_GET_OFFSET(x)  ((((x) & 0x00000FFF
-COUNTER_TO_TICKS(x) ((CYCLE_COUNT
-COUNT
-COUNT
+TIMER_GET_SECS(x)   ((((x) & 0xFE000000U
+TIMER_GET_CYCLES(x) ((((x) & 0x01FFF000U
+TIMER_GET_OFFSET(x)  ((((x) & 0x00000FFFU
+TIMER_TO_TICKS(x) ((CYCLE_TIM
+TIM
+TIM
-                                   
-// non-efficient versions, to be avoided in critical code
@@ -54 +54 @@
-#define TICKS_TO_OFFSET(x) (((x)%TICKS_PER_CYCLE))
-
-
-
+
+
+
+
+
+
+
+
+
-                                       + (CYCLES_PER_SECOND * TICKS_PER_CYCLE) \
-                                       + (TICKS_PER_CYCLE) \
-                                      )
+#define CYCLE_TIMER_WRAP_TICKS(x) ((x % TICKS_PER_SECOND))
-
-COUNT
+TIM

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

@@ -159 +159 @@
-
-        // we are ready!
-        
-        debugOutputShort(DEBUG_LEVEL_VERBOSE, "\n\n");
-        return dev;
@@ -191 +190 @@
-    debugOutput(DEBUG_LEVEL_VERBOSE,"------------- Start -------------\n");
-    
-        
-    // create the connections for all devices
-    // iterate over the found devices
@@ -207 +205 @@
-    }
-
-
-
-
+
+
+
+
+
+
-}
-
@@ -225 +226 @@
-            assert(device);
-                
-
-            int j=0;
-            for(j=0; j<device->getStreamCount();j++) {
@@ -250 +250 @@
-        static int xruns=0;
-                
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
-        if(dev->processorManager->waitForPeriod()) {
-                return dev->options.period_size;
-        } else {
-                debugWarning("XRUN detected\n");
+                
-                // do xrun recovery
-                
-                dev->processorManager->handleXrun();
-                xruns++;

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

@@ -29 +29 @@
-#include "IsoHandler.h"
-#include "IsoStream.h"
-
-
-
+
+
-#include "libutil/TimeSource.h"
-#include "libutil/SystemTimeSource.h"
@@ -39 +38 @@
-#include <assert.h>
-#include <unistd.h>
+#include <string.h>
-
-#include <iostream>
-using namespace std;
-
-
-
+
-#define CC_SLEEP_TIME_AFTER_FAILURE     10
-
-
-
+0
+
+.0
-#define CC_INIT_MAX_TRIES 10
-
@@ -96 +95 @@
-   : TimeSource(), m_handle(0), m_handle_util(0), m_port(port), 
-   m_buf_packets(400), m_max_packet_size(1024), m_irq_interval(-1),
-count
+tim
-   m_ticks_per_usec_dll_err2(0),
-
-
-
+,
+
+
-    m_TimeSource=new FreebobUtil::SystemTimeSource();
-}
@@ -108 +107 @@
-   m_buf_packets(buf_packets), m_max_packet_size( max_packet_size), 
-   m_irq_interval(irq), 
-count
+tim
-   m_ticks_per_usec_dll_err2(0),
-
-
-
+,
+
+
-    m_TimeSource=new FreebobUtil::SystemTimeSource();
-}
-
-IsoHandler::~IsoHandler() {
+
+// Don't call until libraw1394's raw1394_new_handle() function has been
+// fixed to correctly initialise the iso_packet_infos field.  Bug is
+// confirmed present in libraw1394 1.2.1.  In any case,
+// raw1394_destroy_handle() will do any iso system shutdown required.
+//     raw1394_iso_shutdown(m_handle);
+
-    if(m_handle) {
+        if (m_State == E_Running) {
-            stop();
+        }
+        
-        raw1394_destroy_handle(m_handle);
-    }
+    
-    if(m_handle_util) raw1394_destroy_handle(m_handle_util);
-    
-
+if (m_TimeSource) 
-}
-
@@ -131 +141 @@
-    debugOutput( DEBUG_LEVEL_VERBOSE, "IsoHandler (%p) enter...\n",this);
-
+    // check the state
+    if(m_State != E_Created) {
+        debugError("Incorrect state, expected E_Created, got %d\n",(int)m_State);
+        return false;
+    }
+    
+    // the main handle for the ISO traffic
-    m_handle = raw1394_new_handle_on_port( m_port );
-    if ( !m_handle ) {
-        if ( !errno ) {
-                       cerr << "libraw1394 not compatible" << endl
+            debugError("libraw1394 not compatible\n")
-        } else {
-                       perror( "IsoHandler::Initialize: Could not get 1394 handle"
-                       cerr << "Is ieee1394 and raw1394 driver loaded?" << endl
+            debugError("Could not get 1394 handle: %s", strerror(errno)
+            debugError("Are ieee1394 and raw1394 drivers loaded?")
-        }
-        return false;
@@ -147 +164 @@
-    if ( !m_handle_util ) {
-        if ( !errno ) {
-                       cerr << "libraw1394 not compatible" << endl
+            debugError("libraw1394 not compatible\n")
-        } else {
-                       perror( "IsoHandler::Initialize: Could not get 1394 handle"
-                       cerr << "Is ieee1394 and raw1394 driver loaded?" << endl
+            debugError("Could not get 1394 handle: %s", strerror(errno)
+            debugError("Are ieee1394 and raw1394 drivers loaded?")
-        }
-
-
-
+
+
+
+
-    raw1394_set_userdata(m_handle_util, static_cast<void *>(this));
-        
+    // bus reset handling
-    if(raw1394_busreset_notify (m_handle, RAW1394_NOTIFY_ON)) {
-        debugWarning("Could not enable busreset notification.\n");
-        debugWarning(" Error message: %s\n",strerror(errno));
-
-
+
+
+
-        raw1394_set_bus_reset_handler(m_handle, busreset_handler);
+    }
-
-    // initialize the local timesource
-    m_TimeSource_NbCycleWraps=0;
+    unsigned int new_timer;
+    
+#ifdef LIBRAW1394_USE_CTRREAD_API
+    struct raw1394_cycle_timer ctr;
+    int err;
+    err=raw1394_read_cycle_timer(m_handle_util, &ctr);
+    if(err) {
+        debugWarning("raw1394_read_cycle_timer: %s", strerror(err));
+    }
+    new_timer=ctr.cycle_timer;
+#else
+    // normally we should be able to use the same handle
+    // because it is not iterated on by any other stuff
+    // but I'm not sure
-    quadlet_t buf=0;
-    unsigned int new_counter;
-    
-    raw1394_read(m_handle_util, raw1394_get_local_id(m_handle_util), 
-        CSR_REGISTER_BASE | CSR_CYCLE_TIME, 4, &buf);
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    
-    return true;
@@ -185 +280 @@
-{
-    m_TimeSource=t;
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
-    return true;
-}
@@ -210 +298 @@
-    // as busreset can elect a new cycle master,
-    // we need to re-initialize our timing code
-Count
+Tim
-    
-    return 0;
@@ -216 +304 @@
-
-/**
-count
-
-count
+tim
+
+tim
- */
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-    // linear interpolation
@@ -231 +379 @@
-    float offset=m_ticks_per_usec * ((float)delta_usecs);
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
-
-    // if we need to wrap, do it
-
-
+L
+L
-    }
-    
@@ -245 +397 @@
-}
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    freebob_microsecs_t prev_usecs=m_lastmeas_usecs;
-nsigned int prev_ticks=m_cyclecount
+int64_t prev_ticks=m_cycletim
-    
-    freebob_microsecs_t new_usecs;
-nsigned in
-count
-
-count
-count
+int64_
+tim
+
+tim
+tim
-       on the system clock.
-       
@@ -270 +451 @@
-        Basically what we do is estimate the next point (T1,CC1_est)
-        based upon the previous point (T0, CC0) and the estimated rate (R).
-count
+tim
-        at T1 (=CC1_meas). We then calculate the estimation error on R:
-        err=(CC1_meas-CC0)/(T1-T2) - (CC1_est-CC0)/(T1-T2)
@@ -288 +469 @@
-        
-     */
-
+
+
+
+
+
+
+
+
+
+
-    // normally we should be able to use the same handle
-    // because it is not iterated on by any other stuff
-    // but I'm not sure
+    quadlet_t buf=0;
-    raw1394_read(m_handle_util, raw1394_get_local_id(m_handle_util), 
-        CSR_REGISTER_BASE | CSR_CYCLE_TIME, 4, &buf);
-    new_usecs=m_TimeSource->getCurrentTimeAsUsecs();
-
-
-
+
+
+
+
-
-    // the difference in system time
-
+64_t
-    // this cannot be 0, because m_TimeSource->getCurrentTimeAsUsecs should 
-    // never return the same value (maybe in future terrahz processors?)
-    assert(delta_usecs);
-    
-count
-unsigned in
-
+tim
+int64_
+=
-        delta_ticks_meas=new_ticks - prev_ticks;
-    } else { // wraparound
-COUNT
-
-
-count
-unsigned int delta_ticks_est=(unsigned in
+TIM
+
+
+tim
+int64_t delta_ticks_est=(int64_
-    
-    // the measured & estimated rate
-float)delta_ticks_meas/(float
+double)delta_ticks_meas/(double
-    float rate_est=((float)m_ticks_per_usec);
-    
@@ -338 +530 @@
-#ifdef DEBUG
-
- diff=(in
+64_t diff=(int64_
-        
-        // calculate the difference in predicted ticks and
@@ -345 +537 @@
-        
-        
- || diff < -24000
-d, dt_est=%u, dt_meas=%u, d=%
+L || diff < -24000L
+lld, dt_est=%lld, dt_meas=%lld, d=%ll
-                diff, delta_ticks_est, delta_ticks_meas, delta_usecs, (((float)diff)/24.576)
-                );
-        } else {
-d, dt_est=%u, dt_meas=%u, d=%
+lld, dt_est=%lld, dt_meas=%lld, d=%ll
-                diff, delta_ticks_est, delta_ticks_meas, delta_usecs, (((float)diff)/24.576)
-                );
@@ -379 +571 @@
-        
-        // update the internal values
-count
+tim
-        //       the estimated one, not the measured one!
-count
+tim
-        // if we need to wrap, do it
-counter_ticks > TICKS_PER_SECOND * 128
-counter_ticks -= TICKS_PER_SECOND * 128
+timer_ticks > TICKS_PER_SECOND * 128L
+timer_ticks -= TICKS_PER_SECOND * 128L
-        }
-
-        m_lastmeas_usecs = new_usecs;
-
-u -> %10u, d=%7uus, dt_est=%7u,  dt_meas=%7u
-count
+llu -> %10llu, d=%7lldus, dt_est=%7lld,  dt_meas=%7lld
+tim
-              delta_ticks_est, delta_ticks_meas, m_ticks_per_usec, rate_meas
-              );
@@ -405 +597 @@
-}
-
-
-
-
+
-    freebob_microsecs_t prev_usecs;
-    unsigned int prev_ticks;
-count
+tim
-    
-    freebob_microsecs_t new_usecs;
-    unsigned int new_ticks;
-count
+tim
-    
-    float rate=0.0;
@@ -428 +618 @@
-           || (rate < 24.576*(1.0-CC_MAX_RATE_ERROR)))) {
-           
+#ifdef LIBRAW1394_USE_CTRREAD_API
+        struct raw1394_cycle_timer ctr;
+        int err;
+        err=raw1394_read_cycle_timer(m_handle_util, &ctr);
+        if(err) {
+            debugWarning("raw1394_read_cycle_timer: %s", strerror(err));
+        }
+        prev_usecs=(freebob_microsecs_t)ctr.local_time;
+        prev_timer=ctr.cycle_timer;
+#else
-        // normally we should be able to use the same handle
-        // because it is not iterated on by any other stuff
-        // but I'm not sure
+        quadlet_t buf=0;
-        raw1394_read(m_handle_util, raw1394_get_local_id(m_handle_util), 
-            CSR_REGISTER_BASE | CSR_CYCLE_TIME, 4, &buf);
-        prev_usecs=m_TimeSource->getCurrentTimeAsUsecs();
-
-
-COUNTER_TO_TICKS(prev_count
+prev_timer= ntohl(buf) & 0xFFFFFFFF;
+
+TIMER_TO_TICKS(prev_tim
-        
-        usleep(CC_SLEEP_TIME_AFTER_UPDATE);
-        
+        
+#ifdef LIBRAW1394_USE_CTRREAD_API
+        err=raw1394_read_cycle_timer(m_handle_util, &ctr);
+        if(err) {
+            debugWarning("raw1394_read_cycle_timer: %s", strerror(err));
+        }
+        new_usecs=(freebob_microsecs_t)ctr.local_time;
+        new_timer=ctr.cycle_timer;
+#else
-        // normally we should be able to use the same handle
-        // because it is not iterated on by any other stuff
@@ -446 +656 @@
-            CSR_REGISTER_BASE | CSR_CYCLE_TIME, 4, &buf);
-        new_usecs=m_TimeSource->getCurrentTimeAsUsecs();
-
-
-
+
+
+
+
-        
-        unsigned int delta_ticks;
@@ -455 +666 @@
-            delta_ticks=new_ticks - prev_ticks;
-        } else { // wraparound
-COUNT
+TIM
-        }
-        
@@ -467 +678 @@
-        
-        // update the internal values
-count
+tim
-        m_lastmeas_usecs=new_usecs;
-        
@@ -478 +689 @@
-    // this is not fatal, the DLL will eventually correct this
-    if(try_cnt == CC_INIT_MAX_TRIES) {
-count
+tim
-    }
-    
@@ -495 +706 @@
-    debugOutputShort( DEBUG_LEVEL_NORMAL, "  Handler type    : %s\n",
-            (this->getType()==EHT_Receive ? "Receive" : "Transmit"));
-
+ 
-            m_port, channel);
-
+ 
-            this->getPacketCount(), this->getDroppedCount());
+            
-    #ifdef DEBUG
-Counter
-       debugOutputShort( DEBUG_LEVEL_NORMAL, "  Cycle counter
+TimerTicks
+    debugOutputShort( DEBUG_LEVEL_NORMAL, "  Cycle timer   
-            cc,TICKS_TO_SECS(cc),TICKS_TO_CYCLES(cc),TICKS_TO_OFFSET(cc));
+             
+/*  freebob_microsecs_t now=m_TimeSource->getCurrentTimeAsUsecs();
+    cc=mapToCycleTimer(now);
+    freebob_microsecs_t now_mapped=mapToTimeSource(cc);
+    
+    debugOutputShort( DEBUG_LEVEL_NORMAL, "  Mapping test   : now: %14llu, cc: %10lu, mapped now: %14llu\n",
+            now,cc,now_mapped);*/
-    #endif
-
+ 
-            this->getTicksPerUsec(), m_ticks_per_usec_dll_err2);
-
@@ -551 +770 @@
-/* The timesource interface */
-freebob_microsecs_t IsoHandler::getCurrentTime() {
-
-
-
-
-
-
-
+
+
+
-        
-    // this assumes that it never happens that there are more than 2
-    // minutes between calls
-COUNTER_GET_SECS(new_count
+TIMER_GET_SECS(new_tim
-        m_TimeSource_NbCycleWraps++;
-    }
-    
-
-COUNTER_TO_TICKS(new_count
-
-COUNTER_GET_SECS(new_count
+L
+TIMER_TO_TICKS(new_tim
+
+TIMER_GET_SECS(new_tim
-    
-    debugOutput(DEBUG_LEVEL_VERY_VERBOSE,"Wraps=%4u, LastSecs=%3u, nowSecs=%3u, ticks=%10u\n",
-              m_TimeSource_NbCycleWraps, m_TimeSource_LastSecs,
-COUNTER_GET_SECS(new_count
+TIMER_GET_SECS(new_tim
-              );
-              
-    return  ticks;
+}
+
+freebob_microsecs_t IsoHandler::unWrapTime(freebob_microsecs_t t) {
+    return CYCLE_TIMER_UNWRAP_TICKS(t);
+}
+
+freebob_microsecs_t IsoHandler::wrapTime(freebob_microsecs_t t) {
+    return CYCLE_TIMER_WRAP_TICKS(t);
-}
-
@@ -608 +831 @@
-IsoRecvHandler::~IsoRecvHandler()
-{
-
-
-
-
-
-
-
+
-}
-
@@ -628 +845 @@
-}
-
-
+
+
-                    unsigned char channel, unsigned char tag, unsigned char sy, 
-                    unsigned int cycle, unsigned int dropped) {
@@ -647 +865 @@
-bool IsoRecvHandler::prepare()
-{
-
-
-
-
+
+
+
+
+
-
-    debugOutput( DEBUG_LEVEL_VERBOSE, "Preparing iso receive handler (%p)\n",this);
@@ -658 +877 @@
-    debugOutput( DEBUG_LEVEL_VERBOSE, " Irq interval    : %d \n",m_irq_interval);
-
-
+
+
-                             m_buf_packets,
-                             m_max_packet_size,
@@ -676 +896 @@
-    debugOutput( DEBUG_LEVEL_VERBOSE, "start on cycle %d\n", cycle);
-    
+    // start the generic IsoHandler
+    if(!IsoHandler::start(cycle)) {
+        return false;
+    }
+    
-    if(raw1394_iso_recv_start(m_handle, cycle, -1, 0)) {
-        debugFatal("Could not start receive handler (%s)\n",strerror(errno));
@@ -723 +948 @@
-IsoXmitHandler::~IsoXmitHandler()
-{
-
-
-
-
-
-
-
+
-}
-
@@ -742 +961 @@
-
-    return true;
-
-}
-
-enum raw1394_iso_disposition IsoXmitHandler::getPacket(unsigned char *data, unsigned int *length,
-                              unsigned char *tag, unsigned char *sy,
-                              int cycle, unsigned int dropped) {
-
-        debugOutput( DEBUG_LEVEL_VERY_VERBOSE,
-                     "sending packet: length=%d, cycle=%d\n",
-                     *length, cycle );
-        m_packetcount++;
-        m_dropped+=dropped;
-
-        if(m_Client) {
-        return m_Client->getPacket(data, length, tag, sy, cycle, dropped, m_max_packet_size);
-        }
-        
-        return RAW1394_ISO_OK;
-}
-
@@ -766 +967 @@
-    debugOutput( DEBUG_LEVEL_VERBOSE, "Preparing iso transmit handler (%p, client=%p)\n",this,m_Client);
-
-
+
+
+
+
-    debugOutput( DEBUG_LEVEL_VERBOSE, " Buffers         : %d \n",m_buf_packets);
-    debugOutput( DEBUG_LEVEL_VERBOSE, " Max Packet size : %d \n",m_max_packet_size);
@@ -791 +995 @@
-{
-    debugOutput( DEBUG_LEVEL_VERBOSE, "start on cycle %d\n", cycle);
+    
+    if(!(IsoHandler::start(cycle))) {
+        return false;
+    }
+    
-    if(raw1394_iso_xmit_start(m_handle, cycle, m_prebuffers)) {
-        debugFatal("Could not start xmit handler (%s)\n",strerror(errno));
@@ -796 +1005 @@
-    }
-    return true;
+}
+
+enum raw1394_iso_disposition IsoXmitHandler::getPacket(
+                    unsigned char *data, unsigned int *length,
+                    unsigned char *tag, unsigned char *sy,
+                    int cycle, unsigned int dropped) {
+
+    debugOutput( DEBUG_LEVEL_VERY_VERBOSE,
+                    "sending packet: length=%d, cycle=%d\n",
+                    *length, cycle );
+    m_packetcount++;
+    m_dropped+=dropped;
+
+    if(m_Client) {
+        return m_Client->getPacket(data, length, tag, sy, cycle, dropped, m_max_packet_size);
+    }
+
+    return RAW1394_ISO_OK;
-}
-

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

@@ -68 +68 @@
-
-        virtual bool init();
+        virtual bool prepare();
+        virtual bool start(int cycle);
+        virtual bool stop();
-        
-        int iterate() { if(m_handle) return raw1394_loop_iterate(m_handle); else return -1; };
@@ -86 +89 @@
-        virtual enum EHandlerType getType() = 0;
-
-                virtual bool start(int cycle) = 0;
-                virtual bool stop();
-                
-        int getFileDescriptor() { return raw1394_get_fd(m_handle);};
-
@@ -102 +102 @@
-        int getPort() {return m_port;};
-
-
-
-
-
-
-
-
-
-
-Count
+
+
+
+
+
+
+
+
+
+Tim
-        float getTicksPerUsec() {return m_ticks_per_usec;};
-
@@ -125 +125 @@
-        int             m_irq_interval;
-        
-               unsigned int        m_cyclecount
-freebob_microsecs
+        uint64_t        m_cycletim
+uint64
-        float               m_ticks_per_usec;
-        float               m_ticks_per_usec_dll_err2;
@@ -145 +145 @@
-        static int busreset_handler(raw1394handle_t handle, unsigned int generation);
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-    // implement the TimeSource interface
@@ -151 +163 @@
-        freebob_microsecs_t getCurrentTime();
-        freebob_microsecs_t getCurrentTimeAsUsecs();
+        inline freebob_microsecs_t unWrapTime(freebob_microsecs_t t);
+        inline freebob_microsecs_t wrapTime(freebob_microsecs_t t);
+        
-    private:
-        // to cope with wraparound
@@ -173 +188 @@
-    
-        enum EHandlerType getType() { return EHT_Receive;};
-
-//              int registerStream(IsoStream *);
-//              int unregisterStream(IsoStream *);
-
-        bool start(int cycle);
@@ -216 +228 @@
-        
-        enum EHandlerType getType() { return EHT_Transmit;};
-
-//              int registerStream(IsoStream *);
-//              int unregisterStream(IsoStream *);
-
-        unsigned int getPreBuffers() {return m_prebuffers;};

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

@@ -32 +32 @@
-#include <assert.h>
-
-
-namespace FreebobStreaming
-{
@@ -39 +38 @@
-
-IsoHandlerManager::IsoHandlerManager() :
-
+
+
-{
-
@@ -57 +57 @@
-}
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
-bool IsoHandlerManager::Execute()
-{
-
-
+
+
+
+
+
+
-    
-    return true;
-}
-
+/**
+ * Poll the handlers managed by this manager, and iterate them
+ * when ready
+ *
+ * @return true when successful
+ */
-bool IsoHandlerManager::iterate()
-{
@@ -104 +125 @@
-}
-
-count
-Count
+tim
+Tim
-    debugOutput( DEBUG_LEVEL_VERY_VERBOSE, "enter...\n");
-    
@@ -113 +134 @@
-    {
-        int cnt=0;
-Count
+Tim
-            usleep(USLEEP_AFTER_UPDATE_FAILURE);
-        }
@@ -119 +140 @@
-    
-}
-
-bool IsoHandlerManager::prepare()
-{
-        debugOutput( DEBUG_LEVEL_VERBOSE, "enter...\n");
-    for ( IsoHandlerVectorIterator it = m_IsoHandlers.begin();
-          it != m_IsoHandlers.end();
-          ++it )
-    {
-        if(!(*it)->prepare()) {
-                        debugFatal("Could not prepare handlers\n");
-                        return false;
-        }
-    }
-
-        return true;
-}
-
-
-
-bool IsoHandlerManager::registerHandler(IsoHandler *handler)
@@ -205 +208 @@
-
-void IsoHandlerManager::disablePolling(IsoStream *stream) {
+    int i=0;
+    
-    debugOutput(DEBUG_LEVEL_VERY_VERBOSE, "Disable polling on stream %p\n",stream);
-
+
-    for ( IsoHandlerVectorIterator it = m_IsoHandlers.begin();
-        it != m_IsoHandlers.end();
@@ -216 +221 @@
-            debugOutput(DEBUG_LEVEL_VERY_VERBOSE, "polling disabled\n");
-        }
+        
-        i++;
-    }
-
-}
-
-void IsoHandlerManager::enablePolling(IsoStream *stream) {
+    int i=0;
+    
-    debugOutput(DEBUG_LEVEL_VERY_VERBOSE, "Enable polling on stream %p\n",stream);
-int i=0;
+
-    for ( IsoHandlerVectorIterator it = m_IsoHandlers.begin();
-        it != m_IsoHandlers.end();
@@ -233 +240 @@
-            debugOutput(DEBUG_LEVEL_VERY_VERBOSE, "polling enabled\n");
-        }
+        
-        i++;
-    }
@@ -478 +486 @@
-}
-
+
+bool IsoHandlerManager::prepare()
+{
+    bool retval=true;
+    
+    debugOutput( DEBUG_LEVEL_VERBOSE, "enter...\n");
+    
+    // check state
+    if(m_State != E_Created) {
+        debugError("Incorrect state, expected E_Created, got %d\n",(int)m_State);
+        return false;
+    }
+    
+    for ( IsoHandlerVectorIterator it = m_IsoHandlers.begin();
+          it != m_IsoHandlers.end();
+          ++it )
+    {
+        if(!(*it)->prepare()) {
+            debugFatal("Could not prepare handlers\n");
+            retval=false;
+        }
+    }
+
+    if (retval) {
+        m_State=E_Prepared;
+    } else {
+        m_State=E_Error;
+    }
+
+    return retval;
+}
+
-bool IsoHandlerManager::startHandlers() {
-    return startHandlers(-1);
@@ -483 +523 @@
-
-bool IsoHandlerManager::startHandlers(int cycle) {
+    bool retval=true;
+    
-    debugOutput( DEBUG_LEVEL_VERBOSE, "enter...\n");
+    
+    // check state
+    if(m_State != E_Prepared) {
+        debugError("Incorrect state, expected E_Prepared, got %d\n",(int)m_State);
+        return false;
+    }
-    
-    for ( IsoHandlerVectorIterator it = m_IsoHandlers.begin();
@@ -492 +540 @@
-        if(!(*it)->start(cycle)) {
-            debugOutput( DEBUG_LEVEL_VERBOSE, " could not start handler (%p)\n",*it);
-                       return 
+            retval=
-        }
-    }
-    
-
+
+
+
+
+
+
+
-}
-
-bool IsoHandlerManager::stopHandlers() {
-    debugOutput( DEBUG_LEVEL_VERBOSE, "enter...\n");
+    
+    // check state
+    if(m_State != E_Running) {
+        debugError("Incorrect state, expected E_Running, got %d\n",(int)m_State);
+        return false;
+    }
+    
+    bool retval=true;
-    
-    for ( IsoHandlerVectorIterator it = m_IsoHandlers.begin();
@@ -509 +571 @@
-        if(!(*it)->stop()){
-            debugOutput( DEBUG_LEVEL_VERBOSE, " could not stop handler (%p)\n",*it);
-                       return 
+            retval=
-        }
-    }
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-void IsoHandlerManager::setVerboseLevel(int i) {
@@ -527 +610 @@
-
-void IsoHandlerManager::dumpInfo() {
-        debugOutputShort( DEBUG_LEVEL_NORMAL, "Dumping IsoHandlerManager Stream handler information...\n");
-    int i=0;
-    
+    debugOutputShort( DEBUG_LEVEL_NORMAL, "Dumping IsoHandlerManager Stream handler information...\n");
+    debugOutputShort( DEBUG_LEVEL_NORMAL, " State: %d\n",(int)m_State);
+
-    for ( IsoHandlerVectorIterator it = m_IsoHandlers.begin();
-          it != m_IsoHandlers.end();

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

@@ -89 +89 @@
-        bool stopHandlers(); ///< stop the managed ISO handlers 
-
-               bool reset() {return true;}
+        bool reset()
-
-        bool prepare(); ///< prepare the ISO manager and all streams
@@ -96 +96 @@
-        void enablePolling(IsoStream *); ///< enables polling on a stream
-
-        public:
-        
-            
-    // RunnableInterface interface
+    public:
-        bool Execute(); // note that this is called in we while(running) loop
-        bool Init();
-        
-
-
+
-    private:
-
-
+
+
+
+
+
+
-        
+        enum EHandlerStates m_State;
+        
+    private:
+        /// iterate all child handlers
+        bool iterate();
+    public: // FIXME: just so that SPM can do this (temp solution)
+        /// updates the cycle timer caches of all child handlers
+        void updateCycleTimers();
+    private:
-        // note: there is a disctinction between streams and handlers
-        // because one handler can serve multiple streams (in case of 
@@ -134 +144 @@
-        bool rebuildFdMap();
-
-
+
-        DECLARE_DEBUG_MODULE;
-

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

@@ -30 +30 @@
-#include "PacketBuffer.h"
-#include <assert.h>
-
-
-namespace FreebobStreaming
@@ -83 +82 @@
-            m_port, m_channel);
-
-;
+
-
-bool IsoStream::setChannel(int c) {

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

@@ -28 +28 @@
- */
- 
+#ifdef ENABLE_MOTU
-
-#include "MotuStreamProcessor.h"
@@ -101 +102 @@
-        m_running = true;
-        
-count
+tim
-        // iso data has been requested.
-        if (!m_disabled && m_cycle_count<0) {
@@ -176 +177 @@
-                m_next_cycle -= 8000;
-
-count
+tim
-        unwrapped_cycle = cycle;
-        if (m_cycle_count-cycle > 7900)
@@ -843 +844 @@
-}
-
-d
+
-
-        // If the stream is disabled or isn't running there's no need to
@@ -894 +895 @@
-}
-
-d
+
-// Reset some critical variables required so the stream starts cleanly. This
-// method is called once on every stream restart, including those during
@@ -1523 +1524 @@
-}
-
-d
+
-
-        // A MOTU receive stream can stop at any time.  However, signify
@@ -1535 +1536 @@
-}
-
-d
+
-// Reset some critical variables required so the stream starts cleanly. This
-// method is called once on every stream restart, including those during
@@ -1556 +1557 @@
-                
-} // end of namespace FreebobStreaming
+#endif

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

@@ -35 +35 @@
-
-#include "../libutil/DelayLockedLoop.h"
+
+#ifdef ENABLE_MOTU
-
-namespace FreebobStreaming {
@@ -75 +77 @@
-        void setTicksPerFrameDLL(float *dll) {m_ticks_per_frame=dll;};
-
-d
-d
+
+
-
-protected:
@@ -165 +167 @@
-        unsigned int getEventSize(void);
-
-d
-d
+
+
-
-protected:
@@ -183 +185 @@
-        unsigned int m_event_size;
-
-        // The integrator of a Delay-Locked Loop (DLL) used to provide a
-        // continuously updated estimate of the number of ieee1394 frames
-        // per audio frame at the current sample rate.
-        float m_ticks_per_frame;
-
-        signed int m_last_cycle_ofs;
-        signed int m_next_cycle;
@@ -201 +198 @@
-} // end of namespace FreebobStreaming
-
+#endif /* ENABLE_MOTU */
+
-#endif /* __FREEBOB_MOTUSTREAMPROCESSOR__ */
-

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

@@ -46 +46 @@
-        , m_framecounter(0)
-        , m_framerate(framerate)
-
+
+
+
-        , m_running(false)
-        , m_disabled(true)
@@ -69 +71 @@
-    debugOutputShort( DEBUG_LEVEL_NORMAL, "  Enabled        : %d\n", !m_disabled);
-    
-
-
-
-
-
+
+
+
+
-}
-
@@ -80 +81 @@
-    debugOutput( DEBUG_LEVEL_VERY_VERBOSE, "enter...\n");
-    
+    pthread_mutex_init(&m_framecounter_lock, NULL);
+
-    return IsoStream::init();
-}
@@ -138 +141 @@
-}
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        return true;
-}
@@ -157 +188 @@
-}
-
+bool StreamProcessor::setSyncSource(StreamProcessor *s) {
+    m_SyncSource=s;
+    return true;
+}
+
-/**
- * Decrements the frame counter, in a atomic way. This
+ * also sets the buffer tail timestamp
- * is thread safe.
- */
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-}
-
@@ -177 +317 @@
- */
-void StreamProcessor::resetFrameCounter() {
-
+
+
+
-}
-

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

@@ -34 +34 @@
-#include "PortManager.h"
-#include "streamstatistics.h"
+
+#include <pthread.h>
-
-namespace FreebobStreaming {
@@ -73 +75 @@
-
-    bool xrunOccurred() { return (m_xruns>0);};
-
-    /**
-     * This is used for implementing the synchronisation.
-     * As long as this function doesn't return true, the current buffer
-     * contents are not transfered to the packet decoders.
-     *
-     * This means that there can be more events in the buffer than
-     * one period worth of them, should the synchronisation mechanism 
-     * require this
-     * @return 
-     */
-    virtual bool isOnePeriodReady()=0;
-    
-    unsigned int getNbPeriodsReady() { if(m_period) return m_framecounter/m_period; else return 0;};
-        virtual void decrementFrameCounter();
-        virtual void incrementFrameCounter(int nbframes);
-    
-    // move to private?
-        void resetFrameCounter();
-    void resetXrunCounter();
-
@@ -99 +84 @@
-    bool isEnabled() {return !m_disabled;};
-
-
+
+
-
-    virtual bool reset(); ///< reset the streams & buffers (e.g. after xrun)
@@ -111 +97 @@
-    virtual void setVerboseLevel(int l);
-
-
-
+
+
+
+
+
-
-protected:
@@ -124 +113 @@
-
-    unsigned int m_xruns;
-        signed int m_framecounter;
-
-    unsigned int m_framerate;
-
-    StreamProcessorManager *m_manager;
-
+
-    bool m_running;
-    bool m_disabled;
@@ -141 +129 @@
-    DECLARE_DEBUG_MODULE;
-    
+    // frame counter & sync stuff
+    public:
+        /**
+         * @brief Can this StreamProcessor handle a nframes of frames?
+         *
+         * this function indicates if the streamprocessor can handle nframes
+         * of frames. It is used to detect underruns-to-be.
+         *
+         * @param nframes number of frames 
+         * @return true if the StreamProcessor can handle this amount of frames
+         *         false if it can't
+         */
+        virtual bool canClientTransferFrames(unsigned int nframes) {return true;};
+        
+        int getFrameCounter() {return m_framecounter;};
+    
+        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();
+        
+        void setBufferTailTimestamp(uint64_t new_timestamp);
+        void setBufferHeadTimestamp(uint64_t new_timestamp);
+        void setBufferTimestamps(uint64_t new_head, uint64_t new_tail);
+        /**
+         * \brief return the time until the next period boundary (in microseconds)
+         *
+         * Return the time until the next period boundary. If this StreamProcessor 
+         * is the current synchronization source, this function is called to 
+         * determine when a buffer transfer can be made. When this value is
+         * smaller than 0, a period boundary is assumed to be crossed, hence a
+         * transfer can be made.
+         *
+         * \return the time in usecs
+         */
+        virtual int64_t getTimeUntilNextPeriodUsecs() = 0;
+        /**
+         * \brief return the time of the next period boundary (in microseconds)
+         *
+         * Returns the time of the next period boundary, in microseconds. The
+         * goal of this function is to determine the exact point of the period
+         * boundary. This is assumed to be the point at which the buffer transfer should
+         * take place, meaning that it can be used as a reference timestamp for transmitting
+         * StreamProcessors
+         *
+         * \return the time in usecs
+         */
+        virtual uint64_t getTimeAtPeriodUsecs() = 0;
+        
+        /**
+         * \brief return the time of the next period boundary (in internal units) 
+         *
+         * The same as getTimeUntilNextPeriodUsecs() but in internal units.
+         *
+         * @return the time in internal units
+         */
+        virtual uint64_t getTimeAtPeriod() = 0;
+        
+        void getBufferHeadTimestamp(uint64_t *ts, uint64_t *fc);
+        void getBufferTailTimestamp(uint64_t *ts, uint64_t *fc);
+                
+        bool setSyncSource(StreamProcessor *s);
+        float getTicksPerFrame() {return m_ticks_per_frame;};
+    
+    protected:
+        // the framecounter gives the number of frames in the buffer
+        signed int m_framecounter;
+        
+        // the buffer tail timestamp gives the timestamp of the last frame
+        // that was put into the buffer
+        uint64_t   m_buffer_tail_timestamp;
+        
+        // the buffer head timestamp gives the timestamp of the first frame
+        // that was put into the buffer
+        uint64_t   m_buffer_head_timestamp;
+        
+        
+        StreamProcessor *m_SyncSource;
+        
+        float m_ticks_per_frame;
+
+    private:
+        // this mutex protects the access to the framecounter
+        // and the buffer head timestamp.
+        pthread_mutex_t m_framecounter_lock;
-
-};

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

@@ -39 +39 @@
-
-StreamProcessorManager::StreamProcessorManager(unsigned int period, unsigned int nb_buffers)
-
+
+
-
-}
@@ -146 +147 @@
-}
-
+bool StreamProcessorManager::setSyncSource(StreamProcessor *s) {
+    m_SyncSource=s;
+    return true;
+}
+
+StreamProcessor *StreamProcessorManager::getSyncSource() {
+    return m_SyncSource;
+}
+
-bool StreamProcessorManager::init()
-{
-        debugOutput( DEBUG_LEVEL_VERBOSE, "enter...\n");
-
-
+
+
-        m_streamingThread=new FreebobUtil::PosixThread(this,
-           m_thread_realtime, m_thread_priority+5, 
@@ -169 +180 @@
-        m_isoManager->setVerboseLevel(getDebugLevel());
-        
-
-
-
-
-
-
-
-
-
-
-
+
+
+
-        m_isoManagerThread=new FreebobUtil::PosixThread(
-              m_isoManager, 
@@ -201 +204 @@
-
-    if(sem_init(&m_period_semaphore, 0, 0)) {
-               debugFatal( "Cannot init packet
+        debugFatal( "Cannot init period
-        debugFatal( " Error: %s\n",strerror(errno));
-        return false;
@@ -212 +215 @@
-
-        debugOutput( DEBUG_LEVEL_VERBOSE, "Preparing...\n");
-
+
+
+
+
+
+
-        for ( StreamProcessorVectorIterator it = m_ReceiveProcessors.begin();
-                it != m_ReceiveProcessors.end();
-                ++it ) {
+                        if(m_SyncSource == NULL) {
+                                debugWarning(" => Sync Source is %p.\n", *it);
+                                m_SyncSource = *it;
+                        }
+        }
+
+        for ( StreamProcessorVectorIterator it = m_TransmitProcessors.begin();
+                it != m_TransmitProcessors.end();
+                ++it ) {
+                        if(m_SyncSource == NULL) {
+                                debugWarning(" => Sync Source is %p.\n", *it);
+                                m_SyncSource = *it;
+                        }
+        }
+
+        // now do the actual preparation
+        debugOutput( DEBUG_LEVEL_VERBOSE, "Prepare Receive processors...\n");
+        for ( StreamProcessorVectorIterator it = m_ReceiveProcessors.begin();
+                it != m_ReceiveProcessors.end();
+                ++it ) {
+                        if(!(*it)->setSyncSource(m_SyncSource)) {
+                                debugFatal(  " could not set sync source (%p)...\n",(*it));
+                                return false;
+                        }
+                        
-                        if(!(*it)->prepare()) {
-                                debugFatal(  " could not prepare (%p)...\n",(*it));
-                                return false;
-
-
-
-
-
+
+
+
+
-        for ( StreamProcessorVectorIterator it = m_TransmitProcessors.begin();
-                it != m_TransmitProcessors.end();
-                ++it ) {
+                        if(!(*it)->setSyncSource(m_SyncSource)) {
+                                debugFatal(  " could not set sync source (%p)...\n",(*it));
+                                return false;
+                        }               
-                        if(!(*it)->prepare()) {
-                                debugFatal( " could not prepare (%p)...\n",(*it));
-                                return false;
-
-
-
-
+
+
-
-    // if there are no stream processors registered, 
@@ -245 +279 @@
-}
-
+// FIXME: this can be removed
-bool StreamProcessorManager::Execute()
-{
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
-        
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
-}
-
@@ -335 +301 @@
-                it != m_ReceiveProcessors.end();
-                ++it ) {
-d
+
-                                debugOutput(DEBUG_LEVEL_VERBOSE,"Receive stream processor (%p) failed to prepare for start\n", *it);
-                                return false;
@@ -343 +309 @@
-                                return false;
-                        }
-                        
-                        
-                }
-
@@ -351 +315 @@
-                it != m_TransmitProcessors.end();
-                ++it ) {
-d
+
-                                debugOutput(DEBUG_LEVEL_VERBOSE,"Transmit stream processor (%p) failed to prepare for start\n", *it);
-                                return false;
@@ -359 +323 @@
-                                return false;
-                        }
-                        
-                }
-
@@ -368 +331 @@
-        }
-
-
+
+
+
+
+
+
+
-        if (!m_isoManager->startHandlers(0)) {
-                debugFatal("Could not start handlers...\n");
@@ -374 +343 @@
-        }
-        
-
-
+
+
+
+
-        // start the runner thread
+        // FIXME: maybe this should go into the isomanager itself.
+        m_isoManagerThread->Start();
+        
+        // start the runner thread
+        // FIXME: not used anymore (for updatecycletimers ATM, but that's not good)
-        m_streamingThread->Start();
-        
-        // start the runner thread
-        m_isoManagerThread->Start();
-
-        debugOutput( DEBUG_LEVEL_VERBOSE, "Waiting for all StreamProcessors to start running...\n");
@@ -434 +407 @@
-        
-        // now we reset the frame counters
-        // FIXME: check how we are going to do sync
-        for ( StreamProcessorVectorIterator it = m_ReceiveProcessors.begin();
-                it != m_ReceiveProcessors.end();
@@ -467 +439 @@
-        
-        debugOutput( DEBUG_LEVEL_VERBOSE, "Enabling StreamProcessors...\n");
-// and we enable the streamprocessors
-for ( StreamProcessorVectorIterator it = m_ReceiveProcessors.begin(
-
-++it ) {               
-(*it)->enable()
-       m_isoManager->enablePolling(*it);
-}
-
-
-       it != m_TransmitProcessors.end(
-               ++it 
-(*it)->enable(
-m_isoManager->enablePolling(*it)
+
+debugOutput( DEBUG_LEVEL_VERBOSE, " Sync Source StreamProcessor...\n"
+
+debugFatal("Could not prepare Sync Source StreamProcessor for enable()...\n");
+return false
+}
+
+
+
+debugOutput( DEBUG_LEVEL_VERBOSE, " All StreamProcessors...\n"
+        if (!enableStreamProcessors()
+debugFatal("Could not enable StreamProcessors...\n"
+return false
-        }
-        
@@ -509 +481 @@
-                        it != m_ReceiveProcessors.end();
-                        ++it ) {
-d
+
-                }
-        
@@ -515 +487 @@
-                        it != m_TransmitProcessors.end();
-                        ++it ) {
-d
+
-                }
-                usleep(1000);
@@ -560 +532 @@
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        return true;
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-bool StreamProcessorManager::handleXrun() {
-
@@ -583 +589 @@
-        /* 
-         * Reset means:
-
+
+
-         * 2) Bringing all buffers & streamprocessors into a know state
-         *    - Clear all capture buffers
-         *    - Put nb_periods*period_size of null frames into the playback buffers
-starting the packetizer thread
+-enable the SP's
-         */
-Stopping processormanager
-       if(!stop
-   debugFatal("Could not stop
+Disabling StreamProcessors
+        if (!disableStreamProcessors
+       debugFatal("Could not disable StreamProcessors..
-                return false;
-        }
@@ -597 +604 @@
-        debugOutput( DEBUG_LEVEL_VERBOSE, "Resetting Processors...\n");
-        
-frame counte
+streamprocesso
-        for ( StreamProcessorVectorIterator it = m_ReceiveProcessors.begin();
-                it != m_ReceiveProcessors.end();
@@ -611 +618 @@
-                        (*it)->dumpInfo();
-                }
-                
-        }
-        
@@ -629 +635 @@
-        }
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-        debugOutput( DEBUG_LEVEL_VERBOSE, "Xrun handled...\n");
-        
-        
-        return true;
-}
-
+/**
+ * @brief Waits until the next period of samples is ready
+ *
+ * This function does not return until a full period of samples is (or should be)
+ * ready to be transferred. 
+ *
+ * @return true if the period is ready, false if an xrun occurred
+ */
+bool StreamProcessorManager::waitForPeriod() {
+    int time_till_next_period;
+    
+    debugOutput( DEBUG_LEVEL_VERY_VERBOSE, "enter...\n");
+
+    assert(m_SyncSource);
+    
+    time_till_next_period=m_SyncSource->getTimeUntilNextPeriodUsecs();
+    
+    while(time_till_next_period > 0) {
+        debugOutput( DEBUG_LEVEL_VERY_VERBOSE, "waiting for %d usecs...\n", time_till_next_period);
+    
+        // wait for the period
+        usleep(time_till_next_period);
+        
+        // check if it is still true
+        time_till_next_period=m_SyncSource->getTimeUntilNextPeriodUsecs();
+    }
+    
+    debugOutput( DEBUG_LEVEL_VERY_VERBOSE, "delayed for %d usecs...\n", time_till_next_period);
+    
+    // this is to notify the client of the delay 
+    // that we introduced 
+    m_delayed_usecs=time_till_next_period;
+    
+    // we save the 'ideal' time of the transfer at this point,
+    // because we can have interleaved read - process - write 
+    // cycles making that we modify a receiving stream's buffer
+    // before we get to writing.
+    // NOTE: before waitForPeriod() is called again, both the transmit
+    //       and the receive processors should have done their transfer.
+    m_time_of_transfer=m_SyncSource->getTimeAtPeriod();
+    debugOutput( DEBUG_LEVEL_VERBOSE, "transfer at %llu ticks...\n", 
+        m_time_of_transfer);
+    
+    // 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();
+          it != m_ReceiveProcessors.end();
+          ++it ) {
+        // a xrun has occurred on the Iso side
+        xrun_occurred |= (*it)->xrunOccurred();
+        
+        // if this is true, a xrun will occur
+        xrun_occurred |= !((*it)->canClientTransferFrames(m_period));
+        
+#ifdef DEBUG
+        if ((*it)->xrunOccurred()) {
+            debugWarning("Xrun on RECV SP %p due to ISO xrun\n",*it);
+        }
+        if (!((*it)->canClientTransferFrames(m_period))) {
+            debugWarning("Xrun on RECV SP %p due to buffer xrun\n",*it);
+        }
+#endif
+        
+    }
+    for ( StreamProcessorVectorIterator it = m_TransmitProcessors.begin();
+          it != m_TransmitProcessors.end();
+          ++it ) {
+        // a xrun has occurred on the Iso side
+        xrun_occurred |= (*it)->xrunOccurred();
+        
+        // if this is true, a xrun will occur
+        xrun_occurred |= !((*it)->canClientTransferFrames(m_period));
+        
+#ifdef DEBUG
+        if ((*it)->xrunOccurred()) {
+            debugWarning("Xrun on XMIT SP %p due to ISO xrun\n",*it);
+        }
+        if (!((*it)->canClientTransferFrames(m_period))) {
+            debugWarning("Xrun on XMIT SP %p due to buffer xrun\n",*it);
+        }
+#endif        
+    }
+    
+    // now we can signal the client that we are (should be) ready
+    return !xrun_occurred;
+}
+
+/**
+ * @brief Transfer one period of frames for both receive and transmit StreamProcessors
+ *
+ * Transfers one period of frames from the client side to the Iso side and vice versa.
+ *
+ * @return true if successful, false otherwise (indicates xrun).
+ */
-bool StreamProcessorManager::transfer() {
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-bool StreamProcessorManager::transfer(enum StreamProcessor::EProcessorType t) {
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-}
-

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

@@ -54 +54 @@
-                        public FreebobUtil::RunnableInterface {
-
-        friend class StreamRunner;
-
-public:
-
@@ -64 +62 @@
-    bool prepare(); ///< to be called after the processors are registered
-
-
-
+
+
+
-
-    // this is the setup API
-    bool registerProcessor(StreamProcessor *processor); ///< start managing a streamprocessor
-    bool unregisterProcessor(StreamProcessor *processor); ///< stop managing a streamprocessor
+
+    bool enableStreamProcessors(); /// enable registered StreamProcessors
+    bool disableStreamProcessors(); /// disable registered StreamProcessors
-
-    void setPeriodSize(unsigned int period);
@@ -83 +85 @@
-
-    // the client-side functions
-    bool xrunOccurred();
-    int getXrunCount() {return m_xruns;};
-
-    bool waitForPeriod(); ///< wait for the next period
@@ -90 +90 @@
-    bool transfer(); ///< transfer the buffer contents from/to client
-    bool transfer(enum StreamProcessor::EProcessorType); ///< transfer the buffer contents from/to client (single processor type)
-
+
+
+
+
+
+
+
+
+
+
+
+
+
-    bool handleXrun(); ///< reset the streams & buffers after xrun
-
-    bool start();
-    bool stop();
-
-    bool setThreadParameters(bool rt, int priority);
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
-protected:
-    int signalWaiters(); // call this to signal a period boundary
@@ -116 +137 @@
-    StreamProcessorVector m_ReceiveProcessors;
-    StreamProcessorVector m_TransmitProcessors;
+    
+
-
-    unsigned int m_nb_buffers;

branches/streaming-rework/src/libutil/cycles.h

@@ -32 +32 @@
-
-/*
-count
+tim
- * Currently only used on SMP.
- *

branches/streaming-rework/src/libutil/SystemTimeSource.cpp

@@ -35 +35 @@
-
-SystemTimeSource::SystemTimeSource() {
-
+// 
-}
-
@@ -43 +43 @@
-    
-freebob_microsecs_t SystemTimeSource::getCurrentTime() {
-
+
+
+
+
+
-}
-

branches/streaming-rework/src/libutil/SystemTimeSource.h

@@ -46 +46 @@
-    freebob_microsecs_t getCurrentTime();
-    freebob_microsecs_t getCurrentTimeAsUsecs();
+    inline freebob_microsecs_t unWrapTime(freebob_microsecs_t t) {return t;};
+    inline freebob_microsecs_t wrapTime(freebob_microsecs_t t) {return t;};
-
-protected:

branches/streaming-rework/src/libutil/Time.h

@@ -72 +72 @@
-        struct timespec ts;
-        clock_gettime(CLOCK_MONOTONIC, &ts);
-
+LL
-    }
-#endif

branches/streaming-rework/src/libutil/TimeSource.cpp

@@ -30 +30 @@
-#include "TimeSource.h"
-
+#include <time.h>
+
+#include <assert.h>
+
-#include "libutil/Time.h"
-
-namespace FreebobUtil {
-
-
+
+
+
+
+
+
-
-}
@@ -41 +50 @@
-
-}
+/**
+ * (re)Initializes the TimeSource
+ *
+ * @return true if successful
+ */
+void TimeSource::initSlaveTimeSource() {
+    freebob_microsecs_t my_time;
+    freebob_microsecs_t master_time;
+    freebob_microsecs_t my_time2;
+    freebob_microsecs_t master_time2;
+    
+    if (m_Master) {
+        my_time=getCurrentTime();
+        master_time=m_Master->getCurrentTime();
+        
+        struct timespec ts;
+        
+        // sleep for ten milliseconds
+        ts.tv_sec=0;
+        ts.tv_nsec=10000000L;
+        
+        nanosleep(&ts,NULL);
+        
+        my_time2=getCurrentTime();
+        master_time2=m_Master->getCurrentTime();
+        
+        float diff_slave=my_time2-my_time;
+        float diff_master=master_time2-master_time;
+        
+        m_slave_rate=diff_slave/diff_master;
+        
+        // average of the two offset estimates
+        m_slave_offset  = my_time-wrapTime((freebob_microsecs_t)(master_time*m_slave_rate));
+        m_slave_offset += my_time2-wrapTime((freebob_microsecs_t)(master_time2*m_slave_rate));
+        m_slave_offset /= 2;
+        
+        m_last_master_time=master_time2;
+        m_last_time=my_time2;
+
+        debugOutput(DEBUG_LEVEL_NORMAL,"init slave: master=%lu, master2=%lu, diff=%f\n",
+            master_time, master_time2, diff_master);
+        debugOutput(DEBUG_LEVEL_NORMAL,"init slave: slave =%lu, slave2 =%lu, diff=%f\n",
+            my_time, my_time2, diff_slave);
+        debugOutput(DEBUG_LEVEL_NORMAL,"init slave: slave rate=%f, slave_offset=%lu\n",
+            m_slave_rate, m_slave_offset
+            );                
+    }
+    
+
+}
+
+/**
+ * Maps a time point of the master to a time point 
+ * on it's own timeline
+ *
+ * @return the mapped time point
+ */
+freebob_microsecs_t TimeSource::mapMasterTime(freebob_microsecs_t master_time) {
+    if(m_Master) {
+        // calculate the slave based upon the master
+        // and the estimated rate
+        
+        // linear interpolation
+        int delta_master=master_time-m_last_master_time;
+    
+        float offset=m_slave_rate * ((float)delta_master);
+        
+        freebob_microsecs_t mapped=m_last_time+(int)offset;
+        
+        debugOutput(DEBUG_LEVEL_VERY_VERBOSE,"map time: master=%d, offset=%f, slave_base=%lu, pred_ticks=%lu\n",
+            master_time, offset, m_last_time,mapped
+            );
+        
+        return wrapTime(mapped);
+        
+    } else {
+        debugOutput( DEBUG_LEVEL_VERBOSE, "Requested map for non-slave TimeSource\n");
+        
+        return master_time;
+    }
+}
+
+/**
+ * Update the internal state of the TimeSource
+ *
+ */
+bool TimeSource::updateTimeSource() {
+    // update all slaves
+    for ( TimeSourceVectorIterator it = m_Slaves.begin();
+          it != m_Slaves.end(); ++it ) {
+          
+        // update the slave with the current 
+        // master time
+        if (!(*it)->updateTimeSource()) return false;
+    }
+    
+    // this TimeSource has a master
+    if(m_Master) {
+        freebob_microsecs_t my_time=getCurrentTime();
+        freebob_microsecs_t master_time=m_Master->getCurrentTime();
+    
+        // we assume that the master and slave time are 
+        // measured at the same time, but that of course is
+        // not really true. The DLL will have to filter this
+        // out.
+        
+        // the difference in master time
+        int64_t delta_master;
+        if (master_time > m_last_master_time) {
+            delta_master=master_time-m_last_master_time;
+        } else { // wraparound
+            delta_master=m_Master->unWrapTime(master_time)-m_last_master_time;
+        }
+        
+        // the difference in slave time
+        int64_t delta_slave;
+        if (my_time > m_last_time) {
+            delta_slave=my_time-m_last_time;
+        } else { // wraparound
+            delta_slave=unWrapTime(my_time)-m_last_time;
+        }
+        
+        // the estimated slave difference
+        int delta_slave_est=(int)(m_slave_rate * ((double)delta_master));
+        
+        // the measured & estimated rate
+        double rate_meas=((double)delta_slave/(double)delta_master);
+        double rate_est=((double)m_slave_rate);
+        
+        m_last_err=(rate_meas-rate_est);
+        
+        m_slave_rate += 0.01*m_last_err;
+        
+        debugOutput(DEBUG_LEVEL_VERBOSE,"update slave: master=%llu, master2=%llu, diff=%lld\n",
+            master_time, m_last_master_time, delta_master);
+        debugOutput(DEBUG_LEVEL_VERBOSE,"update slave: slave =%llu, slave2 =%llu, diff=%lld, diff_est=%d\n",
+            my_time, m_last_time, delta_slave, delta_slave_est);
+        debugOutput(DEBUG_LEVEL_VERBOSE,"update slave: slave rate meas=%f, slave rate est=%f, err=%f, slave rate=%f\n",
+            rate_meas, rate_est, m_last_err, m_slave_rate
+            );
+
+        
+        m_last_master_time=master_time;
+        
+        int64_t tmp = delta_slave_est;
+        tmp += m_last_time;
+        
+        m_last_time = tmp;
+        
+
+            
+    }
+
+    return true;
+}
+
+/**
+ * Sets the master TimeSource for this timesource.
+ * This TimeSource will sync to the master TimeSource,
+ * making that it will be able to map a time point of 
+ * the master to a time point on it's own timeline
+ *
+ * @param ts master TimeSource  
+ * @return true if successful
+ */
+bool TimeSource::setMaster(TimeSource *ts) {
+    if (m_Master==NULL) {
+        m_Master=ts;
+        
+        // initialize ourselves.
+        initSlaveTimeSource();
+        
+        return true;
+    } else return false;
+}
+
+/**
+ * Clears the master TimeSource for this timesource.
+ *
+ * @return true if successful
+ */
+void TimeSource::clearMaster() {
+    m_Master=NULL;
+}
+
+/**
+ * Registers a slave timesource to this master.
+ * A slave TimeSource will sync to this TimeSource,
+ * making that it will be able to map a time point of 
+ * the master (this) TimeSource to a time point on 
+ * it's own timeline
+ *
+ * @param ts slave TimeSource to register
+ * @return true if successful
+ */
+bool TimeSource::registerSlave(TimeSource *ts) {
+    // TODO: we should check for circular master-slave relationships.
+    
+    debugOutput( DEBUG_LEVEL_VERBOSE, "Registering slave (%p)\n", ts);
+    assert(ts);
+    
+    // inherit debug level
+    ts->setVerboseLevel(getDebugLevel()); 
+    
+    if(ts->setMaster(this)) {
+        m_Slaves.push_back(ts);
+        return true;
+    } else {
+        return false;
+    }
+}
+
+/**
+ * Unregisters a slave TimeSource
+ *
+ * @param ts slave TimeSource to unregister
+ * @return true if successful
+ */
+bool TimeSource::unregisterSlave(TimeSource *ts) {
+    debugOutput( DEBUG_LEVEL_VERBOSE, "Unregistering TimeSource (%p)\n", ts);
+    assert(ts);
+
+    for ( TimeSourceVectorIterator it = m_Slaves.begin();
+          it != m_Slaves.end(); ++it ) {
+
+        if ( *it == ts ) { 
+            m_Slaves.erase(it);
+            ts->clearMaster();
+            return true;
+        }
+    }
+    
+    debugOutput( DEBUG_LEVEL_VERBOSE, " TimeSource (%p) not found\n", ts);
+    
+    return false;
+}
+
+/**
+ * Set verbosity level.
+ * All slave timesources get the same verbosity level
+ *
+ * @param l verbosity level
+ */
+void TimeSource::setVerboseLevel(int l) {
+    setDebugLevel(l);
+
+    for ( TimeSourceVectorIterator it = m_Slaves.begin();
+          it != m_Slaves.end(); ++it ) {
+        
+        (*it)->setVerboseLevel(l);
+    }
+
+}
+
+void TimeSource::printTimeSourceInfo() {
+    debugOutputShort( DEBUG_LEVEL_NORMAL, "TimeSource (%p) info\n", this);
+    debugOutputShort( DEBUG_LEVEL_NORMAL, "  Master           : %p\n", m_Master);
+    debugOutputShort( DEBUG_LEVEL_NORMAL, "  Slave rate       : %f\n", m_slave_rate);
+    debugOutputShort( DEBUG_LEVEL_NORMAL, "  Slave offset     : %lld\n", m_slave_offset);
+    debugOutputShort( DEBUG_LEVEL_NORMAL, "  Last error       : %f\n", m_last_err);
+    debugOutputShort( DEBUG_LEVEL_NORMAL, "  Last master time : %llu\n",m_last_master_time );
+    debugOutputShort( DEBUG_LEVEL_NORMAL, "  Last slave time  : %llu\n",m_last_time );
+
+   
+    for ( TimeSourceVectorIterator it = m_Slaves.begin();
+          it != m_Slaves.end(); ++it ) {
+        
+        (*it)->printTimeSourceInfo();
+    }
+}
-
-} // end of namespace FreebobUtil

branches/streaming-rework/src/libutil/TimeSource.h

@@ -31 +31 @@
-#include "../debugmodule/debugmodule.h"
-
+#include <vector>
+
-typedef uint64_t freebob_microsecs_t;
-
-namespace FreebobUtil {
-
+class TimeSource;
+typedef std::vector<TimeSource *> TimeSourceVector;
+typedef std::vector<TimeSource *>::iterator TimeSourceVectorIterator;
+
+/*!
+\brief The base class for all TimeSource's.
+
+    Any object that can act as a source of timing 
+    information should subclass this class and implement
+    its virtual functions.
+    
+    A TimeSource can be slaved to another TimeSource, allowing
+    the mapping of the master's time to the slave's time.
+*/
-class TimeSource {
-
@@ -44 +60 @@
-    virtual freebob_microsecs_t getCurrentTime()=0;
-    virtual freebob_microsecs_t getCurrentTimeAsUsecs()=0;
+    virtual freebob_microsecs_t unWrapTime(freebob_microsecs_t t)=0;
+    virtual freebob_microsecs_t wrapTime(freebob_microsecs_t t)=0;
+    
+    freebob_microsecs_t mapMasterTime(freebob_microsecs_t t);
+    
+    bool updateTimeSource();
+    
+    bool registerSlave(TimeSource *ts);
+    bool unregisterSlave(TimeSource *ts);
+
+    virtual void setVerboseLevel(int l);
+    
+    virtual void printTimeSourceInfo();
-    
-protected:
+
+private:
+    bool setMaster(TimeSource *ts);
+    void clearMaster();
+    
+    void initSlaveTimeSource();
+    
+    TimeSource * m_Master;
+    TimeSourceVector m_Slaves;
+    
+    freebob_microsecs_t m_last_master_time;
+    freebob_microsecs_t m_last_time;
+    
+    double m_slave_rate;
+    int64_t m_slave_offset;
+    double m_last_err;
+    
+    DECLARE_DEBUG_MODULE;
-
-};

branches/streaming-rework/src/Makefile.am

@@ -27 +27 @@
-libfreebob_la_LIBADD = -lrt
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-libfreebob_la_SOURCES = \
-        iavdevice.h                                     \
-        configrom.cpp \
-        csr1212.c \
@@ -43 +53 @@
-        freebob.cpp \
-        xmlparser.c \
-        threads.h                                       \
-        bebob/bebob_avdevice.h                          \
-        bebob/bebob_avdevice.cpp \
-        bebob/bebob_avdevice_xml.cpp                    \
-        bebob/bebob_avdevice_subunit.h                  \
-        bebob/bebob_avdevice_subunit.cpp \
-       bebob/bebob_avplug.h                            
+        bebob/bebob_avdevice_xml.cpp 
-        bebob/bebob_avplug.cpp \
-        bebob/bebob_avplug_xml.cpp \
-        bebob/bebob_functionblock.h                     \
-        bebob/bebob_functionblock.cpp                   \
-        bebob/bebob_dl_mgr.h                            \
-        bebob/bebob_dl_mgr.cpp                          \
-        bebob/bebob_dl_codes.h                          \
-        bebob/bebob_dl_codes.cpp                        \
-        bebob/bebob_dl_bcd.h                            \
-        bebob/bebob_dl_bcd.cpp \
-
-
-
-
-
+
+
+
-        bounce/bounce_avdevice.cpp \
-        maudio/maudio_avdevice.h                        \
-        maudio/maudio_avdevice.cpp \
+        motu/motu_avdevice.cpp \
+        rme/rme_avdevice.cpp \
+        debugmodule/debugmodule.cpp \
-        libfreebobavc/avc_connect.cpp \
-        libfreebobavc/avc_definitions.cpp \
@@ -75 +74 @@
-        libfreebobavc/avc_extended_subunit_info.cpp \
-        libfreebobavc/avc_function_block.cpp \
-        libfreebobavc/avc_function_block.h              \
-        libfreebobavc/avc_generic.cpp \
-        libfreebobavc/avc_plug_info.cpp \
+        libfreebobavc/avc_serialize.cpp \
-        libfreebobavc/avc_signal_source.cpp \
-        libfreebobavc/avc_subunit_info.cpp \
-        libfreebobavc/avc_unit_info.cpp \
-        libfreebobavc/ieee1394service.cpp \
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
-        libstreaming/cip.c \
-        libstreaming/cyclecounter.h                     \
-        libstreaming/freebob_streaming.cpp \
-        libstreaming/IsoHandler.cpp \
-        libstreaming/IsoHandlerManager.cpp \
-        libstreaming/IsoStream.cpp \
+        libstreaming/MotuPort.cpp \
+        libstreaming/MotuPortInfo.cpp \
+        libstreaming/MotuStreamProcessor.cpp \
-        libstreaming/PacketBuffer.cpp \
-        libstreaming/PortManager.cpp                    \
-        libstreaming/Port.cpp \
+        libstreaming/PortManager.cpp \
+        libstreaming/ringbuffer.c \
-        libstreaming/StreamProcessor.cpp \
-        libstreaming/StreamProcessorManager.cpp \
-        libstreaming/AmdtpPortInfo.cpp                  \
-        libstreaming/AmdtpPort.cpp                      \
-        libstreaming/AmdtpStreamProcessor.cpp           \
-        libstreaming/ringbuffer.c                       \
-        libstreaming/streamstatistics.cpp \
-        libstreaming/MotuStreamProcessor.cpp            \
-        libstreaming/MotuPort.cpp                       \
-        libstreaming/MotuPortInfo.cpp                   \
-        libutil/DelayLockedLoop.h                       \
-        libutil/Atomic.h                                \
-        libutil/PosixThread.h                           \
-        libutil/Thread.h                                \
-        libutil/DelayLockedLoop.cpp \
-        libutil/PosixThread.cpp \
-
-
-
-
+
-        libutil/SystemTimeSource.cpp \
-
-
-
-
-
+
+
-
-libfreebob_la_LDFLAGS =                                 \

branches/streaming-rework/src/motu/motu_avdevice.cpp

@@ -19 +19 @@
- * MA 02111-1307 USA.
- */
+
+#ifdef ENABLE_MOTU
-
-#include "motu/motu_avdevice.h"
@@ -937 +939 @@
-
-}
+#endif // ENABLE_MOTU

branches/streaming-rework/src/motu/motu_avdevice.h

@@ -19 +19 @@
- * MA 02111-1307 USA.
- */
+
+#ifdef ENABLE_MOTU
-
-#ifndef MOTUDEVICE_H
@@ -161 +163 @@
-
-#endif
+
+#endif // ENABLE_MOTU

branches/streaming-rework/tests/Makefile.am

@@ -22 +22 @@
-
-noinst_PROGRAMS = test-freebob test-extplugcmd test-fw410 freebob-server \
-count
+tim
-
-noinst_HEADERS = 
@@ -53 +53 @@
-TEST = test-freebob
-
-count
+tim
-        $(LIBRAW1394_LIBS) $(LIBAVC1394_LIBS)
-counter_SOURCES = test-cyclecount
+timer_SOURCES = test-cycletim
-
-test_sytmonitor_LDADD = $(top_builddir)/src/libfreebob.la $(LIBIEC61883_LIBS) \

branches/streaming-rework/tests/SytMonitor.cpp

@@ -64 +64 @@
-        m_port,channel,
-        cycle,syt_timestamp,
-COUNT
-COUNT
-COUNT
+TIM
+TIM
+TIM
-        
-        );
-    
-    // reconstruct the full cycle
-_ticks=m_handler->getCycleCount
-cycles=TICKS_TO_CYCLES(cc_ticks
+=m_handler->getCycleTim
+ticks=CYCLE_TIMER_TO_TICKS(cc
-    
-seconds=TICKS_TO_SECS(cc_ticks
+cycles=CYCLE_TIMER_GET_CYCLES(cc
-    
-
+
+
+
+
-    // we want cc_seconds to reflect the 'seconds' at the point this 
-    // was received
@@ -83 +86 @@
-     // reconstruct the top part of the timestamp using the current cycle number
-    unsigned int now_cycle_masked=cycle & 0xF;
-COUNT
+TIM
-    
-    // if this is true, wraparound has occurred, undo this wraparound
@@ -95 +98 @@
-    unsigned int new_cycles=cycle + delta_cycles;
-    
-count
+tim
-    // perform this wraparound
-    if(new_cycles>7999) {
@@ -113 +116 @@
-    
-    // and the seconds part
-count
+tim
-    // the timestamp lies in the next second
-    // if it didn't, the timestamp lies in this second
@@ -130 +133 @@
-    
-    // now we reconstruct the presentation time
-COUNT
-COUNT
-COUNT
-COUNT
+TIM
+TIM
+TIM
+TIM
-    
-    if (wraparound_occurred) {

branches/streaming-rework/tests/SytMonitor.h

@@ -30 +30 @@
-#include "src/libstreaming/IsoStream.h"
-#include "src/libstreaming/cip.h"
-count
+tim
-#include "src/libstreaming/ringbuffer.h"
-
@@ -43 +43 @@
-    unsigned int pres_cycle;
-    unsigned int pres_offset;
-nsigned int
+int64_t    
-};
-
@@ -66 +66 @@
-        bool putCycleInfo(struct cycle_info *cif);
-        
+        IsoHandler * getHandler() {return m_handler;};
+        
-        protected:
-           freebob_ringbuffer_t * m_cinfo_buffer;

branches/streaming-rework/tests/test-cycletimer.cpp

@@ -32 +32 @@
-#include <netinet/in.h>
-
-count
+tim
-
-#include "src/libstreaming/IsoHandler.h"
@@ -47 +47 @@
-
-DECLARE_GLOBAL_DEBUG_MODULE;
-IMPL_GLOBAL_DEBUG_MODULE( FreeBoB, DEBUG_LEVEL_VERBOSE );
-
-int run;
@@ -77 +76 @@
-}
-
-count
-
-count
-counter_as_uint=(uint32_t *)&cycle_count
+tim
+
+tim
+timer_as_uint=(uint32_t *)&cycle_tim
-    
-    uint32_t i=0;
@@ -91 +90 @@
-    // 
-    
-count
+tim
-    for (i=0;i<3072;i++) {
-count
-COUNTER_GET_OFFSET(ctr_to_quadlet(cycle_count
+tim
+TIMER_GET_OFFSET(ctr_to_quadlet(cycle_tim
-        
-        if(targetval != i) {
@@ -103 +102 @@
-    
-    for (i=0;i<8000;i++) {
-count
-COUNTER_GET_CYCLES(ctr_to_quadlet(cycle_count
+tim
+TIMER_GET_CYCLES(ctr_to_quadlet(cycle_tim
-        
-        if(targetval != i) {
@@ -113 +112 @@
-    
-    for (i=0;i<128;i++) {
-count
-COUNTER_GET_SECS(ctr_to_quadlet(cycle_count
+tim
+TIMER_GET_SECS(ctr_to_quadlet(cycle_tim
-        
-        if(targetval != i) {
@@ -123 +122 @@
-    
-    
+    // a value in ticks
+    // should be: 10sec, 1380cy, 640ticks
+    targetval=250000000L;
+    cycle_timer.seconds = TICKS_TO_SECS(targetval);
+    cycle_timer.cycles  = TICKS_TO_CYCLES(targetval);
+    cycle_timer.offset  = TICKS_TO_OFFSET(targetval);
+    
+    if((cycle_timer.seconds != 10) |
+        (cycle_timer.cycles != 1380) |
+        (cycle_timer.offset != 640))
+        {
+        debugOutput(DEBUG_LEVEL_NORMAL, "  test4 failed: (%u,10)sec (%u,1380)cy (%u,640)ticks\n",
+            cycle_timer.seconds,cycle_timer.cycles,cycle_timer.offset);
+        failures++;
+    } else {
+         debugOutput(DEBUG_LEVEL_NORMAL, "  test4 ok\n");
+    }
+    
+    i=TICKS_TO_CYCLE_TIMER(targetval);
+    if (i != 0x14564280) {
+         debugOutput(DEBUG_LEVEL_NORMAL, "  test5 failed: (0x%08X,0x14564280)\n",
+            i);
+        failures++;   
+    } else {
+         debugOutput(DEBUG_LEVEL_NORMAL, "  test5 ok\n");
+    }
+    
+    targetval=CYCLE_TIMER_TO_TICKS(i);
+    if (targetval!=250000000L) {
+         debugOutput(DEBUG_LEVEL_NORMAL, "  test6 failed: (%u,250000000)\n",
+            targetval);
+        failures++;   
+    } else {
+         debugOutput(DEBUG_LEVEL_NORMAL, "  test6 ok\n");
+    }
-    
-    if (failures) {
@@ -154 +188 @@
-        signal (SIGPIPE, sighandler);
-
-count
-
-count
-count
+tim
+
+tim
+tim
-           debugOutput(DEBUG_LEVEL_NORMAL, " !!! FAILED !!!\n");
-           exit(1);
@@ -319 +353 @@
-        debugOutput(DEBUG_LEVEL_NORMAL, "Bye...\n");
-
-    delete DebugModuleManager::instance();
-        
-  return EXIT_SUCCESS;
-}

branches/streaming-rework/tests/test-sytmonitor.cpp

@@ -33 +33 @@
-#include <netinet/in.h>
-
-count
+tim
-
-#include "src/libstreaming/IsoHandlerManager.h"
@@ -39 +39 @@
-
-#include "src/libutil/PosixThread.h"
+#include "src/libutil/SystemTimeSource.h"
-
-#include "pthread.h"
@@ -45 +46 @@
-using namespace FreebobUtil;
-
+
-DECLARE_GLOBAL_DEBUG_MODULE;
-IMPL_GLOBAL_DEBUG_MODULE( FreeBoB, DEBUG_LEVEL_VERBOSE );
-
-int run;
@@ -159 +160 @@
-int main(int argc, char *argv[])
-{
-        int target_port=0;
-        int target_channel_1=0;
-        int target_channel_2=0;
-    bool run_realtime=false;
-    int realtime_prio=20;
@@ -167 +165 @@
-    int i;
-    struct sched_param params;
+    uint64_t last_print_time=0;
+    
+    SystemTimeSource masterTimeSource;
-    
-    IsoHandlerManager *m_isoManager=NULL;
@@ -172 +173 @@
-    
-    SytMonitor *monitors[128];
-
+64_t
-    
-    struct arguments arguments;
@@ -245 +246 @@
-            
-            if(!m_isoManager->registerStream(monitors[i])) {
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
-
-        debugOutput(DEBUG_LEVEL_NORMAL,   "Preparing IsoHandlerManager...\n");
@@ -259 +265 @@
-        debugOutput(DEBUG_LEVEL_NORMAL,   "Starting ISO manager sync update thread...\n");
-
-        // start the runner thread
-        m_isoManagerThread->Start();
-
-        debugOutput(DEBUG_LEVEL_NORMAL,   "Starting IsoHandlers...\n");
@@ -267 +271 @@
-                goto finish;
-        }
+        
+        // start the runner thread
+        m_isoManagerThread->Start();
-        
-        if (arguments.realtime) {
@@ -278 +285 @@
-        // do the actual work
-        nb_iter=0;
+        
-        while(run) {
-        debugOutput(DEBUG_LEVEL_VERY_VERBOSE,"--- Iterate ---\n");
-        
-
-
+
+
+
+
+
+
+
-            return false;
-        }
@@ -334 +347 @@
-                                // detect seconds wraparound
-                                if ((master_cif.pres_seconds==0) && (cif.pres_seconds==127)) {
-
+LL
-                                }
-                                if ((master_cif.pres_seconds==127) && (cif.pres_seconds==0)) {
-
+LL
-                                }
-                            // average out the offset
- err=(((long)master_cif.pres_ticks) - ((long
+64_t err=(((uint64_t)master_cif.pres_ticks) - ((uint64_t
-                                
-                                err = err - stream_offset_ticks[i];
@@ -357 +370 @@
-                                        "             [%04us %04uc, %04X (%02uc %04ut)]\n",
-                                        master_cif.seconds,master_cif.cycle,
-COUNT
-COUNT
+TIM
+TIM
-                                        
-                                    debugOutput(DEBUG_LEVEL_NORMAL,
@@ -368 +381 @@
-                                        "             [%04us %04uc, %04X (%02uc %04ut)]\n",
-                                        cif.seconds,cif.cycle,
-COUNT
-COUNT
+TIM
+TIM
-                                    debugOutput(DEBUG_LEVEL_NORMAL,"\n");
-                                }
@@ -420 +433 @@
-        
-            // show info every x iterations
-
+
+
+
-                m_isoManager->dumpInfo();
-                for (i=0;i<arguments.nb_combos;i++) {
-                    monitors[i]->dumpInfo();
-
+
+
-                }
-
+
+
+
+
+
+
-        }
-
@@ -455 +476 @@
-finish:
-        debugOutput(DEBUG_LEVEL_NORMAL, "Bye...\n");
-
-
+
-return EXIT_SUCCESS;
-}