Changeset 395

Timestamp:

02/16/07 02:35:25 (17 years ago)

Author:

pieterpalmers

Message:

debugmodule.cpp:
- removed path from the source file name when printing debug messages

IsoStream?.cpp, StreamProcessor?.cpp:
- debug message modifications

StreamProcessorManager?.cpp:
- removed obsolete debug code

AmdtpStreamProcessor?.cpp:
- debug message modifications
- removed DLL that calculates framerate, as it is also calculated in the

TimestampedBuffer?

- converted code to use the new offset feature of the TimestampedBuffer?
- converted code to use the new frame timestamp calculation feature

of the TimestampedBuffer?

- first try at xmit sync code (unfinished)
- fixed 'unable to start' bug in receive SP

bebob_avdevice.cpp:
- added some #ifdef code to test with xmit SP's only (temporary)

TimestampedBuffer?.cpp:
- add offset feature
- add abitrary frame timestamp calculation

Files:

• branches/streaming-rework/src/bebob/bebob_avdevice.cpp (modified) (2 diffs)
• branches/streaming-rework/src/debugmodule/debugmodule.cpp (modified) (1 diff)
• branches/streaming-rework/src/libstreaming/AmdtpStreamProcessor.cpp (modified) (23 diffs)
• branches/streaming-rework/src/libstreaming/IsoStream.cpp (modified) (1 diff)
• branches/streaming-rework/src/libstreaming/StreamProcessor.cpp (modified) (1 diff)
• branches/streaming-rework/src/libstreaming/StreamProcessorManager.cpp (modified) (4 diffs)
• branches/streaming-rework/src/libutil/TimestampedBuffer.cpp (modified) (11 diffs)
• branches/streaming-rework/src/libutil/TimestampedBuffer.h (modified) (3 diffs)
• branches/streaming-rework/tests/test-timestampedbuffer.cpp (modified) (1 diff)

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

