tstamp_buffering.H

Go to the documentation of this file.

// Copyright (C) 2006-2007 University of Louisiana at Lafayette
// Authors: Suresh Golconda, Pablo Mejia

#ifndef CAJUN_TSTAMP_BUFFERING_H
#define CAJUN_TSTAMP_BUFFERING_H

#include "data_type.H"

#include "util.H"

#include <deque>
#include <vector>

namespace cajun
{
template <class T> class tstamp_buffering_t
{
public:
        tstamp_buffering_t ()
        {
                m_last_tstamp = 0;
                m_expect_first_data = true;
                m_buffer_size = 1;
        }

        tstamp_buffering_t (unsigned buffer_size_)
        {
                m_last_tstamp = 0;
                m_expect_first_data = true;
                m_buffer_size = buffer_size_;
        }

        bool get_data (std::vector<T> &data_list_)
        {
                if (m_ready_list.empty ()) return false;
                data_list_ = m_ready_list.back ();
                if (m_ready_list.size () > 1)
                        m_ready_list.pop_back ();
                return true;
        }

        bool get_next_data (std::vector<T> &data_list_)
        {
                if (m_ready_list.empty ()) return false;
                data_list_ = m_ready_list.front ();
//              if (m_ready_list.size () > 1)
                m_ready_list.pop_front ();
                return true;
        }

        bool data_available ()
        {
                return ! m_ready_list.empty ();
        }

        bool update_data (std::vector<T> &data_list_)
        {
                for (unsigned i = 0; i < data_list_.size (); i++)
                {
                        // If its first data for the buffer, then update
                        // last_tstamp value
                        if (m_expect_first_data)
                        {
                                m_expect_first_data = false;
                                m_last_tstamp = data_list_[i].tstamp;
                        }

                        if (! are_equal (m_last_tstamp, data_list_[i].tstamp))
                        {
                                m_last_tstamp = data_list_[i].tstamp;
                                flush_buffer ();
                                m_buffer_list.push_back (data_list_[i]);
                        }
                        else if (data_list_[i].packet_id + 1 ==
                                 data_list_[i].total_packets)
                        {// If last packet of the sequence
                                m_expect_first_data = true;
                                m_last_tstamp = data_list_[i].tstamp;
                                m_buffer_list.push_back (data_list_[i]);
                                flush_buffer ();
                        }
                        else
                                m_buffer_list.push_back (data_list_[i]);
                }
                return true;
        }
private:
        std::vector<T> m_buffer_list;
        std::deque< std::vector<T> > m_ready_list;

        void flush_buffer ()
        {
                // Move buffer to ready list
                m_ready_list.push_back (std::vector<T> ());
                m_ready_list.back ().swap (m_buffer_list);
                if (m_ready_list.size () > m_buffer_size)
                {
//                      printf ("tstamp_buffering_t : flushing buffer\n");
                        m_ready_list.pop_front ();
                }
        }

        double m_last_tstamp;
        bool m_expect_first_data;
        unsigned m_buffer_size;
};
};

#endif

---