Changeset 228

Timestamp:

05/28/06 05:43:20 (16 years ago)

Author:

pieterpalmers

Message:

- generic rate control added for ringbuffer based ports.

Files:

• branches/libfreebob-2.0/src/debugmodule/debugmodule.cpp (modified) (1 diff)
• branches/libfreebob-2.0/src/libstreaming/AmdtpPort.cpp (modified) (1 diff)
• branches/libfreebob-2.0/src/libstreaming/AmdtpPort.h (modified) (1 diff)
• branches/libfreebob-2.0/src/libstreaming/AmdtpStreamProcessor.cpp (modified) (5 diffs)
• branches/libfreebob-2.0/src/libstreaming/Port.cpp (modified) (6 diffs)
• branches/libfreebob-2.0/src/libstreaming/Port.h (modified) (2 diffs)

branches/libfreebob-2.0/src/debugmodule/debugmodule.cpp

@@ -72 +72 @@
-
-    va_start( arg, format );
-
-
-
-
+
-    if ( vprintf( format, arg ) < 0 ) {
-        cerr << "Could not create debug string with printf" << endl;
-        return;
-    }
-
-
-
-
+
-    va_end( arg );
-}

branches/libfreebob-2.0/src/libstreaming/AmdtpPort.cpp

@@ -32 +32 @@
-namespace FreebobStreaming {
-
-AmdtpMidiPort::AmdtpMidiPort(std::string name, 
-                           enum E_Direction direction,
-                           int position, 
-                           int location, 
-                           enum E_Formats format, 
-                           int type)
-        : MidiPort(name, direction),
-          AmdtpPortInfo(name, position, location, format, type)
-          , m_countdown(0)
-{
-        m_ringbuffer=freebob_ringbuffer_create(m_buffersize * getEventSize());
-        
-        if(!m_ringbuffer) {
-                debugFatal("Could not allocate ringbuffer\n");
-                m_buffersize=0;
-        }
-        
-}
-
-AmdtpMidiPort::~AmdtpMidiPort() {
-        if (m_ringbuffer) freebob_ringbuffer_free(m_ringbuffer);
-        
-}
-
-/**
- * The problem with MIDI ports is that there is no guaranteed availability of data.
- * This function will return true if: 
- *  (1) there is a byte ready in the buffer
- *  (2) we are allowed to send a byte
- *
- * it will also assume that you actually are sending a byte, and it will reset
- * the countdown
- *
- * note on (2): the midi over 1394 spec limits the speed of sending midi data bytes.
- *              For every (time muxed) channel, you can send only one midi byte every
- *              320 microseconds. The packet rate is 8000pkt/sec, or 125us. Therefore
- *              we wait (at least) two packets before sending another byte. This comes
- *              down to 375us, so there is a slight limiting of the bandwidth.
- *
- * \todo fix the too long delay (375us instead of 320us)
- *
- * @return true if you can send a midi byte
- */
-bool AmdtpMidiPort::canSend() {
-        bool byte_present_in_buffer;
-        assert(m_ringbuffer);
-        
-        byte_present_in_buffer=(freebob_ringbuffer_read_space(m_ringbuffer)>=sizeof(char));
-        
-        if(byte_present_in_buffer && (m_countdown < 0)) {
-                m_countdown=2;
-                return true;
-        }
-        return false;
-}
-
-} // end of namespace FreebobStreaming

branches/libfreebob-2.0/src/libstreaming/AmdtpPort.h

@@ -84 +84 @@
-                           int location, 
-                           enum E_Formats format, 
-
+
+
+
+
-
-
-
-
-
+
+
-
-protected:
-        int m_countdown;
-        
-};

branches/libfreebob-2.0/src/libstreaming/AmdtpStreamProcessor.cpp