@@ -1085 +1085 @@
-}
-
+#ifdef TEST_XMIT_ONLY
+int
+AvDevice::getStreamCount() {
+//     return 2; // one receive, one transmit
+    return 1; // one receive, one transmit
+}
+
+FreebobStreaming::StreamProcessor *
+AvDevice::getStreamProcessorByIndex(int i) {
+    switch (i) {
+    case 0:
+//         return m_receiveProcessor;
+//     case 1:
+//         if (m_snoopMode) {
+//             return m_receiveProcessor2;
+//         } else {
+            return m_transmitProcessor;
+//         }
+    default:
+        return NULL;
+    }
+    return 0;
+}
+
+// FIXME: error checking
+int
+AvDevice::startStreamByIndex(int i) {
+    int iso_channel=0;
+    int plug=0;
+    int hostplug=-1;
+
+//     if (m_snoopMode) {
+//
+//         switch (i) {
+//         case 0:
+//             // snooping doesn't use CMP, but obtains the info of the channel
+//             // from the target plug
+//
+//             // TODO: get isochannel from plug
+//
+//             // set the channel obtained by the connection management
+//             m_receiveProcessor->setChannel(iso_channel);
+//             break;
+//         case 1:
+//             // snooping doesn't use CMP, but obtains the info of the channel
+//             // from the target plug
+//
+//             // TODO: get isochannel from plug
+//
+//             // set the channel obtained by the connection management
+//             m_receiveProcessor2->setChannel(iso_channel);
+//
+//             break;
+//         default:
+//             return 0;
+//         }
+//     } else {
+
+        switch (i) {
+        case 0:
+//             // do connection management: make connection
+//             iso_channel = iec61883_cmp_connect(
+//                 m_p1394Service->getHandle(),
+//                 m_pConfigRom->getNodeId() | 0xffc0,
+//                 &plug,
+//                 raw1394_get_local_id (m_p1394Service->getHandle()),
+//                 &hostplug,
+//                 &m_receiveProcessorBandwidth);
+// 
+//             // set the channel obtained by the connection management
+//             m_receiveProcessor->setChannel(iso_channel);
+//             break;
+//         case 1:
+            // do connection management: make connection
+            iso_channel = iec61883_cmp_connect(
+                m_p1394Service->getHandle(),
+                raw1394_get_local_id (m_p1394Service->getHandle()),
+                &hostplug,
+                m_pConfigRom->getNodeId() | 0xffc0,
+                &plug,
+                &m_transmitProcessorBandwidth);
+
+            // set the channel obtained by the connection management
+            m_transmitProcessor->setChannel(iso_channel);
+            break;
+        default:
+            return -1;
+        }
+//     }
+
+    if (iso_channel < 0) return -1;
+    
+    return 0;
+
+}
+
+// FIXME: error checking
+int
+AvDevice::stopStreamByIndex(int i) {
+    // do connection management: break connection
+
+    int plug=0;
+    int hostplug=-1;
+//     if (m_snoopMode) {
+//         switch (i) {
+//         case 0:
+//             // do connection management: break connection
+//
+//             break;
+//         case 1:
+//             // do connection management: break connection
+//
+//             break;
+//         default:
+//             return 0;
+//         }
+//     } else {
+        switch (i) {
+        case 0:
+//             // do connection management: break connection
+//             iec61883_cmp_disconnect(
+//                 m_p1394Service->getHandle(),
+//                 m_pConfigRom->getNodeId() | 0xffc0,
+//                 plug,
+//                 raw1394_get_local_id (m_p1394Service->getHandle()),
+//                 hostplug,
+//                 m_receiveProcessor->getChannel(),
+//                 m_receiveProcessorBandwidth);
+// 
+//             break;
+//         case 1:
+            // do connection management: break connection
+            iec61883_cmp_disconnect(
+                m_p1394Service->getHandle(),
+                raw1394_get_local_id (m_p1394Service->getHandle()),
+                hostplug,
+                m_pConfigRom->getNodeId() | 0xffc0,
+                plug,
+                m_transmitProcessor->getChannel(),
+                m_transmitProcessorBandwidth);
+
+            break;
+        default:
+            return 0;
+        }
+//     }
+
+    return 0;
+}
+#else
-int
-AvDevice::getStreamCount() {
@@ -1232 +1382 @@
-    return 0;
-}
+#endif
-
-template <typename T> bool serializeVector( Glib::ustring path,

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

@@ -99 +99 @@
-    va_list arg;
-    va_start( arg, format );
+    
+    // remove the path info from the filename
+    char *f=(char *)file;
+    char *fname;
+    while((f=strstr(f, "/"))) {
+        f++; // move away from delimiter
+        fname=f;
+    }
+    
-    DebugModuleManager::instance()->print( "%s (%s)[%4d] %s: ", getPreSequence( level ),
-il
+nam
-    DebugModuleManager::instance()->va_print( format, arg );
-    DebugModuleManager::instance()->print( "%s", getPostSequence( level ) );

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

@@ -36 +36 @@
-#include <assert.h>
-
-
-
-
+
-
-// in ticks
@@ -172 +170 @@
-            // therefore sync_lag_cycles * TICKS_PER_CYCLE earlier than
-            // T1.
-
-
-
-
-
-
-
-
-
-
-
+
+
+
-            
-            #ifdef DEBUG
@@ -189 +179 @@
-            }
-            #endif
-
-
-
-
-
+
+
-        } else {
-            debugOutput(DEBUG_LEVEL_VERY_VERBOSE,
@@ -235 +222 @@
-#ifdef DEBUG
-    if(!m_is_disabled) {
-
+
+
+
+
-            timestamp, cycle_timer, now_cycles, cycle
-            );
@@ -241 +231 @@
-            until_next
-            );
-
-
+, CY_SYT=%04d
+, TICKS_TO_CYCLES(syt)
-            );
-    }
@@ -256 +246 @@
-        uint32_t test_ts=sytXmitToFullTicks(syt, cycle, now);
-
-Y_VER
+
-            cycle, syt, CYCLE_TIMER_GET_CYCLES(syt), CYCLE_TIMER_GET_OFFSET(syt)
-            );
-Y_VER
+
-            cycle, now_ticks, CYCLE_TIMER_GET_SECS(now), CYCLE_TIMER_GET_CYCLES(now), CYCLE_TIMER_GET_OFFSET(now)
-            );
-Y_VER
+
-            cycle, test_ts, TICKS_TO_SECS(test_ts), TICKS_TO_CYCLES(test_ts), TICKS_TO_OFFSET(test_ts)
-            );
-Y_VER
+
-            cycle, timestamp_u, TICKS_TO_SECS(timestamp_u), TICKS_TO_CYCLES(timestamp_u), TICKS_TO_OFFSET(timestamp_u)
-            );
@@ -371 +361 @@
-
-int64_t AmdtpTransmitStreamProcessor::getTimeUntilNextPeriodUsecs() {
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-}
-
@@ -383 +387 @@
-
-uint64_t AmdtpTransmitStreamProcessor::getTimeAtPeriod() {
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
-}
-
@@ -430 +443 @@
-    m_WakeupStat.setName("XMT WAKEUP");
-
-...\n"
+ (%p)...\n", this
-    
-    // prepare all non-device specific stuff
@@ -485 +498 @@
-    m_ringbuffer_size_frames=m_nb_buffers * m_period;
-
-    // add the receive processing delay
-//     m_ringbuffer_size_frames+=(uint)(RECEIVE_PROCESSING_DELAY/m_ticks_per_frame);
-
-    assert(m_data_buffer);    
-    m_data_buffer->setBufferSize(m_ringbuffer_size_frames);
@@ -497 +507 @@
-    
-    m_data_buffer->setWrapValue(128L*TICKS_PER_SECOND);
+    
+    // we have to make sure that the buffer HEAD timestamp
+    // lies in the future for every possible buffer fill case.
+    m_data_buffer->setTickOffset((int)(m_ringbuffer_size_frames*m_ticks_per_frame));
-    
-    m_data_buffer->prepare();
@@ -656 +670 @@
-    debugOutput(DEBUG_LEVEL_VERY_VERBOSE, "AmdtpTransmitStreamProcessor::putFrames(%d, %llu)\n", nbframes, ts);
-    
-    // The timestamp passed to this function is the time
-    // of the period transfer. This means that we have to
-    // add our max buffer size to it to ensure causality
-    // in all cases:
-    // we have to make sure that the buffer HEAD timestamp
-    // lies in the future for every possible buffer fill case.
-    float ticks_per_frame=m_SyncSource->getTicksPerFrame();
-    ts = addTicks(ts,(uint32_t)((float)m_ringbuffer_size_frames * ticks_per_frame));
-    
-    // transfer the data
-    m_data_buffer->blockProcessWriteFrames(nbframes, ts);
@@ -929 +934 @@
-        m_running,m_disabled,m_is_disabled);
-
+    // check our enable status
+    if (!m_disabled && m_is_disabled) {
+        // this means that we are trying to enable
+        if (cycle == m_cycle_to_enable_at) {
+            m_is_disabled=false;
+            debugOutput(DEBUG_LEVEL_VERBOSE,"Enabling StreamProcessor %p at %d (SYT=%04X)\n", 
+                this, cycle, ntohs(packet->syt));
+            // the previous timestamp is the one we need to start with
+            // because we're going to update the buffer again this loop
+            // using writeframes
+            m_data_buffer->setBufferTailTimestamp(m_last_timestamp2);
+
+        } else {
+            debugOutput(DEBUG_LEVEL_VERY_VERBOSE,
+                "will enable StreamProcessor %p at %u, now is %d\n",
+                    this, m_cycle_to_enable_at, cycle);
+        }
+    } else if (m_disabled && !m_is_disabled) {
+        // trying to disable
+        debugOutput(DEBUG_LEVEL_VERBOSE,"disabling StreamProcessor %p at %u\n", this, cycle);
+        m_is_disabled=true;
+    }
+
-    if((packet->syt != 0xFFFF) 
-       && (packet->fdf != 0xFF) 
@@ -957 +985 @@
-            m_last_timestamp, m_handler->getWakeupInterval(),m_syt_interval,m_ticks_per_frame);
-        
-        m_last_timestamp += (uint64_t)(((float)m_handler->getWakeupInterval())
-                                       * ((float)m_syt_interval) * m_ticks_per_frame);
-        debugOutput(DEBUG_LEVEL_VERY_VERBOSE," ==> %lluticks\n", m_last_timestamp);
-        
-        // the receive processing delay indicates how much
-        // extra time we use as slack
-        m_last_timestamp += RECEIVE_PROCESSING_DELAY;
-        
-        // wrap if nescessary
-        m_last_timestamp=wrapAtMaxTicks(m_last_timestamp);
-        
-        //=> now estimate the device frame rate
-        if (m_last_timestamp2 && m_last_timestamp) {
-            // try and estimate the frame rate from the device
-            
-            // first get the measured difference between both 
-            // timestamps
-            int64_t measured_difference;
-            measured_difference=((int64_t)(m_last_timestamp))
-                               -((int64_t)(m_last_timestamp2));
-            // correct for seconds wraparound
-            if (m_last_timestamp<m_last_timestamp2) {
-                measured_difference+=128L*TICKS_PER_SECOND;
-            }
-
-            // implement a 1st order DLL to estimate the framerate
-            // this is the number of ticks between two samples
-            float f=measured_difference;
-            float err = f / (1.0*m_syt_interval) - m_ticks_per_frame;
-
-            // integrate the error
-            m_ticks_per_frame += RECEIVE_DLL_INTEGRATION_COEFFICIENT*err;
-            
-        }
-
-        //=> signal that we're running (if we are)
-        if(!m_running && nevents && m_last_timestamp2 && m_last_timestamp) {
@@ -999 +992 @@
-
-        //=> don't process the stream samples when it is not enabled.
-        if (!m_disabled && m_is_disabled) {
-            // this means that we are trying to enable
-            if (cycle == m_cycle_to_enable_at) {
-                m_is_disabled=false;
-                debugOutput(DEBUG_LEVEL_VERBOSE,"enabling StreamProcessor %p at %d\n", this, cycle);
-                // the previous timestamp is the one we need to start with
-                // because we're going to update the buffer again this loop
-                // using writeframes
-                m_data_buffer->setBufferTailTimestamp(m_last_timestamp2);
-
-            } else {
-                debugOutput(DEBUG_LEVEL_VERY_VERBOSE,
-                    "will enable StreamProcessor %p at %u, now is %d\n",
-                     this, m_cycle_to_enable_at, cycle);
-            }
-        } else if (m_disabled && !m_is_disabled) {
-            // trying to disable
-            debugOutput(DEBUG_LEVEL_VERBOSE,"disabling StreamProcessor %p at %u\n", this, cycle);
-            m_is_disabled=true;
-        }
-        
-        if(m_is_disabled) {
-
@@ -1029 +1001 @@
-            // the next (possible) sample is not this one, but lies 
-            // SYT_INTERVAL * rate later
-
-
-
-
+
+
-
-            // set the timestamp as if there will be a sample put into
@@ -1049 +1019 @@
-            uint32_t test_ts=sytRecvToFullTicks(syt, cycle, now);
-
-Y_VER
+
-                cycle, syt, CYCLE_TIMER_GET_CYCLES(syt), CYCLE_TIMER_GET_OFFSET(syt)
-                );
-Y_VER
+
-                cycle, now_ticks, CYCLE_TIMER_GET_SECS(now), CYCLE_TIMER_GET_CYCLES(now), CYCLE_TIMER_GET_OFFSET(now)
-                );
-Y_VER
+
-                cycle, test_ts, TICKS_TO_SECS(test_ts), TICKS_TO_CYCLES(test_ts), TICKS_TO_OFFSET(test_ts)
-                );
@@ -1119 +1089 @@
-
-uint64_t AmdtpReceiveStreamProcessor::getTimeAtPeriod() {
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
-        );
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
-    
-    return next_period_boundary;
@@ -1183 +1107 @@
-
-    StreamProcessor::dumpInfo();
-    
-        debugOutputShort( DEBUG_LEVEL_NORMAL, "  Device framerate  : %f\n", 24576000.0/m_ticks_per_frame);
-
-}
@@ -1203 +1125 @@
-    m_WakeupStat.reset();
-    
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-    // reset all non-device specific stuff
@@ -1224 +1154 @@
-    m_WakeupStat.setName("RCV WAKEUP");
-
+    debugOutput( DEBUG_LEVEL_VERBOSE, "Preparing (%p)...\n", this);
+        
-        // prepare all non-device specific stuff
-        // i.e. the iso stream and the associated ports
@@ -1231 +1163 @@
-        }
-        
-        debugOutput( DEBUG_LEVEL_VERBOSE, "Preparing...\n");
-        switch (m_framerate) {
-        case 32000:
@@ -1280 +1211 @@
-    
-    m_data_buffer->setWrapValue(128L*TICKS_PER_SECOND);
+    
+    // The timestamp passed to this function is the time
+    // of the period transfer. This means that we have to
+    // add our max buffer size to it to ensure causality
+    // in all cases:
+    // we have to make sure that the buffer HEAD timestamp
+    // lies in the future for every possible buffer fill case.
+    
+    // the receive processing delay indicates how much
+    // extra time we use as slack
+    m_data_buffer->setTickOffset(RECEIVE_PROCESSING_DELAY);
-    
-    m_data_buffer->prepare();

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

@@ -84 +84 @@
-
-bool IsoStream::setChannel(int c) {
-to %d\n",
+for (%p) to %d\n",this, 
-
-    m_channel=c;

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

@@ -76 +76 @@
-    debugOutputShort( DEBUG_LEVEL_NORMAL, "  Enabled               : %s\n", m_disabled ? "No" : "Yes");
-    debugOutputShort( DEBUG_LEVEL_NORMAL, "   enable status        : %s\n", m_is_disabled ? "No" : "Yes");
+    
+    debugOutputShort( DEBUG_LEVEL_NORMAL, "  Device framerate      : Sync: %f, Buffer %f\n", 
+        24576000.0*m_SyncSource->m_data_buffer->getRate(),
+        24576000.0*m_data_buffer->getRate()
+        );
-    
-    m_data_buffer->dumpInfo();

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

@@ -905 +905 @@
-                it != m_ReceiveProcessors.end();
-                ++it ) {
-            
-            //#ifdef DEBUG
-            #if 0
-            {
-                uint64_t ts_tail=0;
-                uint64_t fc_tail=0;
-                
-                uint64_t ts_head=0;
-                uint64_t fc_head=0;
-                
-                int cnt=0;
-                
-                (*it)->getBufferHeadTimestamp(&ts_head,&fc_head);
-                (*it)->getBufferTailTimestamp(&ts_tail,&fc_tail);
-                
-                while((fc_head != fc_tail) && (cnt++ < 10)) {
-                    (*it)->getBufferHeadTimestamp(&ts_head,&fc_head);
-                    (*it)->getBufferTailTimestamp(&ts_tail,&fc_tail);
-                }
-                
-                debugOutput(DEBUG_LEVEL_VERBOSE,"R => HEAD: TS=%11llu, FC=%5llu | TAIL: TS=%11llu, FC=%5llu, %d\n",
-                    ts_head, fc_head, ts_tail, fc_tail, cnt);
-            }
-            #endif
-    
-            if(!(*it)->getFrames(m_period)) {
-                    debugOutput(DEBUG_LEVEL_VERBOSE,"could not getFrames(%u, %11llu) from stream processor (%p)",
@@ -935 +911 @@
-                    return false; // buffer underrun
-            }
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
-        }
-    } else {
@@ -965 +917 @@
-                it != m_TransmitProcessors.end();
-                ++it ) {
-                
-            //#ifdef DEBUG
-            #if 0
-            {
-                uint64_t ts_tail=0;
-                uint64_t fc_tail=0;
-                
-                uint64_t ts_head=0;
-                uint64_t fc_head=0;
-                
-                int cnt=0;
-                
-                (*it)->getBufferHeadTimestamp(&ts_head,&fc_head);
-                (*it)->getBufferTailTimestamp(&ts_tail,&fc_tail);
-                
-                while((fc_head != fc_tail) && (cnt++ < 10)) {
-                    (*it)->getBufferHeadTimestamp(&ts_head,&fc_head);
-                    (*it)->getBufferTailTimestamp(&ts_tail,&fc_tail);
-                }
-                
-                debugOutput(DEBUG_LEVEL_VERBOSE,"T => HEAD: TS=%11llu, FC=%5llu | TAIL: TS=%11llu, FC=%5llu, %d\n",
-                    ts_head, fc_head, ts_tail, fc_tail, cnt);
-            }
-            #endif
-                
-            if(!(*it)->putFrames(m_period, (int64_t)m_time_of_transfer)) {
@@ -995 +923 @@
-                return false; // buffer overrun
-            }
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
-        }
-    }

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

