Switch commoncpp2 to ucommon to solve dependency conflicts.
libccrtp was depending on commoncpp2, and have been replaced by a version
depending on ucommon as well.
diff --git a/jni/libccrtp/sources/src/ccrtp/ioqueue.h b/jni/libccrtp/sources/src/ccrtp/ioqueue.h
index d8aa239..c33c3c3 100644
--- a/jni/libccrtp/sources/src/ccrtp/ioqueue.h
+++ b/jni/libccrtp/sources/src/ccrtp/ioqueue.h
@@ -41,15 +41,13 @@
* @short Generic RTP input/output queues.
**/
-#ifndef CCXX_RTP_IOQUEUE_H_
+#ifndef CCXX_RTP_IOQUEUE_H_
#define CCXX_RTP_IOQUEUE_H_
#include <ccrtp/iqueue.h>
#include <ccrtp/oqueue.h>
-#ifdef CCXX_NAMESPACES
-namespace ost {
-#endif
+NAMESPACE_COMMONCPP
/**
* @defgroup ioqueue Generic RTP input/output queues.
@@ -75,56 +73,56 @@
* @short RTP data queue handler.
*/
class __EXPORT RTPDataQueue :
- public IncomingDataQueue,
- public OutgoingDataQueue
+ public IncomingDataQueue,
+ public OutgoingDataQueue
{
public:
- /**
- * @enum Tos rtp.h cc++/rtp.h
- * @short Type of network service the application uses.
- *
- * If the application uses enhanced network service, for
- * instance Integrated Services or Differentiated Services, it
- * <em>has not</em> to ensure fair competition with TCP,
- * provided that the requested service is actually being
- * delivered. Whenever the application uses best-effort
- * service or the requested enhanced service is not actually
- * being delivered, it <em>has</em> to ensure fair competition
- * with TCP. By default, best-effot is assumed.
- *
- * @note Although not required, RTP packets are always sent on
- * top of UDP segments. No other underlying transport protocol
- * is supported at present.
- *
- * @todo implement fair competition with tcp
- **/
- typedef enum {
- tosBestEffort, ///< Best-effort network service
- tosEnhanced ///< Enhanced network service
- } Tos;
+ /**
+ * @enum Tos rtp.h cc++/rtp.h
+ * @short Type of network service the application uses.
+ *
+ * If the application uses enhanced network service, for
+ * instance Integrated Services or Differentiated Services, it
+ * <em>has not</em> to ensure fair competition with TCP,
+ * provided that the requested service is actually being
+ * delivered. Whenever the application uses best-effort
+ * service or the requested enhanced service is not actually
+ * being delivered, it <em>has</em> to ensure fair competition
+ * with TCP. By default, best-effot is assumed.
+ *
+ * @note Although not required, RTP packets are always sent on
+ * top of UDP segments. No other underlying transport protocol
+ * is supported at present.
+ *
+ * @todo implement fair competition with tcp
+ **/
+ typedef enum {
+ tosBestEffort, ///< Best-effort network service
+ tosEnhanced ///< Enhanced network service
+ } Tos;
- /**
- * Specify the kind of service the application expects to use.
- *
- * @param tos type of service the application expects to use
- *
- * @note If enhanced service is specified but packet loss is
- * high (the requested service does not appear to actually be
- * delivered) ccRTP defaults to best-effort suitable
- * behaviour: guarantee fair competition with TCP.
- *
- * @todo Implement fair competition with tcp
- **/
- inline void
- setTypeOfService(Tos tos)
- { typeOfService = tos; }
+ /**
+ * Specify the kind of service the application expects to use.
+ *
+ * @param tos type of service the application expects to use
+ *
+ * @note If enhanced service is specified but packet loss is
+ * high (the requested service does not appear to actually be
+ * delivered) ccRTP defaults to best-effort suitable
+ * behaviour: guarantee fair competition with TCP.
+ *
+ * @todo Implement fair competition with tcp
+ **/
+ inline void
+ setTypeOfService(Tos tos)
+ { typeOfService = tos; }
- /**
- * Enable packet queue processing in the stack. This method
- * will not any thread of execution.
- **/
- inline void enableStack()
- { dataServiceActive = true; }
+ /**
+ * Enable packet queue processing in the stack. This method
+ * will not any thread of execution.
+ **/
+ inline void enableStack()
+ { dataServiceActive = true; }
/**
* Disable packet queue processing in the stack.
@@ -132,206 +130,204 @@
inline void disableStack()
{ dataServiceActive = false; }
- /**
- * Get active connection state flag.
- *
- * @return true if connection "active".
- */
- inline bool
- isActive() const
- { return dataServiceActive; }
+ /**
+ * Get active connection state flag.
+ *
+ * @return true if connection "active".
+ */
+ inline bool
+ isActive() const
+ { return dataServiceActive; }
- /**
- * Get the timestamp that should be given for a packet whose
- * payload sampling instant corresponds to the current system
- * time.
- *
- * The timestamp applications should provide for each packet
- * represents the sampling instant of its payload and should
- * not be a reading of the system clock. Nevertheless, the
- * internal operation of the RTP stack relies on the accuracy
- * of the provided timestamp, since several computations
- * assume that there is a certain degree of correspondence
- * between the timestamp and the system clock.
- *
- * It is recommended that applications use this method in
- * order to <em>periodically adjust the RTP timestamp</em>.
- *
- * In particular, it is advisable getting the timestamp
- * corresponding to the first sampling instant or any instant
- * after a period of inactivity through a call to this method.
- *
- * Applications should use the nominal sampling or
- * any other value provided by the coder in order to compute
- * the next timestamps with minimum computational requirement.
- *
- * For instance, an application using an RTP profile that
- * specifies a fixed sampling rate of 8 Khz with eight bits
- * per sample, continuously transmitting audio blocks 80
- * octets long, would transmit 100 packets every
- * second. Every packet would carry a timestamp 80 units
- * greater than the previous one. So, the first timestamp
- * would be obtained from this method, whereas the following
- * ones would be computed adding 80 every time. Also the
- * timestamp should be increased for every block whether
- * it is put in the queue or dropped.
- *
- * The aforementioned increment can be obtained from the
- * RTPDataQueue::getTimestampIncrement() method rather than
- * computing it by hand in the application.
- *
- * @note Frame based applications must follow a specific
- * timestamping method, probably specified in a profile.
- *
- * @note You should take into account that by default ccRTP
- * assumes that the application begins sampling at the queue
- * creation time. Moreover, the first sampling instant is
- * assigned a "user visible" timestamp of 0, although the RTP
- * stack will then add internally a ramdom offset unknown to
- * the application. That is to say, the application may count
- * samples from 0 in order to get the timestamp for the next
- * packet, provided that the first sampling instant is the
- * same as the queue creation time. Nevertheless, this
- * simpler way of starting will not be as accurate as it would
- * be if the application got at least the first timestamp
- * through getCurrentTimestamp. <em>We provide this option
- * since ccRTP interface is evolving, but we admit that it is
- * ugly, we could remove this option or even replace uint32
- * timestamps with a restrictively regulated object;
- * suggestions are gladly welcomed</em>
- **/
- uint32
- getCurrentTimestamp() const;
+ /**
+ * Get the timestamp that should be given for a packet whose
+ * payload sampling instant corresponds to the current system
+ * time.
+ *
+ * The timestamp applications should provide for each packet
+ * represents the sampling instant of its payload and should
+ * not be a reading of the system clock. Nevertheless, the
+ * internal operation of the RTP stack relies on the accuracy
+ * of the provided timestamp, since several computations
+ * assume that there is a certain degree of correspondence
+ * between the timestamp and the system clock.
+ *
+ * It is recommended that applications use this method in
+ * order to <em>periodically adjust the RTP timestamp</em>.
+ *
+ * In particular, it is advisable getting the timestamp
+ * corresponding to the first sampling instant or any instant
+ * after a period of inactivity through a call to this method.
+ *
+ * Applications should use the nominal sampling or
+ * any other value provided by the coder in order to compute
+ * the next timestamps with minimum computational requirement.
+ *
+ * For instance, an application using an RTP profile that
+ * specifies a fixed sampling rate of 8 Khz with eight bits
+ * per sample, continuously transmitting audio blocks 80
+ * octets long, would transmit 100 packets every
+ * second. Every packet would carry a timestamp 80 units
+ * greater than the previous one. So, the first timestamp
+ * would be obtained from this method, whereas the following
+ * ones would be computed adding 80 every time. Also the
+ * timestamp should be increased for every block whether
+ * it is put in the queue or dropped.
+ *
+ * The aforementioned increment can be obtained from the
+ * RTPDataQueue::getTimestampIncrement() method rather than
+ * computing it by hand in the application.
+ *
+ * @note Frame based applications must follow a specific
+ * timestamping method, probably specified in a profile.
+ *
+ * @note You should take into account that by default ccRTP
+ * assumes that the application begins sampling at the queue
+ * creation time. Moreover, the first sampling instant is
+ * assigned a "user visible" timestamp of 0, although the RTP
+ * stack will then add internally a ramdom offset unknown to
+ * the application. That is to say, the application may count
+ * samples from 0 in order to get the timestamp for the next
+ * packet, provided that the first sampling instant is the
+ * same as the queue creation time. Nevertheless, this
+ * simpler way of starting will not be as accurate as it would
+ * be if the application got at least the first timestamp
+ * through getCurrentTimestamp. <em>We provide this option
+ * since ccRTP interface is evolving, but we admit that it is
+ * ugly, we could remove this option or even replace uint32
+ * timestamps with a restrictively regulated object;
+ * suggestions are gladly welcomed</em>
+ **/
+ uint32
+ getCurrentTimestamp() const;
- /**
- * Specify the bandwidth of the current session.
- *
- * @param bw bandwidth of the current session, in bits/s.
- *
- * @see AVPQueue::setControlBandwidth()
- */
- void
- setSessionBandwidth(uint32 bw)
- { sessionBw = bw; }
+ /**
+ * Specify the bandwidth of the current session.
+ *
+ * @param bw bandwidth of the current session, in bits/s.
+ *
+ * @see AVPQueue::setControlBandwidth()
+ */
+ void
+ setSessionBandwidth(uint32 bw)
+ { sessionBw = bw; }
- uint32
- getDefaultSessionBandwidth() const
- { return defaultSessionBw; }
+ uint32
+ getDefaultSessionBandwidth() const
+ { return defaultSessionBw; }
- uint32
- getSessionBandwidth() const
- { return sessionBw; }
+ uint32
+ getSessionBandwidth() const
+ { return sessionBw; }
- /**
- * Set the packet timeclock for synchronizing timestamps.
- **/
- inline void
- setTimeclock()
- { timeclock.setTimer(); }
+ /**
+ * Set the packet timeclock for synchronizing timestamps.
+ **/
+ inline void
+ setTimeclock()
+ { timeclock.setTimer(); }
- /**
- * Get the packet timeclock for synchronizing timestamps.
- *
- * @return runtime in milliseconds since last set.
- */
- inline timeout_t
- getTimeclock() const
- { return timeclock.getElapsed(); }
+ /**
+ * Get the packet timeclock for synchronizing timestamps.
+ *
+ * @return runtime in milliseconds since last set.
+ */
+ inline timeout_t
+ getTimeclock() const
+ { return timeclock.getElapsed(); }
protected:
- /**
- * Constructor. This will generate a random application SSRC
- * identifier.
- *
- * @param size an estimation of the number of participants in
- * the session
- **/
- RTPDataQueue(uint32 size = defaultMembersHashSize);
+ /**
+ * Constructor. This will generate a random application SSRC
+ * identifier.
+ *
+ * @param size an estimation of the number of participants in
+ * the session
+ **/
+ RTPDataQueue(uint32 size = defaultMembersHashSize);
- /**
- * Using this constructor you can start a session with the
- * given ssrc, instead of the usual randomly generated
- * one. This is necessary when you need to initiate several
- * sessions having the same SSRC identifier, for instance, to
- * implement layered encoding, in which case each layer is
- * managed through a different session but all sessions share
- * the same SSRC identifier.
- *
- * @warning This doesn't seem to be a good solution
- *
- * @param ssrc Synchronization SouRCe identifier for this session
- * @param size an estimation of the number of participants in the
- * session
- */
- RTPDataQueue(uint32* ssrc, uint32 size = defaultMembersHashSize);
+ /**
+ * Using this constructor you can start a session with the
+ * given ssrc, instead of the usual randomly generated
+ * one. This is necessary when you need to initiate several
+ * sessions having the same SSRC identifier, for instance, to
+ * implement layered encoding, in which case each layer is
+ * managed through a different session but all sessions share
+ * the same SSRC identifier.
+ *
+ * @warning This doesn't seem to be a good solution
+ *
+ * @param ssrc Synchronization SouRCe identifier for this session
+ * @param size an estimation of the number of participants in the
+ * session
+ */
+ RTPDataQueue(uint32* ssrc, uint32 size = defaultMembersHashSize);
- /**
- * The queue destructor flushes the queue and stops all
- * services.
- */
- inline virtual
- ~RTPDataQueue()
- { endQueue(); }
+ /**
+ * The queue destructor flushes the queue and stops all
+ * services.
+ */
+ inline virtual
+ ~RTPDataQueue()
+ { endQueue(); }
/**
* A plugin point for timer tick driven events.
*/
inline virtual void
- timerTick()
- { return; }
+ timerTick()
+ { return; }
- void renewLocalSSRC()
- {IncomingDataQueue::renewLocalSSRC();}
+ void renewLocalSSRC()
+ {IncomingDataQueue::renewLocalSSRC();}
private:
- RTPDataQueue(const RTPDataQueue &o);
+ RTPDataQueue(const RTPDataQueue &o);
- RTPDataQueue&
- operator=(const RTPDataQueue &o);
+ RTPDataQueue&
+ operator=(const RTPDataQueue &o);
- /**
- * Global queue initialization.
- *
- * @param localSSRC local 32-bit SSRC identifier
- **/
- void
- initQueue();
+ /**
+ * Global queue initialization.
+ *
+ * @param localSSRC local 32-bit SSRC identifier
+ **/
+ void
+ initQueue();
protected:
- /**
- * This method ends the queue.
- */
- void
- endQueue();
+ /**
+ * This method ends the queue.
+ */
+ void
+ endQueue();
- /**
- * This function is used to check for and schedule against
- * arriving packets based on the derived connection type.
- *
- * @return true if packet waiting for processing.
- * @param number of microseconds to wait.
- */
- virtual bool
- isPendingData(microtimeout_t timeout) = 0;
+ /**
+ * This function is used to check for and schedule against
+ * arriving packets based on the derived connection type.
+ *
+ * @return true if packet waiting for processing.
+ * @param number of microseconds to wait.
+ */
+ virtual bool
+ isPendingData(microtimeout_t timeout) = 0;
private:
- // true if connection "active"
- volatile bool dataServiceActive;
- Tos typeOfService;
- TimerPort timeclock;
- /* RTP session bandwidth control */
- static const uint32 defaultSessionBw;
- uint32 sessionBw;
+ // true if connection "active"
+ volatile bool dataServiceActive;
+ Tos typeOfService;
+ TimerPort timeclock;
+ /* RTP session bandwidth control */
+ static const uint32 defaultSessionBw;
+ uint32 sessionBw;
};
/** @}*/ // ioqueue
-#ifdef CCXX_NAMESPACES
-}
-#endif
+END_NAMESPACE
#endif //CCXX_RTP_IOQUEUE_H_