@@ -268 +268 @@
-                                        return false;
-                                }
+                                
+                                // we use a timing unit of 10ns
+                                // this makes sure that for the max syt interval
+                                // we don't have rounding, and keeps the numbers low
+                                // we have 1 slot every 8 events
+                                // we have syt_interval events per packet
+                                // => syt_interval/8 slots per packet
+                                // packet rate is 8000pkt/sec => interval=125us
+                                // so the slot interval is (1/8000)/(syt_interval/8)
+                                // or: 1/(1000 * syt_interval) sec
+                                // which is 1e9/(1000*syt_interval) nsec
+                                // or 100000/syt_interval 'units'
+                                // the event interval is fixed to 320us = 32000 'units'
+                                if(!(*it)->useRateControl(true,(100000/m_syt_interval),32000, false)) {
+                                        debugFatal("Could not set signal type to PeriodSignalling");
+                                        return false;
+                                }
+                                
-                                // buffertype and datatype are dependant on the API
-                                debugWarning("---------------- ! Doing hardcoded test setup ! --------------\n");
@@ -433 +451 @@
-                        bytes2write -= byteswritten;
-                }
-
+
-                // the bytes2write should always be cluster aligned
-                assert(bytes2write%cluster_size==0);
-
+
-        }
-
@@ -555 +573 @@
-                        target_event=(quadlet_t *)(data + ((j * m_dimension) + mp->getPosition()));
-                        
-Sen
+Rea
-                                mp->readEvent(&byte);
-                                *target_event=htonl(
@@ -566 +584 @@
-                                        IEC61883_AM824_SET_LABEL(0,IEC61883_AM824_LABEL_MIDI_NO_DATA));
-                        }
-                        mp->trigger();
-                }
-
@@ -1066 +1083 @@
-                        target_event=(quadlet_t *)(data + ((j * m_dimension) + mp->getPosition()));
-                        quadlet_t sample_int=ntohl(*target_event);
+                        // FIXME: this assumes that 2X and 3X speed isn't used, 
+                        // because only the 1X slot is put into the ringbuffer
-                        if(IEC61883_AM824_GET_LABEL(sample_int) != IEC61883_AM824_LABEL_MIDI_NO_DATA) {
-
+000000
-                                if(!mp->writeEvent(&sample_int)) {
-                                        debugWarning("Packet port events lost\n");

branches/libfreebob-2.0/src/libstreaming/Port.cpp

@@ -41 +41 @@
-        m_BufferType(E_PointerBuffer),
-        m_enabled(true),
+        m_initialized(false),
-        m_buffersize(0),
-        m_eventsize(0),
@@ -48 +49 @@
-        m_buffer(0),
-        m_ringbuffer(0),
-
+
+
+
+
+
+
+
+
-{
-
@@ -284 +292 @@
-        assert(m_ringbuffer);
-        
-
-
-
-
+
+
+
-}
-
@@ -293 +300 @@
-        assert(m_ringbuffer);
-        
-
-
-
-
+
+
+
-        return (read==m_eventsize);
-}
@@ -304 +310 @@
-        assert(m_ringbuffer);
-        
-        char *byte=(char *)event;
-        unsigned int bytes2write=m_eventsize*nevents;
-        
-
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-}
@@ -313 +330 @@
-int Port::readEvents(void *event, unsigned int nevents) {
-        assert(m_ringbuffer);
-        char *byte=(char *)event;
-        
-        unsigned int bytes2read=m_eventsize*nevents;
-        
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-/* Private functions */

branches/libfreebob-2.0/src/libstreaming/Port.h

@@ -198 +198 @@
-        void setExternalBufferAddress(void *buff);
-
+
+        /**
+         * \brief enable/disable ratecontrol
+         *
+         * Rate control is nescessary for some types of ports (most notably 
+         * midi). The StreamProcessor that handles the port should call canRead()
+         * everytime a 'slot' that could be filled with an event passes. The canRead 
+         * function will return true if 
+         *  (1) there is an event ready in the buffer
+         *  (2) we are allowed to send an event in this slot
+         *
+         * Setting the rate works is done with the slot_interval and the event_interval
+         * parameters. On every call to canRead(), a counter is decremented with 
+         * slot_interval. If the counter drops below 0, canRead() returns true and resets
+         * the counter to event_interval.
+         *
+         * e.g. for AMDTP midi, we are only allowed to send a midi byte every 320us
+         *      if the SYT interval is 8, there is exactly one midi slot every packet.
+         *      therefore the slot_interval is 1/8000s (=125us), and the event_interval 
+         *      is 320us.
+         *      
+         *      Note that the interval parameters are unitless, so you can adapt them
+         *      to your needs. In the AMDTP case for example, when the SYT interval is 32
+         *      (when the samplerate is 192kHz for example) there are 4 midi slots in
+         *      each packet, making the slot time interval 125us/4 = 31.25us. 
+         *      The event time interval stays the same (320us). We can however set the
+         *      slot_interval to 3125 and the event_interval to 32000, as we can choose
+         *      the unit of the counter time step (chosen to be 10ns in this case).
+         *
+         * The average argument deserves some attention too. If average is true, we use
+         * average rate control. This means that on average there will be a delay of
+         * event_interval between two events, but that sometimes there can be a smaller
+         * delay. This mode fixes the average rate of the stream.
+         * If average is false, there will always be a minimal delay of event_interval
+         * between two events. This means that the maximum rate of the stream is fixed,
+         * and that the average rate will be lower than (or at max equal to) the rate in 
+         * average mode.
+         *
+         *
+         * \note only works for the E_RingBuffer ports
+         * \note use before calling init()
+         *
+         * @param use set this to true to use rate control
+         * @param slot_interval the interval between slots
+         * @param event_interval the interval between events
+         * @param average use average rate control
+         * @return true if rate control was enabled/disabled successfully
+         */
+        virtual bool useRateControl(bool use, unsigned int slot_interval, 
+                                    unsigned int event_interval, bool average);
+        
+        bool usingRateControl() { return m_do_ratecontrol;}; ///< are we using rate control?
+        
+        /**
+         * Can we send an event in this slot. subject to rate control and 
+         * byte availability.
+         * @return true if we can send an event on this slot
+         */
+        bool canRead();
+
-        // FIXME: this is not really OO, but for performance???
-        void *getBufferAddress();
@@ -228 +288 @@
-        freebob_ringbuffer_t *m_ringbuffer;
-        bool m_use_external_buffer;
+        
+        bool m_do_ratecontrol;
+        int m_event_interval;
+        int m_slot_interval;
+        int m_rate_counter;
+        int m_rate_counter_minimum;
+        bool m_average_ratecontrol;
-
-        bool allocateInternalBuffer();