#13795: Initial commit for sflphone-android
includes: libexpat libyaml libdbus-c++ commoncpp ccrtp
libdbus (from android-4.0.4 sources)
TODO:
- git ignores "/jni/sflphone", sflphone repo should be cloned.
- sflphone-android only needs daemon directory. Ideally it should be possible
to clone it without cloning the whole sflphone project.
into sfl-android (commit 6a0fa7a "#13961: Fix cipher handling" has been used here)
- add pjsip-android project as a git submodule
- sflphone-android needs pjsip android project. Ideally daemon git repository
should not embed pjsip. Instead pjsip should be clone from official repositories.
Considering this, structure should have three distincts git repos:
sflphone-android/.git
sflphone-android/jni/ccrtp-1.8.0-android
sflphone-android/jni/commoncpp2-1.8.1-android
sflphone-android/jni/dbus
sflphone-android/jni/libdbus-c++-0.9.0-android
sflphone-android/jni/libexpat
sflphone-android/jni/libyaml
sflphone-android/jni/sflphone-daemon/.git
sflphone-android/jni/sflphone-daemon/src/audio
sflphone-android/jni/sflphone-daemon/src/config
sflphone-android/jni/sflphone-daemon/src/dbus
sflphone-android/jni/sflphone-daemon/src/history
sflphone-android/jni/sflphone-daemon/src/hooks
sflphone-android/jni/sflphone-daemon/src/iax
sflphone-android/jni/sflphone-daemon/src/sip
sflphone-android/jni/sflphone-daemon/src/video
sflphone-android/jni/pjsip-android/.git
Signed-off-by: Emeric Vigier <emeric.vigier@savoirfairelinux.com>
diff --git a/jni/ccrtp-1.8.0-android/src/ccrtp/ioqueue.h b/jni/ccrtp-1.8.0-android/src/ccrtp/ioqueue.h
new file mode 100644
index 0000000..d8aa239
--- /dev/null
+++ b/jni/ccrtp-1.8.0-android/src/ccrtp/ioqueue.h
@@ -0,0 +1,343 @@
+// Copyright (C) 2001,2002,2004 Federico Montesino Pouzols <fedemp@altern.org>.
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+//
+// As a special exception, you may use this file as part of a free software
+// library without restriction. Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License. This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+//
+// This exception applies only to the code released under the name GNU
+// ccRTP. If you copy code from other releases into a copy of GNU
+// ccRTP, as the General Public License permits, the exception does
+// not apply to the code that you add in this way. To avoid misleading
+// anyone as to the status of such modified files, you must delete
+// this exception notice from them.
+//
+// If you write modifications of your own for GNU ccRTP, it is your choice
+// whether to permit this exception to apply to your modifications.
+// If you do not wish that, delete this exception notice.
+//
+
+/**
+ * @file ioqueue.h
+ *
+ * @short Generic RTP input/output queues.
+ **/
+
+#ifndef CCXX_RTP_IOQUEUE_H_
+#define CCXX_RTP_IOQUEUE_H_
+
+#include <ccrtp/iqueue.h>
+#include <ccrtp/oqueue.h>
+
+#ifdef CCXX_NAMESPACES
+namespace ost {
+#endif
+
+/**
+ * @defgroup ioqueue Generic RTP input/output queues.
+ * @{
+ **/
+
+/**
+ * @class RTPDataQueue
+ *
+ * A packet queue handler for building different kinds of RTP protocol
+ * systems. The queue manages both incoming and outgoing RTP packets,
+ * as well as synchronization and transmission/reception timers. By
+ * making the queue handler a seperate base class it becomes possible
+ * to define RTP classes for RTP profiles and sessions of different
+ * types.
+ *
+ * Outgoing packets are sent via the OutgoingDataQueue::putData method.
+ *
+ * Incoming packets can be retrieved via IncomingDataQueue::getData
+ * method.
+ *
+ * @author David Sugar <dyfet@ostel.com>
+ * @short RTP data queue handler.
+ */
+class __EXPORT RTPDataQueue :
+ 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;
+
+ /**
+ * 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; }
+
+ /**
+ * Disable packet queue processing in the stack.
+ **/
+ inline void disableStack()
+ { dataServiceActive = false; }
+
+ /**
+ * 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;
+
+ /**
+ * 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
+ getSessionBandwidth() const
+ { return sessionBw; }
+
+ /**
+ * 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(); }
+
+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);
+
+ /**
+ * 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(); }
+
+ /**
+ * A plugin point for timer tick driven events.
+ */
+ inline virtual void
+ timerTick()
+ { return; }
+
+ void renewLocalSSRC()
+ {IncomingDataQueue::renewLocalSSRC();}
+
+private:
+ RTPDataQueue(const RTPDataQueue &o);
+
+ RTPDataQueue&
+ operator=(const RTPDataQueue &o);
+
+ /**
+ * Global queue initialization.
+ *
+ * @param localSSRC local 32-bit SSRC identifier
+ **/
+ void
+ initQueue();
+
+protected:
+ /**
+ * 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;
+
+private:
+ // 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
+
+#endif //CCXX_RTP_IOQUEUE_H_
+
+/** EMACS **
+ * Local variables:
+ * mode: c++
+ * c-basic-offset: 8
+ * End:
+ */