@@ -39 +39 @@
-TimestampedBuffer::TimestampedBuffer(TimestampedBufferClient *c)
-    : m_event_buffer(NULL), m_cluster_buffer(NULL),
- 
+
-      m_bytes_per_frame(0), m_bytes_per_buffer(0),
-      m_wrap_at(0xFFFFFFFFFFFFFFFFLLU),
-
+
+
+
-      m_buffer_next_tail_timestamp(0),
-      m_dll_e2(0.0), m_dll_b(0.877), m_dll_c(0.384),
@@ -146 +148 @@
-    m_bytes_per_buffer=m_bytes_per_frame*m_buffer_size;
-
+    return true;
+}
+
+/**
+ * Sets the buffer offset in ticks. 
+ *
+ * A positive value means that the buffer is 'delayed' for nticks ticks.
+ *
+ * @note These offsets are only used when reading timestamps. Any function
+ *       that returns a timestamp will incorporate this offset. 
+ * @param nframes the number of ticks (positive = delay buffer)
+ * @return true if successful
+ */
+bool TimestampedBuffer::setTickOffset(int nticks) {
+    debugOutput(DEBUG_LEVEL_VERBOSE,"Setting ticks offset to %d\n",nticks);
+    m_tick_offset=nticks;
-    return true;
-}
@@ -519 +537 @@
- * 
- * This is thread safe.
+ *
+ * @note considers offsets
- * 
- * @param new_timestamp 
- */
-void TimestampedBuffer::setBufferTailTimestamp(uint64_t new_timestamp) {
+
+    // add the offsets
+    int64_t diff=m_buffer_next_tail_timestamp - m_buffer_tail_timestamp;
+    if (diff < 0) diff += m_wrap_at;
+    
+    double rate;
+    
+    if (diff) {
+        rate=(double)diff / (double)m_update_period;
+    } else {
+        rate=m_nominal_rate;
+    }
+        
+    int64_t ts=new_timestamp;
+    ts += m_tick_offset;
+    
+    if (ts >= (int64_t)m_wrap_at) {
+        ts -= m_wrap_at;
+    } else if (ts < 0) {
+        ts += m_wrap_at;
+    }
-    
-#ifdef DEBUG
-128L*TICKS_PER_SECOND
+m_wrap_at
-        debugWarning("timestamp not wrapped: %llu\n",new_timestamp);
+    }    
+    if ((ts >= (int64_t)m_wrap_at) || (ts < 0 )) {
+        debugWarning("ts not wrapped correctly: %lld\n",ts);
-    }
-#endif
@@ -532 +576 @@
-    pthread_mutex_lock(&m_framecounter_lock);
-    
-new_timestamp
+ts
-    
-    m_dll_e2=m_update_period * m_nominal_rate;
@@ -539 +583 @@
-    pthread_mutex_unlock(&m_framecounter_lock);    
-    
-, NTS=%llu, DLL2
-m_buffer_next_tail_timestamp, m_dll_e2
+ => %11lld, NTS=%llu, DLL2=%f, RATE
+ts, m_buffer_next_tail_timestamp, m_dll_e2, rate
-
-}
@@ -555 +599 @@
- */
-void TimestampedBuffer::getBufferHeadTimestamp(uint64_t *ts, uint64_t *fc) {
-
-
-
-
-
-
-
-
+
+
-    *fc = m_framecounter;
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
-}
-
@@ -616 +623 @@
-
-/**
+ * @brief Get timestamp for a specific position from the buffer tail
+ *
+ * Returns the timestamp for a position that is nframes earlier than the 
+ * buffer tail
+ *
+ * @param nframes number of frames
+ * @return timestamp value
+ */
+uint64_t TimestampedBuffer::getTimestampFromTail(int nframes)
+{
+    // ts(x) = m_buffer_tail_timestamp -
+    //         (m_buffer_next_tail_timestamp - m_buffer_tail_timestamp)/(samples_between_updates)*(x)
+    
+    int64_t diff=m_buffer_next_tail_timestamp - m_buffer_tail_timestamp;
+    if (diff < 0) diff += m_wrap_at;
+    
+    double rate=(double)diff / (double)m_update_period;
+    
+    int64_t timestamp;
+    
+    pthread_mutex_lock(&m_framecounter_lock);
+
+    timestamp=(int64_t)m_buffer_tail_timestamp - (int64_t)((nframes) * rate);
+
+    pthread_mutex_unlock(&m_framecounter_lock);
+    
+    if(timestamp >= (int64_t)m_wrap_at) {
+        timestamp -= m_wrap_at;
+    } else if(timestamp < 0) {
+        timestamp += m_wrap_at;
+    }
+    
+    return (uint64_t)timestamp;
+}
+
+/**
+ * @brief Get timestamp for a specific position from the buffer head
+ *
+ * Returns the timestamp for a position that is nframes later than the 
+ * buffer head
+ *
+ * @param nframes number of frames
+ * @return timestamp value
+ */
+uint64_t TimestampedBuffer::getTimestampFromHead(int nframes)
+{
+    return getTimestampFromTail(m_framecounter-nframes);
+}
+
+/**
- * Resets the frame counter, in a atomic way. This
- * is thread safe.
@@ -639 +696 @@
- * Increments the frame counter in a thread safe way.
- * Also updates the timestamp.
-
+
+
+
+
- * @param nbframes the number of frames to add
- * @param new_timestamp the new timestamp
- */
-void TimestampedBuffer::incrementFrameCounter(int nbframes, uint64_t new_timestamp) {
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    
-#ifdef DEBUG
-128L*TICKS_PER_SECOND
+m_wrap_at
-        debugWarning("timestamp not wrapped: %llu\n",new_timestamp);
+    }    
+    if ((ts >= (int64_t)m_wrap_at) || (ts < 0 )) {
+        debugWarning("ts not wrapped correctly: %lld\n",ts);
-    }
-#endif
-
-
-
-
+
-    // update the DLL
-
-
+
+
+
+
+
+
+
+
+
-    // idea to implement it for nbframes values that differ from m_update_period:
-    // diff = diff * nbframes/m_update_period
@@ -674 +757 @@
-        diff += m_wrap_at;
-    }
-
+
-    double err=diff;
-    
@@ -682 +765 @@
-                    m_framecounter, m_buffer_tail_timestamp, m_buffer_next_tail_timestamp);
-    
+    pthread_mutex_lock(&m_framecounter_lock);
+    m_framecounter += nbframes;
+    
-    m_buffer_tail_timestamp=m_buffer_next_tail_timestamp;
-
+
+
+
-    
-    debugOutput(DEBUG_LEVEL_VERY_VERBOSE, "U: FC=%10u, TS=%011llu, NTS=%011llu\n",
@@ -689 +777 @@
-    
-    if (m_buffer_next_tail_timestamp >= m_wrap_at) {
+        debugOutput(DEBUG_LEVEL_VERY_VERBOSE, "Unwrapping next tail timestamp: %011llu",
+                m_buffer_next_tail_timestamp);
+                
-        m_buffer_next_tail_timestamp -= m_wrap_at;
-        
-(DEBUG_LEVEL_VERY_VERBOSE, "Unwrapping next tail timestamp: %
+Short(DEBUG_LEVEL_VERY_VERBOSE, " => %0
-                m_buffer_next_tail_timestamp);
-
-
-
-
-
-
+
+
+
+
+
-    
-    pthread_mutex_unlock(&m_framecounter_lock);
-    
-    if(m_buffer_tail_timestamp>=m_wrap_at) {
-
+
+
+
+
-    }
-    if(m_buffer_next_tail_timestamp>=m_wrap_at) {
-
+
+
+
-    }
-    

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

@@ -112 +112 @@
-    
-    void setBufferTailTimestamp(uint64_t new_timestamp);
-
+
+
+
+
+
+
+
+
+
+
+
-    // dll stuff
-    bool setNominalRate(float r);
@@ -149 +159 @@
-    signed int m_framecounter;
-    
+    // the offset that define the timing of the buffer
+    signed int m_tick_offset;
+    
-    // the buffer tail timestamp gives the timestamp of the last frame
-    // that was put into the buffer
@@ -154 +167 @@
-    uint64_t   m_buffer_next_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;
-    // this mutex protects the access to the framecounter
-    // and the buffer head timestamp.

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

@@ -289 +289 @@
-    t->setWrapValue(arguments.wrap_at);
-    
+    t->setTickOffset(10000);
+    
-    t->prepare();
-