* #27232: jni: added pjproject checkout as regular git content
We will remove it once the next release of pjsip (with Android support)
comes out and is merged into SFLphone.
diff --git a/jni/pjproject-android/.svn/pristine/af/af19e0b30bd0b806e23b3602b71b61969b91454c.svn-base b/jni/pjproject-android/.svn/pristine/af/af19e0b30bd0b806e23b3602b71b61969b91454c.svn-base
new file mode 100644
index 0000000..4f788bb
--- /dev/null
+++ b/jni/pjproject-android/.svn/pristine/af/af19e0b30bd0b806e23b3602b71b61969b91454c.svn-base
@@ -0,0 +1,35 @@
+/* $Id$ */
+/*
+ * Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
+ * Copyright (C) 2003-2008 Benny Prijono <benny@prijono.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
+ */
+#include <pj/rand.h>
+#include <pj/os.h>
+#include <pj/compat/rand.h>
+
+PJ_DEF(void) pj_srand(unsigned int seed)
+{
+ PJ_CHECK_STACK();
+ platform_srand(seed);
+}
+
+PJ_DEF(int) pj_rand(void)
+{
+ PJ_CHECK_STACK();
+ return platform_rand();
+}
+
diff --git a/jni/pjproject-android/.svn/pristine/af/af4e8c9c3886739973ccc27d1bb3b3f547392ba3.svn-base b/jni/pjproject-android/.svn/pristine/af/af4e8c9c3886739973ccc27d1bb3b3f547392ba3.svn-base
new file mode 100644
index 0000000..a0c083f
--- /dev/null
+++ b/jni/pjproject-android/.svn/pristine/af/af4e8c9c3886739973ccc27d1bb3b3f547392ba3.svn-base
@@ -0,0 +1,24 @@
+/* $Id$ */
+/*
+ * Copyright (C) 2009-2011 Teluu Inc. (http://www.teluu.com)
+ *
+ * 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
+ */
+
+/*
+ * This file is a C++ wrapper, see ticket #886 for details.
+ */
+
+#include "sip_auth_parser.c"
diff --git a/jni/pjproject-android/.svn/pristine/af/af70e0f54cf36e8518142a15b3d568801f6da0d8.svn-base b/jni/pjproject-android/.svn/pristine/af/af70e0f54cf36e8518142a15b3d568801f6da0d8.svn-base
new file mode 100644
index 0000000..647b078
--- /dev/null
+++ b/jni/pjproject-android/.svn/pristine/af/af70e0f54cf36e8518142a15b3d568801f6da0d8.svn-base
@@ -0,0 +1,146 @@
+/* $Id$ */
+/*
+ * Copyright (C) 2011-2013 Teluu Inc. (http://www.teluu.com)
+ * Copyright (C) 2011 Dan Arrhenius <dan@keystream.se>
+ *
+ * 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
+ */
+#ifndef __PJMEDIA_CODEC_OPENCORE_AMR_H__
+#define __PJMEDIA_CODEC_OPENCORE_AMR_H__
+
+#include <pjmedia-codec/types.h>
+
+/**
+ * @defgroup PJMED_OC_AMR OpenCORE AMR Codec
+ * @ingroup PJMEDIA_CODEC_CODECS
+ * @brief AMRCodec wrapper for OpenCORE AMR codec
+ * @{
+ */
+
+PJ_BEGIN_DECL
+
+/**
+ * Bitmask options to be passed during AMR codec factory initialization.
+ */
+enum pjmedia_amr_options
+{
+ PJMEDIA_AMR_NO_NB = 1, /**< Disable narrowband mode. */
+ PJMEDIA_AMR_NO_WB = 2, /**< Disable wideband mode. */
+};
+
+/**
+ * Settings. Use #pjmedia_codec_opencore_amrnb/wb_set_config() to
+ * activate.
+ */
+typedef struct pjmedia_codec_amr_config
+{
+ /**
+ * Control whether to use octent align.
+ */
+ pj_bool_t octet_align;
+
+ /**
+ * Set the bitrate.
+ */
+ unsigned bitrate;
+
+} pjmedia_codec_amr_config;
+
+typedef pjmedia_codec_amr_config pjmedia_codec_amrnb_config;
+typedef pjmedia_codec_amr_config pjmedia_codec_amrwb_config;
+
+/**
+ * Initialize and register AMR codec factory to pjmedia endpoint.
+ *
+ * @param endpt The pjmedia endpoint.
+ * @param options Bitmask of pjmedia_amr_options (default=0).
+ *
+ * @return PJ_SUCCESS on success.
+ */
+PJ_DECL(pj_status_t) pjmedia_codec_opencore_amr_init(pjmedia_endpt* endpt,
+ unsigned options);
+
+/**
+ * Initialize and register AMR codec factory using default settings to
+ * pjmedia endpoint.
+ *
+ * @param endpt The pjmedia endpoint.
+ *
+ * @return PJ_SUCCESS on success.
+ */
+PJ_DECL(pj_status_t)
+pjmedia_codec_opencore_amr_init_default(pjmedia_endpt* endpt);
+
+/**
+ * Unregister AMR codec factory from pjmedia endpoint and deinitialize
+ * the OpenCORE codec library.
+ *
+ * @return PJ_SUCCESS on success.
+ */
+PJ_DECL(pj_status_t) pjmedia_codec_opencore_amr_deinit(void);
+
+/**
+ * Initialize and register AMR-NB codec factory to pjmedia endpoint. Calling
+ * this function will automatically initialize AMR codec factory without
+ * the wideband mode (i.e. it is equivalent to calling
+ * #pjmedia_codec_opencore_amr_init() with PJMEDIA_AMR_NO_WB). Application
+ * should call #pjmedia_codec_opencore_amr_init() instead if wishing to use
+ * both modes.
+ *
+ * @param endpt The pjmedia endpoint.
+ *
+ * @return PJ_SUCCESS on success.
+ */
+PJ_DECL(pj_status_t) pjmedia_codec_opencore_amrnb_init(pjmedia_endpt* endpt);
+
+/**
+ * Unregister AMR-NB codec factory from pjmedia endpoint and deinitialize
+ * the OpenCORE codec library.
+ *
+ * @return PJ_SUCCESS on success.
+ */
+PJ_DECL(pj_status_t) pjmedia_codec_opencore_amrnb_deinit(void);
+
+
+/**
+ * Set AMR-NB parameters.
+ *
+ * @param cfg The settings;
+ *
+ * @return PJ_SUCCESS on success.
+ */
+PJ_DECL(pj_status_t) pjmedia_codec_opencore_amrnb_set_config(
+ const pjmedia_codec_amrnb_config* cfg);
+
+
+/**
+ * Set AMR-WB parameters.
+ *
+ * @param cfg The settings;
+ *
+ * @return PJ_SUCCESS on success.
+ */
+PJ_DECL(pj_status_t) pjmedia_codec_opencore_amrwb_set_config(
+ const pjmedia_codec_amrwb_config* cfg);
+
+PJ_END_DECL
+
+
+/**
+ * @}
+ */
+
+#endif /* __PJMEDIA_CODEC_OPENCORE_AMRNB_H__ */
+
diff --git a/jni/pjproject-android/.svn/pristine/af/af73523c33d540b651f798792e0e1819a4d32b6e.svn-base b/jni/pjproject-android/.svn/pristine/af/af73523c33d540b651f798792e0e1819a4d32b6e.svn-base
new file mode 100644
index 0000000..5d14f35
--- /dev/null
+++ b/jni/pjproject-android/.svn/pristine/af/af73523c33d540b651f798792e0e1819a4d32b6e.svn-base
@@ -0,0 +1,193 @@
+EXPORTS
+ echo_supp_cancel_echo @ 1 NONAME
+ echo_supp_capture @ 2 NONAME
+ echo_supp_create @ 3 NONAME
+ echo_supp_destroy @ 4 NONAME
+ echo_supp_playback @ 5 NONAME
+ pjmedia_bidirectional_port_create @ 6 NONAME
+ pjmedia_calc_avg_signal @ 7 NONAME
+ pjmedia_clock_create @ 8 NONAME
+ pjmedia_clock_destroy @ 9 NONAME
+ pjmedia_clock_start @ 10 NONAME
+ pjmedia_clock_stop @ 11 NONAME
+ pjmedia_clock_wait @ 12 NONAME
+ pjmedia_codec_g711_deinit @ 13 NONAME
+ pjmedia_codec_g711_init @ 14 NONAME
+ pjmedia_codec_info_to_id @ 15 NONAME
+ pjmedia_codec_mgr_alloc_codec @ 16 NONAME
+ pjmedia_codec_mgr_dealloc_codec @ 17 NONAME
+ pjmedia_codec_mgr_enum_codecs @ 18 NONAME
+ pjmedia_codec_mgr_find_codecs_by_id @ 19 NONAME
+ pjmedia_codec_mgr_get_codec_info @ 20 NONAME
+ pjmedia_codec_mgr_get_default_param @ 21 NONAME
+ pjmedia_codec_mgr_init @ 22 NONAME
+ pjmedia_codec_mgr_register_factory @ 23 NONAME
+ pjmedia_codec_mgr_set_codec_priority @ 24 NONAME
+ pjmedia_codec_mgr_unregister_factory @ 25 NONAME
+ pjmedia_conf_add_passive_port @ 26 NONAME
+ pjmedia_conf_add_port @ 27 NONAME
+ pjmedia_conf_adjust_rx_level @ 28 NONAME
+ pjmedia_conf_adjust_tx_level @ 29 NONAME
+ pjmedia_conf_configure_port @ 30 NONAME
+ pjmedia_conf_connect_port @ 31 NONAME
+ pjmedia_conf_create @ 32 NONAME
+ pjmedia_conf_destroy @ 33 NONAME
+ pjmedia_conf_disconnect_port @ 34 NONAME
+ pjmedia_conf_enum_ports @ 35 NONAME
+ pjmedia_conf_get_connect_count @ 36 NONAME
+ pjmedia_conf_get_master_port @ 37 NONAME
+ pjmedia_conf_get_port_count @ 38 NONAME
+ pjmedia_conf_get_port_info @ 39 NONAME
+ pjmedia_conf_get_ports_info @ 40 NONAME
+ pjmedia_conf_get_signal_level @ 41 NONAME
+ pjmedia_conf_remove_port @ 42 NONAME
+ pjmedia_conf_set_port0_name @ 43 NONAME
+ pjmedia_delay_buf_create @ 44 NONAME
+ pjmedia_delay_buf_get @ 45 NONAME
+ pjmedia_delay_buf_put @ 46 NONAME
+ pjmedia_echo_cancel @ 47 NONAME
+ pjmedia_echo_capture @ 48 NONAME
+ pjmedia_echo_create @ 49 NONAME
+ pjmedia_echo_destroy @ 50 NONAME
+ pjmedia_echo_playback @ 51 NONAME
+ pjmedia_echo_port_create @ 52 NONAME
+ pjmedia_endpt_create @ 53 NONAME
+ pjmedia_endpt_create_pool @ 54 NONAME
+ pjmedia_endpt_create_sdp @ 55 NONAME
+ pjmedia_endpt_destroy @ 56 NONAME
+ pjmedia_endpt_dump @ 57 NONAME
+ pjmedia_endpt_get_codec_mgr @ 58 NONAME
+ pjmedia_endpt_get_ioqueue @ 59 NONAME
+ pjmedia_endpt_get_thread @ 60 NONAME
+ pjmedia_endpt_get_thread_count @ 61 NONAME
+ pjmedia_ice_create @ 62 NONAME
+ pjmedia_ice_destroy @ 63 NONAME
+ pjmedia_ice_get_comp @ 64 NONAME
+ pjmedia_ice_get_init_status @ 65 NONAME
+ pjmedia_ice_init_ice @ 66 NONAME
+ pjmedia_ice_modify_sdp @ 67 NONAME
+ pjmedia_ice_simulate_lost @ 68 NONAME
+ pjmedia_ice_start_ice @ 69 NONAME
+ pjmedia_ice_start_init @ 70 NONAME
+ pjmedia_ice_stop_ice @ 71 NONAME
+ pjmedia_jbuf_create @ 72 NONAME
+ pjmedia_jbuf_destroy @ 73 NONAME
+ pjmedia_jbuf_get_frame @ 74 NONAME
+ pjmedia_jbuf_get_state @ 75 NONAME
+ pjmedia_jbuf_put_frame @ 76 NONAME
+ pjmedia_jbuf_reset @ 77 NONAME
+ pjmedia_jbuf_set_adaptive @ 78 NONAME
+ pjmedia_jbuf_set_fixed @ 79 NONAME
+ pjmedia_master_port_create @ 80 NONAME
+ pjmedia_master_port_destroy @ 81 NONAME
+ pjmedia_master_port_get_dport @ 82 NONAME
+ pjmedia_master_port_get_uport @ 83 NONAME
+ pjmedia_master_port_set_dport @ 84 NONAME
+ pjmedia_master_port_set_uport @ 85 NONAME
+ pjmedia_master_port_start @ 86 NONAME
+ pjmedia_master_port_stop @ 87 NONAME
+ pjmedia_mem_capture_create @ 88 NONAME
+ pjmedia_mem_capture_get_size @ 89 NONAME
+ pjmedia_mem_capture_set_eof_cb @ 90 NONAME
+ pjmedia_mem_player_create @ 91 NONAME
+ pjmedia_mem_player_set_eof_cb @ 92 NONAME
+ pjmedia_null_port_create @ 93 NONAME
+ pjmedia_plc_create @ 94 NONAME
+ pjmedia_plc_generate @ 95 NONAME
+ pjmedia_plc_save @ 96 NONAME
+ pjmedia_port_destroy @ 97 NONAME
+ pjmedia_port_get_frame @ 98 NONAME
+ pjmedia_port_info_init @ 99 NONAME
+ pjmedia_port_put_frame @ 100 NONAME
+ pjmedia_resample_create @ 101 NONAME
+ pjmedia_resample_destroy @ 102 NONAME
+ pjmedia_resample_get_input_size @ 103 NONAME
+ pjmedia_resample_port_create @ 104 NONAME
+ pjmedia_resample_run @ 105 NONAME
+ pjmedia_rtcp_build_rtcp @ 106 NONAME
+ pjmedia_rtcp_fini @ 107 NONAME
+ pjmedia_rtcp_get_ntp_time @ 108 NONAME
+ pjmedia_rtcp_init @ 109 NONAME
+ pjmedia_rtcp_rx_rtcp @ 110 NONAME
+ pjmedia_rtcp_rx_rtp @ 111 NONAME
+ pjmedia_rtcp_tx_rtp @ 112 NONAME
+ pjmedia_rtp_decode_rtp @ 113 NONAME
+ pjmedia_rtp_encode_rtp @ 114 NONAME
+ pjmedia_rtp_session_init @ 115 NONAME
+ pjmedia_rtp_session_update @ 116 NONAME
+ pjmedia_session_check_dtmf @ 117 NONAME
+ pjmedia_session_create @ 118 NONAME
+ pjmedia_session_destroy @ 119 NONAME
+ pjmedia_session_dial_dtmf @ 120 NONAME
+ pjmedia_session_enum_streams @ 121 NONAME
+ pjmedia_session_get_dtmf @ 122 NONAME
+ pjmedia_session_get_info @ 123 NONAME
+ pjmedia_session_get_port @ 124 NONAME
+ pjmedia_session_get_stream_stat @ 125 NONAME
+ pjmedia_session_info_from_sdp @ 126 NONAME
+ pjmedia_session_pause @ 127 NONAME
+ pjmedia_session_pause_stream @ 128 NONAME
+ pjmedia_session_resume @ 129 NONAME
+ pjmedia_session_resume_stream @ 130 NONAME
+ pjmedia_session_set_dtmf_callback @ 131 NONAME
+ pjmedia_silence_det_apply @ 132 NONAME
+ pjmedia_silence_det_create @ 133 NONAME
+ pjmedia_silence_det_detect @ 134 NONAME
+ pjmedia_silence_det_disable @ 135 NONAME
+ pjmedia_silence_det_set_adaptive @ 136 NONAME
+ pjmedia_silence_det_set_fixed @ 137 NONAME
+ pjmedia_silence_det_set_name @ 138 NONAME
+ pjmedia_silence_det_set_params @ 139 NONAME
+ pjmedia_snd_port_connect @ 140 NONAME
+ pjmedia_snd_port_create @ 141 NONAME
+ pjmedia_snd_port_create_player @ 142 NONAME
+ pjmedia_snd_port_create_rec @ 143 NONAME
+ pjmedia_snd_port_destroy @ 144 NONAME
+ pjmedia_snd_port_disconnect @ 145 NONAME
+ pjmedia_snd_port_get_ec_tail @ 146 NONAME
+ pjmedia_snd_port_get_port @ 147 NONAME
+ pjmedia_snd_port_get_snd_stream @ 148 NONAME
+ pjmedia_snd_port_set_ec @ 149 NONAME
+ pjmedia_splitcomb_create @ 150 NONAME
+ pjmedia_splitcomb_create_rev_channel @ 151 NONAME
+ pjmedia_splitcomb_set_channel @ 152 NONAME
+ pjmedia_stream_check_dtmf @ 153 NONAME
+ pjmedia_stream_create @ 154 NONAME
+ pjmedia_stream_destroy @ 155 NONAME
+ pjmedia_stream_dial_dtmf @ 156 NONAME
+ pjmedia_stream_get_dtmf @ 157 NONAME
+ pjmedia_stream_get_port @ 158 NONAME
+ pjmedia_stream_get_stat @ 159 NONAME
+ pjmedia_stream_get_transport @ 160 NONAME
+ pjmedia_stream_info_from_sdp @ 161 NONAME
+ pjmedia_stream_pause @ 162 NONAME
+ pjmedia_stream_resume @ 163 NONAME
+ pjmedia_stream_set_dtmf_callback @ 164 NONAME
+ pjmedia_stream_start @ 165 NONAME
+ pjmedia_strerror @ 166 NONAME
+ pjmedia_tonegen_create @ 167 NONAME
+ pjmedia_tonegen_create2 @ 168 NONAME
+ pjmedia_tonegen_get_digit_map @ 169 NONAME
+ pjmedia_tonegen_is_busy @ 170 NONAME
+ pjmedia_tonegen_play @ 171 NONAME
+ pjmedia_tonegen_play_digits @ 172 NONAME
+ pjmedia_tonegen_set_digit_map @ 173 NONAME
+ pjmedia_tonegen_stop @ 174 NONAME
+ pjmedia_transport_udp_attach @ 175 NONAME
+ pjmedia_transport_udp_close @ 176 NONAME
+ pjmedia_transport_udp_create @ 177 NONAME
+ pjmedia_transport_udp_create2 @ 178 NONAME
+ pjmedia_transport_udp_create3 @ 179 NONAME
+ pjmedia_transport_udp_get_info @ 180 NONAME
+ pjmedia_transport_udp_simulate_lost @ 181 NONAME
+ pjmedia_wav_player_port_create @ 182 NONAME
+ pjmedia_wav_player_port_get_pos @ 183 NONAME
+ pjmedia_wav_player_port_set_pos @ 184 NONAME
+ pjmedia_wav_player_set_eof_cb @ 185 NONAME
+ pjmedia_wav_playlist_create @ 186 NONAME
+ pjmedia_wav_playlist_set_eof_cb @ 187 NONAME
+ pjmedia_wav_writer_port_create @ 188 NONAME
+ pjmedia_wav_writer_port_get_pos @ 189 NONAME
+ pjmedia_wav_writer_port_set_cb @ 190 NONAME
+ pjmedia_wave_hdr_file_to_host @ 191 NONAME
+ pjmedia_wave_hdr_host_to_file @ 192 NONAME
diff --git a/jni/pjproject-android/.svn/pristine/af/af889e6f86ad9ba5e374245a9efb4f69837f97c5.svn-base b/jni/pjproject-android/.svn/pristine/af/af889e6f86ad9ba5e374245a9efb4f69837f97c5.svn-base
new file mode 100644
index 0000000..edfd40f
--- /dev/null
+++ b/jni/pjproject-android/.svn/pristine/af/af889e6f86ad9ba5e374245a9efb4f69837f97c5.svn-base
@@ -0,0 +1,31 @@
+# $Id$
+import inc_sip as sip
+import inc_sdp as sdp
+
+pjsua = "--null-audio --id=sip:CLIENT --registrar sip:127.0.0.1:$PORT " + \
+ "--realm=* --user=username --password=password " + \
+ "--auto-update-nat=0"
+
+# 401 Response, missing realm value
+req1 = sip.RecvfromTransaction("Initial request", 401,
+ include=["REGISTER sip"],
+ exclude=[],
+ resp_hdr=['WWW-Authenticate: Digest']
+ )
+
+# Client should retry, we giving it another 401 with empty realm
+req2 = sip.RecvfromTransaction("REGISTER retry #1 of 2", 407,
+ include=["REGISTER sip"],
+ exclude=[],
+ resp_hdr=['Proxy-Authenticate: Digest realm=""']
+ )
+
+# Client should retry
+req3 = sip.RecvfromTransaction("REGISTER retry #2 of 2", 200,
+ include=[],
+ exclude=[],
+ expect="registration success"
+ )
+
+recvfrom_cfg = sip.RecvfromCfg("Registration with empty realm",
+ pjsua, [req1, req2, req3])
diff --git a/jni/pjproject-android/.svn/pristine/af/af8f5d7bf29490b56ddf67f94b265c80c804a4b6.svn-base b/jni/pjproject-android/.svn/pristine/af/af8f5d7bf29490b56ddf67f94b265c80c804a4b6.svn-base
new file mode 100644
index 0000000..69a9859
--- /dev/null
+++ b/jni/pjproject-android/.svn/pristine/af/af8f5d7bf29490b56ddf67f94b265c80c804a4b6.svn-base
@@ -0,0 +1,114 @@
+# $Id$
+#
+# pjsua Setup script.
+#
+# Copyright (C) 2003-2008 Benny Prijono <benny@prijono.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
+#
+from distutils.core import setup, Extension
+import os
+import sys
+import platform
+
+# find pjsip version
+pj_version=""
+pj_version_major=""
+pj_version_minor=""
+pj_version_rev=""
+pj_version_suffix=""
+f = open('../../../version.mak', 'r')
+for line in f:
+ if line.find("export PJ_VERSION_MAJOR") != -1:
+ tokens=line.split("=")
+ if len(tokens)>1:
+ pj_version_major= tokens[1].strip()
+ elif line.find("export PJ_VERSION_MINOR") != -1:
+ tokens=line.split("=")
+ if len(tokens)>1:
+ pj_version_minor= line.split("=")[1].strip()
+ elif line.find("export PJ_VERSION_REV") != -1:
+ tokens=line.split("=")
+ if len(tokens)>1:
+ pj_version_rev= line.split("=")[1].strip()
+ elif line.find("export PJ_VERSION_SUFFIX") != -1:
+ tokens=line.split("=")
+ if len(tokens)>1:
+ pj_version_suffix= line.split("=")[1].strip()
+
+f.close()
+if not pj_version_major:
+ print 'Unable to get PJ_VERSION_MAJOR'
+ sys.exit(1)
+
+pj_version = pj_version_major + "." + pj_version_minor
+if pj_version_rev:
+ pj_version += "." + pj_version_rev
+if pj_version_suffix:
+ pj_version += "-" + pj_version_suffix
+
+#print 'PJ_VERSION = "'+ pj_version + '"'
+
+
+# Fill in pj_inc_dirs
+pj_inc_dirs = []
+f = os.popen("make -f helper.mak inc_dir")
+for line in f:
+ pj_inc_dirs.append(line.rstrip("\r\n"))
+f.close()
+
+# Fill in pj_lib_dirs
+pj_lib_dirs = []
+f = os.popen("make -f helper.mak lib_dir")
+for line in f:
+ pj_lib_dirs.append(line.rstrip("\r\n"))
+f.close()
+
+# Fill in pj_libs
+pj_libs = []
+f = os.popen("make -f helper.mak libs")
+for line in f:
+ pj_libs.append(line.rstrip("\r\n"))
+f.close()
+
+# Mac OS X depedencies
+if platform.system() == 'Darwin':
+ extra_link_args = ["-framework", "CoreFoundation",
+ "-framework", "AudioToolbox"]
+ version = platform.mac_ver()[0].split(".")
+ # OS X Lion (10.7.x) or above support
+ if version[0] == '10' and int(version[1]) >= 7:
+ extra_link_args += ["-framework", "AudioUnit"]
+else:
+ extra_link_args = []
+
+
+setup(name="pjsua",
+ version=pj_version,
+ description='SIP User Agent Library based on PJSIP',
+ url='http://trac.pjsip.org/repos/wiki/Python_SIP_Tutorial',
+ ext_modules = [Extension("_pjsua",
+ ["_pjsua.c"],
+ define_macros=[('PJ_AUTOCONF', '1'),],
+ include_dirs=pj_inc_dirs,
+ library_dirs=pj_lib_dirs,
+ libraries=pj_libs,
+ extra_link_args=extra_link_args
+ )
+ ],
+ py_modules=["pjsua"]
+ )
+
+
diff --git a/jni/pjproject-android/.svn/pristine/af/afb68d56fd4857d40154e6cbd398b57bb14b4fd5.svn-base b/jni/pjproject-android/.svn/pristine/af/afb68d56fd4857d40154e6cbd398b57bb14b4fd5.svn-base
new file mode 100644
index 0000000..d7b3344
--- /dev/null
+++ b/jni/pjproject-android/.svn/pristine/af/afb68d56fd4857d40154e6cbd398b57bb14b4fd5.svn-base
@@ -0,0 +1,1680 @@
+/* $Id$ */
+/*
+ * Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
+ * Copyright (C) 2003-2008 Benny Prijono <benny@prijono.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
+ */
+#include <pjmedia-codec/ipp_codecs.h>
+#include <pjmedia-codec/amr_sdp_match.h>
+#include <pjmedia-codec/g7221_sdp_match.h>
+#include <pjmedia/codec.h>
+#include <pjmedia/errno.h>
+#include <pjmedia/endpoint.h>
+#include <pjmedia/plc.h>
+#include <pjmedia/port.h>
+#include <pjmedia/silencedet.h>
+#include <pj/assert.h>
+#include <pj/log.h>
+#include <pj/math.h>
+#include <pj/pool.h>
+#include <pj/string.h>
+#include <pj/os.h>
+
+
+/*
+ * Only build this file if PJMEDIA_HAS_INTEL_IPP != 0
+ */
+#if defined(PJMEDIA_HAS_INTEL_IPP) && PJMEDIA_HAS_INTEL_IPP != 0
+
+#include <usc.h>
+#include <ippversion.h>
+
+#define THIS_FILE "ipp_codecs.c"
+
+
+/* Prototypes for IPP codecs factory */
+static pj_status_t ipp_test_alloc( pjmedia_codec_factory *factory,
+ const pjmedia_codec_info *id );
+static pj_status_t ipp_default_attr( pjmedia_codec_factory *factory,
+ const pjmedia_codec_info *id,
+ pjmedia_codec_param *attr );
+static pj_status_t ipp_enum_codecs( pjmedia_codec_factory *factory,
+ unsigned *count,
+ pjmedia_codec_info codecs[]);
+static pj_status_t ipp_alloc_codec( pjmedia_codec_factory *factory,
+ const pjmedia_codec_info *id,
+ pjmedia_codec **p_codec);
+static pj_status_t ipp_dealloc_codec( pjmedia_codec_factory *factory,
+ pjmedia_codec *codec );
+
+/* Prototypes for IPP codecs implementation. */
+static pj_status_t ipp_codec_init( pjmedia_codec *codec,
+ pj_pool_t *pool );
+static pj_status_t ipp_codec_open( pjmedia_codec *codec,
+ pjmedia_codec_param *attr );
+static pj_status_t ipp_codec_close( pjmedia_codec *codec );
+static pj_status_t ipp_codec_modify(pjmedia_codec *codec,
+ const pjmedia_codec_param *attr );
+static pj_status_t ipp_codec_parse( pjmedia_codec *codec,
+ void *pkt,
+ pj_size_t pkt_size,
+ const pj_timestamp *ts,
+ unsigned *frame_cnt,
+ pjmedia_frame frames[]);
+static pj_status_t ipp_codec_encode( pjmedia_codec *codec,
+ const struct pjmedia_frame *input,
+ unsigned output_buf_len,
+ struct pjmedia_frame *output);
+static pj_status_t ipp_codec_decode( pjmedia_codec *codec,
+ const struct pjmedia_frame *input,
+ unsigned output_buf_len,
+ struct pjmedia_frame *output);
+static pj_status_t ipp_codec_recover(pjmedia_codec *codec,
+ unsigned output_buf_len,
+ struct pjmedia_frame *output);
+
+/* Definition for IPP codecs operations. */
+static pjmedia_codec_op ipp_op =
+{
+ &ipp_codec_init,
+ &ipp_codec_open,
+ &ipp_codec_close,
+ &ipp_codec_modify,
+ &ipp_codec_parse,
+ &ipp_codec_encode,
+ &ipp_codec_decode,
+ &ipp_codec_recover
+};
+
+/* Definition for IPP codecs factory operations. */
+static pjmedia_codec_factory_op ipp_factory_op =
+{
+ &ipp_test_alloc,
+ &ipp_default_attr,
+ &ipp_enum_codecs,
+ &ipp_alloc_codec,
+ &ipp_dealloc_codec,
+ &pjmedia_codec_ipp_deinit
+};
+
+/* IPP codecs factory */
+static struct ipp_factory {
+ pjmedia_codec_factory base;
+ pjmedia_endpt *endpt;
+ pj_pool_t *pool;
+ pj_mutex_t *mutex;
+ unsigned g7221_pcm_shift;
+} ipp_factory;
+
+/* IPP codecs private data. */
+typedef struct ipp_private {
+ int codec_idx; /**< Codec index. */
+ void *codec_setting; /**< Specific codec setting. */
+ pj_pool_t *pool; /**< Pool for each instance. */
+
+ USC_Handle enc; /**< Encoder state. */
+ USC_Handle dec; /**< Decoder state. */
+ USC_CodecInfo *info; /**< Native codec info. */
+ pj_uint16_t frame_size; /**< Bitstream frame size. */
+
+ pj_bool_t plc_enabled; /**< PLC enabled flag. */
+ pjmedia_plc *plc; /**< PJMEDIA PLC engine, NULL if
+ codec has internal PLC. */
+
+ pj_bool_t vad_enabled; /**< VAD enabled flag. */
+ pjmedia_silence_det *vad; /**< PJMEDIA VAD engine, NULL if
+ codec has internal VAD. */
+ pj_timestamp last_tx; /**< Timestamp of last transmit.*/
+
+ unsigned g7221_pcm_shift; /**< G722.1 PCM level adjustment*/
+} ipp_private_t;
+
+
+/* USC codec implementations. */
+extern USC_Fxns USC_G729AFP_Fxns;
+extern USC_Fxns USC_G729I_Fxns;
+extern USC_Fxns USC_G723_Fxns;
+extern USC_Fxns USC_G726_Fxns;
+extern USC_Fxns USC_G728_Fxns;
+extern USC_Fxns USC_G722_Fxns;
+extern USC_Fxns USC_GSMAMR_Fxns;
+extern USC_Fxns USC_AMRWB_Fxns;
+extern USC_Fxns USC_AMRWBE_Fxns;
+
+
+/* CUSTOM CALLBACKS */
+
+/* This callback is useful for translating RTP frame into USC frame, e.g:
+ * reassigning frame attributes, reorder bitstream. Default behaviour of
+ * the translation is just setting the USC frame buffer & its size as
+ * specified in RTP frame, setting USC frame frametype to 0, setting bitrate
+ * of USC frame to bitrate info of codec_data. Implement this callback when
+ * the default behaviour is unapplicable.
+ */
+typedef void (*predecode_cb)(ipp_private_t *codec_data,
+ const pjmedia_frame *rtp_frame,
+ USC_Bitstream *usc_frame);
+
+/* Parse frames from a packet. Default behaviour of frame parsing is
+ * just separating frames based on calculating frame length derived
+ * from bitrate. Implement this callback when the default behaviour is
+ * unapplicable.
+ */
+typedef pj_status_t (*parse_cb)(ipp_private_t *codec_data, void *pkt,
+ pj_size_t pkt_size, const pj_timestamp *ts,
+ unsigned *frame_cnt, pjmedia_frame frames[]);
+
+/* Pack frames into a packet. Default behaviour of packing frames is
+ * just stacking the frames with octet aligned without adding any
+ * payload header. Implement this callback when the default behaviour is
+ * unapplicable.
+ */
+typedef pj_status_t (*pack_cb)(ipp_private_t *codec_data, void *pkt,
+ pj_size_t *pkt_size, pj_size_t max_pkt_size);
+
+
+
+/* Custom callback implementations. */
+static void predecode_g723( ipp_private_t *codec_data,
+ const pjmedia_frame *rtp_frame,
+ USC_Bitstream *usc_frame);
+static pj_status_t parse_g723( ipp_private_t *codec_data, void *pkt,
+ pj_size_t pkt_size, const pj_timestamp *ts,
+ unsigned *frame_cnt, pjmedia_frame frames[]);
+
+static void predecode_g729( ipp_private_t *codec_data,
+ const pjmedia_frame *rtp_frame,
+ USC_Bitstream *usc_frame);
+
+static void predecode_amr( ipp_private_t *codec_data,
+ const pjmedia_frame *rtp_frame,
+ USC_Bitstream *usc_frame);
+static pj_status_t parse_amr( ipp_private_t *codec_data, void *pkt,
+ pj_size_t pkt_size, const pj_timestamp *ts,
+ unsigned *frame_cnt, pjmedia_frame frames[]);
+static pj_status_t pack_amr( ipp_private_t *codec_data, void *pkt,
+ pj_size_t *pkt_size, pj_size_t max_pkt_size);
+
+static void predecode_g7221( ipp_private_t *codec_data,
+ const pjmedia_frame *rtp_frame,
+ USC_Bitstream *usc_frame);
+static pj_status_t pack_g7221( ipp_private_t *codec_data, void *pkt,
+ pj_size_t *pkt_size, pj_size_t max_pkt_size);
+
+/* IPP codec implementation descriptions. */
+static struct ipp_codec {
+ int enabled; /* Is this codec enabled? */
+ const char *name; /* Codec name. */
+ pj_uint8_t pt; /* Payload type. */
+ USC_Fxns *fxns; /* USC callback functions. */
+ unsigned clock_rate; /* Codec's clock rate. */
+ unsigned channel_count; /* Codec's channel count. */
+ unsigned samples_per_frame; /* Codec's samples count. */
+
+ unsigned def_bitrate; /* Default bitrate of this codec. */
+ unsigned max_bitrate; /* Maximum bitrate of this codec. */
+ pj_uint8_t frm_per_pkt; /* Default num of frames per packet.*/
+ int has_native_vad; /* Codec has internal VAD? */
+ int has_native_plc; /* Codec has internal PLC? */
+
+ predecode_cb predecode; /* Callback to translate RTP frame
+ into USC frame. */
+ parse_cb parse; /* Callback to parse bitstream. */
+ pack_cb pack; /* Callback to pack bitstream. */
+
+ pjmedia_codec_fmtp dec_fmtp; /* Decoder's fmtp params. */
+}
+
+ipp_codec[] =
+{
+# if PJMEDIA_HAS_INTEL_IPP_CODEC_AMR
+ {1, "AMR", PJMEDIA_RTP_PT_AMR, &USC_GSMAMR_Fxns, 8000, 1, 160,
+ 7400, 12200, 2, 1, 1,
+ &predecode_amr, &parse_amr, &pack_amr,
+ {1, {{{"octet-align", 11}, {"1", 1}}} }
+ },
+# endif
+
+# if PJMEDIA_HAS_INTEL_IPP_CODEC_AMRWB
+ {1, "AMR-WB", PJMEDIA_RTP_PT_AMRWB, &USC_AMRWB_Fxns, 16000, 1, 320,
+ 15850, 23850, 2, 1, 1,
+ &predecode_amr, &parse_amr, &pack_amr,
+ {1, {{{"octet-align", 11}, {"1", 1}}} }
+ },
+# endif
+
+# if PJMEDIA_HAS_INTEL_IPP_CODEC_G729
+# if defined(PJ_HAS_FLOATING_POINT) && (PJ_HAS_FLOATING_POINT != 0)
+ {1, "G729", PJMEDIA_RTP_PT_G729, &USC_G729AFP_Fxns, 8000, 1, 80,
+ 8000, 11800, 2, 1, 1,
+ &predecode_g729, NULL, NULL
+ },
+# else
+ {1, "G729", PJMEDIA_RTP_PT_G729, &USC_G729I_Fxns, 8000, 1, 80,
+ 8000, 11800, 2, 1, 1,
+ &predecode_g729, NULL, NULL
+ },
+# endif
+# endif
+
+# if PJMEDIA_HAS_INTEL_IPP_CODEC_G723_1
+ /* This is actually G.723.1 */
+ {1, "G723", PJMEDIA_RTP_PT_G723, &USC_G723_Fxns, 8000, 1, 240,
+ 6300, 6300, 1, 1, 1,
+ &predecode_g723, &parse_g723, NULL
+ },
+# endif
+
+# if PJMEDIA_HAS_INTEL_IPP_CODEC_G726
+ {0, "G726-16", PJMEDIA_RTP_PT_G726_16, &USC_G726_Fxns, 8000, 1, 80,
+ 16000, 16000, 2, 0, 0,
+ NULL, NULL, NULL
+ },
+ {0, "G726-24", PJMEDIA_RTP_PT_G726_24, &USC_G726_Fxns, 8000, 1, 80,
+ 24000, 24000, 2, 0, 0,
+ NULL, NULL, NULL
+ },
+ {1, "G726-32", PJMEDIA_RTP_PT_G726_32, &USC_G726_Fxns, 8000, 1, 80,
+ 32000, 32000, 2, 0, 0,
+ NULL, NULL, NULL
+ },
+ {0, "G726-40", PJMEDIA_RTP_PT_G726_40, &USC_G726_Fxns, 8000, 1, 80,
+ 40000, 40000, 2, 0, 0,
+ NULL, NULL, NULL
+ },
+ /* Old definition of G726-32 */
+ {1, "G721", PJMEDIA_RTP_PT_G721, &USC_G726_Fxns, 8000, 1, 80,
+ 32000, 32000, 2, 0, 0,
+ NULL, NULL, NULL
+ },
+# endif
+
+# if PJMEDIA_HAS_INTEL_IPP_CODEC_G728
+ {1, "G728", PJMEDIA_RTP_PT_G728, &USC_G728_Fxns, 8000, 1, 80,
+ 16000, 16000, 2, 0, 1,
+ NULL, NULL, NULL
+ },
+# endif
+
+# if PJMEDIA_HAS_INTEL_IPP_CODEC_G722_1
+ {0, "G7221", PJMEDIA_RTP_PT_G722_1_16, &USC_G722_Fxns, 16000, 1, 320,
+ 16000, 16000, 1, 0, 1,
+ predecode_g7221, NULL, pack_g7221,
+ {1, {{{"bitrate", 7}, {"16000", 5}}} }
+ },
+ {1, "G7221", PJMEDIA_RTP_PT_G722_1_24, &USC_G722_Fxns, 16000, 1, 320,
+ 24000, 24000, 1, 0, 1,
+ predecode_g7221, NULL, pack_g7221,
+ {1, {{{"bitrate", 7}, {"24000", 5}}} }
+ },
+ {1, "G7221", PJMEDIA_RTP_PT_G722_1_32, &USC_G722_Fxns, 16000, 1, 320,
+ 32000, 32000, 1, 0, 1,
+ predecode_g7221, NULL, pack_g7221,
+ {1, {{{"bitrate", 7}, {"32000", 5}}} }
+ },
+# endif
+};
+
+
+#if PJMEDIA_HAS_INTEL_IPP_CODEC_G729
+
+static void predecode_g729( ipp_private_t *codec_data,
+ const pjmedia_frame *rtp_frame,
+ USC_Bitstream *usc_frame)
+{
+ switch (rtp_frame->size) {
+ case 2:
+ /* SID */
+ usc_frame->frametype = 1;
+ usc_frame->bitrate = codec_data->info->params.modes.bitrate;
+ break;
+ case 8:
+ /* G729D */
+ usc_frame->frametype = 2;
+ usc_frame->bitrate = 6400;
+ break;
+ case 10:
+ /* G729 */
+ usc_frame->frametype = 3;
+ usc_frame->bitrate = 8000;
+ break;
+ case 15:
+ /* G729E */
+ usc_frame->frametype = 4;
+ usc_frame->bitrate = 11800;
+ break;
+ default:
+ usc_frame->frametype = 0;
+ usc_frame->bitrate = 0;
+ break;
+ }
+
+ usc_frame->pBuffer = rtp_frame->buf;
+ usc_frame->nbytes = rtp_frame->size;
+}
+
+#endif /* PJMEDIA_HAS_INTEL_IPP_CODEC_G729 */
+
+
+#if PJMEDIA_HAS_INTEL_IPP_CODEC_G723_1
+
+static void predecode_g723( ipp_private_t *codec_data,
+ const pjmedia_frame *rtp_frame,
+ USC_Bitstream *usc_frame)
+{
+ int i, HDR = 0;
+ pj_uint8_t *f = (pj_uint8_t*)rtp_frame->buf;
+
+ PJ_UNUSED_ARG(codec_data);
+
+ for (i = 0; i < 2; ++i){
+ int tmp;
+ tmp = (f[0] >> (i & 0x7)) & 1;
+ HDR += tmp << i ;
+ }
+
+ usc_frame->pBuffer = rtp_frame->buf;
+ usc_frame->nbytes = rtp_frame->size;
+ usc_frame->bitrate = HDR == 0? 6300 : 5300;
+ usc_frame->frametype = 0;
+}
+
+static pj_status_t parse_g723(ipp_private_t *codec_data, void *pkt,
+ pj_size_t pkt_size, const pj_timestamp *ts,
+ unsigned *frame_cnt, pjmedia_frame frames[])
+{
+ unsigned count = 0;
+ pj_uint8_t *f = (pj_uint8_t*)pkt;
+
+ while (pkt_size && count < *frame_cnt) {
+ int framesize, i, j;
+ int HDR = 0;
+
+ for (i = 0; i < 2; ++i){
+ j = (f[0] >> (i & 0x7)) & 1;
+ HDR += j << i ;
+ }
+
+ if (HDR == 0)
+ framesize = 24;
+ else if (HDR == 1)
+ framesize = 20;
+ else if (HDR == 2)
+ framesize = 4;
+ else if (HDR == 3)
+ framesize = 1;
+ else {
+ pj_assert(!"Unknown G723.1 frametype, packet may be corrupted!");
+ return PJMEDIA_CODEC_EINMODE;
+ }
+
+ frames[count].type = PJMEDIA_FRAME_TYPE_AUDIO;
+ frames[count].buf = f;
+ frames[count].size = framesize;
+ frames[count].timestamp.u64 = ts->u64 + count *
+ ipp_codec[codec_data->codec_idx].samples_per_frame;
+
+ f += framesize;
+ pkt_size -= framesize;
+
+ ++count;
+ }
+
+ *frame_cnt = count;
+ return PJ_SUCCESS;
+}
+
+#endif /* PJMEDIA_HAS_INTEL_IPP_CODEC_G723_1 */
+
+
+#if PJMEDIA_HAS_INTEL_IPP_CODEC_AMR || PJMEDIA_HAS_INTEL_IPP_CODEC_AMRWB
+
+#include <pjmedia-codec/amr_helper.h>
+
+typedef struct amr_settings_t {
+ pjmedia_codec_amr_pack_setting enc_setting;
+ pjmedia_codec_amr_pack_setting dec_setting;
+ pj_int8_t enc_mode;
+} amr_settings_t;
+
+
+/* Rearrange AMR bitstream and convert RTP frame into USC frame:
+ * - make the start_bit to be 0
+ * - if it is speech frame, reorder bitstream from sensitivity bits order
+ * to encoder bits order.
+ * - set the appropriate value of usc_frame.
+ */
+static void predecode_amr( ipp_private_t *codec_data,
+ const pjmedia_frame *rtp_frame,
+ USC_Bitstream *usc_frame)
+{
+ pjmedia_frame frame;
+ pjmedia_codec_amr_bit_info *info;
+ pjmedia_codec_amr_pack_setting *setting;
+
+ setting = &((amr_settings_t*)codec_data->codec_setting)->dec_setting;
+
+ frame = *rtp_frame;
+ pjmedia_codec_amr_predecode(rtp_frame, setting, &frame);
+ info = (pjmedia_codec_amr_bit_info*) &frame.bit_info;
+
+ usc_frame->pBuffer = frame.buf;
+ usc_frame->nbytes = frame.size;
+ if (info->mode != -1) {
+ usc_frame->bitrate = setting->amr_nb?
+ pjmedia_codec_amrnb_bitrates[info->mode]:
+ pjmedia_codec_amrwb_bitrates[info->mode];
+ } else {
+ usc_frame->bitrate = 0;
+ }
+
+ if (frame.size > 5) {
+ /* Speech */
+ if (info->good_quality)
+ usc_frame->frametype = 0;
+ else
+ usc_frame->frametype = setting->amr_nb ? 5 : 6;
+ } else if (frame.size == 5) {
+ /* SID */
+ if (info->good_quality) {
+ usc_frame->frametype = info->STI? 2 : 1;
+ } else {
+ usc_frame->frametype = setting->amr_nb ? 6 : 7;
+ }
+ } else {
+ /* no data */
+ usc_frame->frametype = 3;
+ }
+}
+
+/* Pack AMR payload */
+static pj_status_t pack_amr(ipp_private_t *codec_data, void *pkt,
+ pj_size_t *pkt_size, pj_size_t max_pkt_size)
+{
+ enum {MAX_FRAMES_PER_PACKET = PJMEDIA_MAX_FRAME_DURATION_MS / 20};
+
+ pjmedia_frame frames[MAX_FRAMES_PER_PACKET];
+ unsigned nframes = 0;
+ pjmedia_codec_amr_bit_info *info;
+ pj_uint8_t *r; /* Read cursor */
+ pj_uint8_t SID_FT;
+ pjmedia_codec_amr_pack_setting *setting;
+ const pj_uint8_t *framelen_tbl;
+
+ setting = &((amr_settings_t*)codec_data->codec_setting)->enc_setting;
+ framelen_tbl = setting->amr_nb? pjmedia_codec_amrnb_framelen:
+ pjmedia_codec_amrwb_framelen;
+
+ SID_FT = (pj_uint8_t)(setting->amr_nb? 8 : 9);
+
+ /* Align pkt buf right */
+ r = (pj_uint8_t*)pkt + max_pkt_size - *pkt_size;
+ pj_memmove(r, pkt, *pkt_size);
+
+ /* Get frames */
+ for (;;) {
+ pj_bool_t eof;
+ pj_uint16_t info_;
+
+ info_ = *((pj_uint16_t*)r);
+ eof = ((info_ & 0x40) != 0);
+
+ info = (pjmedia_codec_amr_bit_info*) &frames[nframes].bit_info;
+ pj_bzero(info, sizeof(*info));
+ info->frame_type = (pj_uint8_t)(info_ & 0x0F);
+ info->good_quality = (pj_uint8_t)((info_ & 0x80) == 0);
+ info->mode = (pj_int8_t) ((info_ >> 8) & 0x0F);
+ info->STI = (pj_uint8_t)((info_ >> 5) & 1);
+
+ frames[nframes].buf = r + 2;
+ frames[nframes].size = info->frame_type <= SID_FT ?
+ framelen_tbl[info->frame_type] : 0;
+
+ r += frames[nframes].size + 2;
+
+ /* Last frame */
+ if (++nframes >= MAX_FRAMES_PER_PACKET || eof)
+ break;
+ }
+
+ /* Pack */
+ *pkt_size = max_pkt_size;
+ return pjmedia_codec_amr_pack(frames, nframes, setting, pkt, pkt_size);
+}
+
+
+/* Parse AMR payload into frames. */
+static pj_status_t parse_amr(ipp_private_t *codec_data, void *pkt,
+ pj_size_t pkt_size, const pj_timestamp *ts,
+ unsigned *frame_cnt, pjmedia_frame frames[])
+{
+ amr_settings_t* s = (amr_settings_t*)codec_data->codec_setting;
+ pjmedia_codec_amr_pack_setting *setting;
+ pj_status_t status;
+ pj_uint8_t cmr;
+
+ setting = &s->dec_setting;
+
+ status = pjmedia_codec_amr_parse(pkt, pkt_size, ts, setting, frames,
+ frame_cnt, &cmr);
+ if (status != PJ_SUCCESS)
+ return status;
+
+ /* Check Change Mode Request. */
+ if (((setting->amr_nb && cmr <= 7) || (!setting->amr_nb && cmr <= 8)) &&
+ s->enc_mode != cmr)
+ {
+ struct ipp_codec *ippc = &ipp_codec[codec_data->codec_idx];
+
+ s->enc_mode = cmr;
+ codec_data->info->params.modes.bitrate = s->enc_setting.amr_nb?
+ pjmedia_codec_amrnb_bitrates[s->enc_mode] :
+ pjmedia_codec_amrwb_bitrates[s->enc_mode];
+ ippc->fxns->std.Control(&codec_data->info->params.modes,
+ codec_data->enc);
+
+ PJ_LOG(4,(THIS_FILE, "AMR%s switched encoding mode to: %d (%dbps)",
+ (s->enc_setting.amr_nb?"":"-WB"),
+ s->enc_mode,
+ codec_data->info->params.modes.bitrate));
+ }
+
+ return PJ_SUCCESS;
+}
+
+#endif /* PJMEDIA_HAS_INTEL_IPP_CODEC_AMR */
+
+
+#if PJMEDIA_HAS_INTEL_IPP_CODEC_G722_1
+
+static void predecode_g7221( ipp_private_t *codec_data,
+ const pjmedia_frame *rtp_frame,
+ USC_Bitstream *usc_frame)
+{
+ usc_frame->pBuffer = (char*)rtp_frame->buf;
+ usc_frame->nbytes = rtp_frame->size;
+ usc_frame->frametype = 0;
+ usc_frame->bitrate = codec_data->info->params.modes.bitrate;
+
+#if defined(PJ_IS_LITTLE_ENDIAN) && PJ_IS_LITTLE_ENDIAN!=0
+ {
+ pj_uint16_t *p, *p_end;
+
+ p = (pj_uint16_t*)rtp_frame->buf;
+ p_end = p + rtp_frame->size/2;
+ while (p < p_end) {
+ *p = pj_ntohs(*p);
+ ++p;
+ }
+ }
+#endif
+}
+
+static pj_status_t pack_g7221( ipp_private_t *codec_data, void *pkt,
+ pj_size_t *pkt_size, pj_size_t max_pkt_size)
+{
+ PJ_UNUSED_ARG(codec_data);
+ PJ_UNUSED_ARG(max_pkt_size);
+
+#if defined(PJ_IS_LITTLE_ENDIAN) && PJ_IS_LITTLE_ENDIAN!=0
+ {
+ pj_uint16_t *p, *p_end;
+
+ p = (pj_uint16_t*)pkt;
+ p_end = p + *pkt_size/2;
+ while (p < p_end) {
+ *p = pj_htons(*p);
+ ++p;
+ }
+ }
+#else
+ PJ_UNUSED_ARG(pkt);
+ PJ_UNUSED_ARG(pkt_size);
+#endif
+
+ return PJ_SUCCESS;
+}
+
+
+#include <pjmedia-codec/g7221.h>
+
+
+PJ_DEF(pj_status_t) pjmedia_codec_g7221_set_pcm_shift(int val)
+{
+ PJ_ASSERT_RETURN(val >= 0, PJ_EINVAL);
+
+ ipp_factory.g7221_pcm_shift = val;
+ return PJ_SUCCESS;
+}
+
+
+#endif /* PJMEDIA_HAS_INTEL_IPP_CODEC_G722_1 */
+
+/*
+ * Initialize and register IPP codec factory to pjmedia endpoint.
+ */
+PJ_DEF(pj_status_t) pjmedia_codec_ipp_init( pjmedia_endpt *endpt )
+{
+ pjmedia_codec_mgr *codec_mgr;
+ pj_str_t codec_name;
+ pj_status_t status;
+
+ if (ipp_factory.pool != NULL) {
+ /* Already initialized. */
+ return PJ_SUCCESS;
+ }
+
+ /* Create IPP codec factory. */
+ ipp_factory.base.op = &ipp_factory_op;
+ ipp_factory.base.factory_data = NULL;
+ ipp_factory.endpt = endpt;
+ ipp_factory.g7221_pcm_shift = PJMEDIA_G7221_DEFAULT_PCM_SHIFT;
+
+ ipp_factory.pool = pjmedia_endpt_create_pool(endpt, "IPP codecs", 4000, 4000);
+ if (!ipp_factory.pool)
+ return PJ_ENOMEM;
+
+ /* Create mutex. */
+ status = pj_mutex_create_simple(ipp_factory.pool, "IPP codecs",
+ &ipp_factory.mutex);
+ if (status != PJ_SUCCESS)
+ goto on_error;
+
+ /* Get the codec manager. */
+ codec_mgr = pjmedia_endpt_get_codec_mgr(endpt);
+ if (!codec_mgr) {
+ status = PJ_EINVALIDOP;
+ goto on_error;
+ }
+
+ /* Register format match callback. */
+#if PJMEDIA_HAS_INTEL_IPP_CODEC_G722_1
+ pj_cstr(&codec_name, "G7221");
+ status = pjmedia_sdp_neg_register_fmt_match_cb(
+ &codec_name,
+ &pjmedia_codec_g7221_match_sdp);
+ if (status != PJ_SUCCESS)
+ goto on_error;
+#endif
+
+#if PJMEDIA_HAS_INTEL_IPP_CODEC_AMR
+ pj_cstr(&codec_name, "AMR");
+ status = pjmedia_sdp_neg_register_fmt_match_cb(
+ &codec_name,
+ &pjmedia_codec_amr_match_sdp);
+ if (status != PJ_SUCCESS)
+ goto on_error;
+#endif
+
+#if PJMEDIA_HAS_INTEL_IPP_CODEC_AMRWB
+ pj_cstr(&codec_name, "AMR-WB");
+ status = pjmedia_sdp_neg_register_fmt_match_cb(
+ &codec_name,
+ &pjmedia_codec_amr_match_sdp);
+ if (status != PJ_SUCCESS)
+ goto on_error;
+#endif
+
+ /* Suppress compile warning */
+ PJ_UNUSED_ARG(codec_name);
+
+ /* Register codec factory to endpoint. */
+ status = pjmedia_codec_mgr_register_factory(codec_mgr,
+ &ipp_factory.base);
+ if (status != PJ_SUCCESS)
+ goto on_error;
+
+ /* Done. */
+ return PJ_SUCCESS;
+
+on_error:
+ pj_pool_release(ipp_factory.pool);
+ ipp_factory.pool = NULL;
+ return status;
+}
+
+/*
+ * Unregister IPP codecs factory from pjmedia endpoint.
+ */
+PJ_DEF(pj_status_t) pjmedia_codec_ipp_deinit(void)
+{
+ pjmedia_codec_mgr *codec_mgr;
+ pj_status_t status;
+
+ if (ipp_factory.pool == NULL) {
+ /* Already deinitialized */
+ return PJ_SUCCESS;
+ }
+
+ pj_mutex_lock(ipp_factory.mutex);
+
+ /* Get the codec manager. */
+ codec_mgr = pjmedia_endpt_get_codec_mgr(ipp_factory.endpt);
+ if (!codec_mgr) {
+ pj_pool_release(ipp_factory.pool);
+ ipp_factory.pool = NULL;
+ return PJ_EINVALIDOP;
+ }
+
+ /* Unregister IPP codecs factory. */
+ status = pjmedia_codec_mgr_unregister_factory(codec_mgr,
+ &ipp_factory.base);
+
+ /* Destroy mutex. */
+ pj_mutex_destroy(ipp_factory.mutex);
+
+ /* Destroy pool. */
+ pj_pool_release(ipp_factory.pool);
+ ipp_factory.pool = NULL;
+
+ return status;
+}
+
+
+/*
+ * Check if factory can allocate the specified codec.
+ */
+static pj_status_t ipp_test_alloc( pjmedia_codec_factory *factory,
+ const pjmedia_codec_info *info )
+{
+ unsigned i;
+
+ PJ_UNUSED_ARG(factory);
+
+ /* Type MUST be audio. */
+ if (info->type != PJMEDIA_TYPE_AUDIO)
+ return PJMEDIA_CODEC_EUNSUP;
+
+ for (i = 0; i < PJ_ARRAY_SIZE(ipp_codec); ++i) {
+ pj_str_t name = pj_str((char*)ipp_codec[i].name);
+ if ((pj_stricmp(&info->encoding_name, &name) == 0) &&
+ (info->clock_rate == (unsigned)ipp_codec[i].clock_rate) &&
+ (info->channel_cnt == (unsigned)ipp_codec[i].channel_count) &&
+ (ipp_codec[i].enabled))
+ {
+ return PJ_SUCCESS;
+ }
+ }
+
+ /* Unsupported, or mode is disabled. */
+ return PJMEDIA_CODEC_EUNSUP;
+}
+
+/*
+ * Generate default attribute.
+ */
+static pj_status_t ipp_default_attr (pjmedia_codec_factory *factory,
+ const pjmedia_codec_info *id,
+ pjmedia_codec_param *attr )
+{
+ unsigned i;
+
+ PJ_ASSERT_RETURN(factory==&ipp_factory.base, PJ_EINVAL);
+
+ pj_bzero(attr, sizeof(pjmedia_codec_param));
+
+ for (i = 0; i < PJ_ARRAY_SIZE(ipp_codec); ++i) {
+ pj_str_t name = pj_str((char*)ipp_codec[i].name);
+ if ((pj_stricmp(&id->encoding_name, &name) == 0) &&
+ (id->clock_rate == (unsigned)ipp_codec[i].clock_rate) &&
+ (id->channel_cnt == (unsigned)ipp_codec[i].channel_count) &&
+ (id->pt == (unsigned)ipp_codec[i].pt))
+ {
+ attr->info.pt = (pj_uint8_t)id->pt;
+ attr->info.channel_cnt = ipp_codec[i].channel_count;
+ attr->info.clock_rate = ipp_codec[i].clock_rate;
+ attr->info.avg_bps = ipp_codec[i].def_bitrate;
+ attr->info.max_bps = ipp_codec[i].max_bitrate;
+ attr->info.pcm_bits_per_sample = 16;
+ attr->info.frm_ptime = (pj_uint16_t)
+ (ipp_codec[i].samples_per_frame * 1000 /
+ ipp_codec[i].channel_count /
+ ipp_codec[i].clock_rate);
+ attr->setting.frm_per_pkt = ipp_codec[i].frm_per_pkt;
+
+ /* Default flags. */
+ attr->setting.plc = 1;
+ attr->setting.penh= 0;
+ attr->setting.vad = 1;
+ attr->setting.cng = attr->setting.vad;
+ attr->setting.dec_fmtp = ipp_codec[i].dec_fmtp;
+
+ if (attr->setting.vad == 0) {
+#if PJMEDIA_HAS_INTEL_IPP_CODEC_G729
+ if (id->pt == PJMEDIA_RTP_PT_G729) {
+ /* Signal G729 Annex B is being disabled */
+ attr->setting.dec_fmtp.cnt = 1;
+ pj_strset2(&attr->setting.dec_fmtp.param[0].name, "annexb");
+ pj_strset2(&attr->setting.dec_fmtp.param[0].val, "no");
+ }
+#endif
+ }
+
+ return PJ_SUCCESS;
+ }
+ }
+
+ return PJMEDIA_CODEC_EUNSUP;
+}
+
+/*
+ * Enum codecs supported by this factory.
+ */
+static pj_status_t ipp_enum_codecs(pjmedia_codec_factory *factory,
+ unsigned *count,
+ pjmedia_codec_info codecs[])
+{
+ unsigned max;
+ unsigned i;
+
+ PJ_UNUSED_ARG(factory);
+ PJ_ASSERT_RETURN(codecs && *count > 0, PJ_EINVAL);
+
+ max = *count;
+
+ for (i = 0, *count = 0; i < PJ_ARRAY_SIZE(ipp_codec) && *count < max; ++i)
+ {
+ if (!ipp_codec[i].enabled)
+ continue;
+
+ pj_bzero(&codecs[*count], sizeof(pjmedia_codec_info));
+ codecs[*count].encoding_name = pj_str((char*)ipp_codec[i].name);
+ codecs[*count].pt = ipp_codec[i].pt;
+ codecs[*count].type = PJMEDIA_TYPE_AUDIO;
+ codecs[*count].clock_rate = ipp_codec[i].clock_rate;
+ codecs[*count].channel_cnt = ipp_codec[i].channel_count;
+
+ ++*count;
+ }
+
+ return PJ_SUCCESS;
+}
+
+/*
+ * Allocate a new codec instance.
+ */
+static pj_status_t ipp_alloc_codec( pjmedia_codec_factory *factory,
+ const pjmedia_codec_info *id,
+ pjmedia_codec **p_codec)
+{
+ ipp_private_t *codec_data;
+ pjmedia_codec *codec;
+ int idx;
+ pj_pool_t *pool;
+ unsigned i;
+
+ PJ_ASSERT_RETURN(factory && id && p_codec, PJ_EINVAL);
+ PJ_ASSERT_RETURN(factory == &ipp_factory.base, PJ_EINVAL);
+
+ pj_mutex_lock(ipp_factory.mutex);
+
+ /* Find codec's index */
+ idx = -1;
+ for (i = 0; i < PJ_ARRAY_SIZE(ipp_codec); ++i) {
+ pj_str_t name = pj_str((char*)ipp_codec[i].name);
+ if ((pj_stricmp(&id->encoding_name, &name) == 0) &&
+ (id->clock_rate == (unsigned)ipp_codec[i].clock_rate) &&
+ (id->channel_cnt == (unsigned)ipp_codec[i].channel_count) &&
+ (ipp_codec[i].enabled))
+ {
+ idx = i;
+ break;
+ }
+ }
+ if (idx == -1) {
+ *p_codec = NULL;
+ return PJMEDIA_CODEC_EFAILED;
+ }
+
+ /* Create pool for codec instance */
+ pool = pjmedia_endpt_create_pool(ipp_factory.endpt, "IPPcodec", 512, 512);
+ codec = PJ_POOL_ZALLOC_T(pool, pjmedia_codec);
+ PJ_ASSERT_RETURN(codec != NULL, PJ_ENOMEM);
+ codec->op = &ipp_op;
+ codec->factory = factory;
+ codec->codec_data = PJ_POOL_ZALLOC_T(pool, ipp_private_t);
+ codec_data = (ipp_private_t*) codec->codec_data;
+
+ /* Create PLC if codec has no internal PLC */
+ if (!ipp_codec[idx].has_native_plc) {
+ pj_status_t status;
+ status = pjmedia_plc_create(pool, ipp_codec[idx].clock_rate,
+ ipp_codec[idx].samples_per_frame, 0,
+ &codec_data->plc);
+ if (status != PJ_SUCCESS) {
+ pj_pool_release(pool);
+ pj_mutex_unlock(ipp_factory.mutex);
+ return status;
+ }
+ }
+
+ /* Create silence detector if codec has no internal VAD */
+ if (!ipp_codec[idx].has_native_vad) {
+ pj_status_t status;
+ status = pjmedia_silence_det_create(pool,
+ ipp_codec[idx].clock_rate,
+ ipp_codec[idx].samples_per_frame,
+ &codec_data->vad);
+ if (status != PJ_SUCCESS) {
+ pj_pool_release(pool);
+ pj_mutex_unlock(ipp_factory.mutex);
+ return status;
+ }
+ }
+
+ codec_data->pool = pool;
+ codec_data->codec_idx = idx;
+
+ pj_mutex_unlock(ipp_factory.mutex);
+
+ *p_codec = codec;
+ return PJ_SUCCESS;
+}
+
+/*
+ * Free codec.
+ */
+static pj_status_t ipp_dealloc_codec( pjmedia_codec_factory *factory,
+ pjmedia_codec *codec )
+{
+ ipp_private_t *codec_data;
+
+ PJ_ASSERT_RETURN(factory && codec, PJ_EINVAL);
+ PJ_ASSERT_RETURN(factory == &ipp_factory.base, PJ_EINVAL);
+
+ /* Close codec, if it's not closed. */
+ codec_data = (ipp_private_t*) codec->codec_data;
+ if (codec_data->enc != NULL || codec_data->dec != NULL) {
+ ipp_codec_close(codec);
+ }
+
+ pj_pool_release(codec_data->pool);
+
+ return PJ_SUCCESS;
+}
+
+/*
+ * Init codec.
+ */
+static pj_status_t ipp_codec_init( pjmedia_codec *codec,
+ pj_pool_t *pool )
+{
+ PJ_UNUSED_ARG(codec);
+ PJ_UNUSED_ARG(pool);
+ return PJ_SUCCESS;
+}
+
+/*
+ * Open codec.
+ */
+static pj_status_t ipp_codec_open( pjmedia_codec *codec,
+ pjmedia_codec_param *attr )
+{
+ ipp_private_t *codec_data = (ipp_private_t*) codec->codec_data;
+ struct ipp_codec *ippc = &ipp_codec[codec_data->codec_idx];
+ int info_size;
+ pj_pool_t *pool;
+ int i, j;
+ USC_MemBank *membanks;
+ int nb_membanks;
+
+ pool = codec_data->pool;
+
+ /* Get the codec info size */
+ if (USC_NoError != ippc->fxns->std.GetInfoSize(&info_size)) {
+ PJ_LOG(1,(THIS_FILE, "Error getting codec info size"));
+ goto on_error;
+ }
+ /* Get the codec info */
+ codec_data->info = pj_pool_zalloc(pool, info_size);
+ if (USC_NoError != ippc->fxns->std.GetInfo((USC_Handle)NULL,
+ codec_data->info))
+ {
+ PJ_LOG(1,(THIS_FILE, "Error getting codec info"));
+ goto on_error;
+ }
+
+ /* PREPARING THE ENCODER */
+
+ /* Setting the encoder params */
+ codec_data->info->params.direction = USC_ENCODE;
+ codec_data->info->params.modes.vad = attr->setting.vad &&
+ ippc->has_native_vad;
+ codec_data->info->params.modes.bitrate = attr->info.avg_bps;
+ codec_data->info->params.law = 0; /* Linear PCM input */
+
+#if PJMEDIA_HAS_INTEL_IPP_CODEC_G729
+ if (ippc->pt == PJMEDIA_RTP_PT_G729) {
+ /* Check if G729 Annex B is signaled to be disabled */
+ for (i = 0; i < attr->setting.enc_fmtp.cnt; ++i) {
+ if (pj_stricmp2(&attr->setting.enc_fmtp.param[i].name, "annexb")==0)
+ {
+ if (pj_stricmp2(&attr->setting.enc_fmtp.param[i].val, "no")==0)
+ {
+ attr->setting.vad = 0;
+ codec_data->info->params.modes.vad = 0;
+ }
+ break;
+ }
+ }
+ }
+#endif
+
+ /* Get number of memory blocks needed by the encoder */
+ if (USC_NoError != ippc->fxns->std.NumAlloc(&codec_data->info->params,
+ &nb_membanks))
+ {
+ PJ_LOG(1,(THIS_FILE, "Error getting no of memory blocks of encoder"));
+ goto on_error;
+ }
+
+ /* Allocate memory blocks table */
+ membanks = (USC_MemBank*) pj_pool_zalloc(pool,
+ sizeof(USC_MemBank) * nb_membanks);
+ /* Get size of each memory block */
+ if (USC_NoError != ippc->fxns->std.MemAlloc(&codec_data->info->params,
+ membanks))
+ {
+ PJ_LOG(1,(THIS_FILE, "Error getting memory blocks size of encoder"));
+ goto on_error;
+ }
+
+ /* Allocate memory for each block */
+ for (i = 0; i < nb_membanks; i++) {
+ membanks[i].pMem = (char*) pj_pool_zalloc(pool, membanks[i].nbytes);
+ }
+
+ /* Create encoder instance */
+ if (USC_NoError != ippc->fxns->std.Init(&codec_data->info->params,
+ membanks,
+ &codec_data->enc))
+ {
+ PJ_LOG(1,(THIS_FILE, "Error initializing encoder"));
+ goto on_error;
+ }
+
+ /* PREPARING THE DECODER */
+
+ /* Setting the decoder params */
+ codec_data->info->params.direction = USC_DECODE;
+
+ /* Not sure if VAD affects decoder, just try to be safe */
+ //codec_data->info->params.modes.vad = ippc->has_native_vad;
+
+ /* Get number of memory blocks needed by the decoder */
+ if (USC_NoError != ippc->fxns->std.NumAlloc(&codec_data->info->params,
+ &nb_membanks))
+ {
+ PJ_LOG(1,(THIS_FILE, "Error getting no of memory blocks of decoder"));
+ goto on_error;
+ }
+
+ /* Allocate memory blocks table */
+ membanks = (USC_MemBank*) pj_pool_zalloc(pool,
+ sizeof(USC_MemBank) * nb_membanks);
+ /* Get size of each memory block */
+ if (USC_NoError != ippc->fxns->std.MemAlloc(&codec_data->info->params,
+ membanks))
+ {
+ PJ_LOG(1,(THIS_FILE, "Error getting memory blocks size of decoder"));
+ goto on_error;
+ }
+
+ /* Allocate memory for each block */
+ for (i = 0; i < nb_membanks; i++) {
+ membanks[i].pMem = (char*) pj_pool_zalloc(pool, membanks[i].nbytes);
+ }
+
+ /* Create decoder instance */
+ if (USC_NoError != ippc->fxns->std.Init(&codec_data->info->params,
+ membanks, &codec_data->dec))
+ {
+ PJ_LOG(1,(THIS_FILE, "Error initializing decoder"));
+ goto on_error;
+ }
+
+ /* Update codec info */
+ ippc->fxns->std.GetInfo((USC_Handle)codec_data->enc, codec_data->info);
+
+ /* Get bitstream size */
+ i = codec_data->info->params.modes.bitrate * ippc->samples_per_frame;
+ j = ippc->clock_rate << 3;
+ codec_data->frame_size = (pj_uint16_t)(i / j);
+ if (i % j) ++codec_data->frame_size;
+
+ codec_data->vad_enabled = (attr->setting.vad != 0);
+ codec_data->plc_enabled = (attr->setting.plc != 0);
+
+#if PJMEDIA_HAS_INTEL_IPP_CODEC_AMR
+ /* Init AMR settings */
+ if (ippc->pt == PJMEDIA_RTP_PT_AMR || ippc->pt == PJMEDIA_RTP_PT_AMRWB) {
+ amr_settings_t *s;
+ pj_uint8_t octet_align = 0;
+ pj_int8_t enc_mode;
+
+ enc_mode = pjmedia_codec_amr_get_mode(
+ codec_data->info->params.modes.bitrate);
+ pj_assert(enc_mode >= 0 && enc_mode <= 8);
+
+ /* Check AMR specific attributes */
+
+ for (i = 0; i < attr->setting.dec_fmtp.cnt; ++i) {
+ /* octet-align, one of the parameters that must have same value
+ * in offer & answer (RFC 4867 Section 8.3.1). Just check fmtp
+ * in the decoder side, since it's value is guaranteed to fulfil
+ * above requirement (by SDP negotiator).
+ */
+ const pj_str_t STR_FMTP_OCTET_ALIGN = {"octet-align", 11};
+
+ if (pj_stricmp(&attr->setting.dec_fmtp.param[i].name,
+ &STR_FMTP_OCTET_ALIGN) == 0)
+ {
+ octet_align=(pj_uint8_t)
+ pj_strtoul(&attr->setting.dec_fmtp.param[i].val);
+ break;
+ }
+ }
+
+ for (i = 0; i < attr->setting.enc_fmtp.cnt; ++i) {
+ /* mode-set, encoding mode is chosen based on local default mode
+ * setting:
+ * - if local default mode is included in the mode-set, use it
+ * - otherwise, find the closest mode to local default mode;
+ * if there are two closest modes, prefer to use the higher
+ * one, e.g: local default mode is 4, the mode-set param
+ * contains '2,3,5,6', then 5 will be chosen.
+ */
+ const pj_str_t STR_FMTP_MODE_SET = {"mode-set", 8};
+
+ if (pj_stricmp(&attr->setting.enc_fmtp.param[i].name,
+ &STR_FMTP_MODE_SET) == 0)
+ {
+ const char *p;
+ pj_size_t l;
+ pj_int8_t diff = 99;
+
+ p = pj_strbuf(&attr->setting.enc_fmtp.param[i].val);
+ l = pj_strlen(&attr->setting.enc_fmtp.param[i].val);
+
+ while (l--) {
+ if ((ippc->pt==PJMEDIA_RTP_PT_AMR && *p>='0' && *p<='7') ||
+ (ippc->pt==PJMEDIA_RTP_PT_AMRWB && *p>='0' && *p<='8'))
+ {
+ pj_int8_t tmp = (pj_int8_t)(*p - '0' - enc_mode);
+
+ if (PJ_ABS(diff) > PJ_ABS(tmp) ||
+ (PJ_ABS(diff) == PJ_ABS(tmp) && tmp > diff))
+ {
+ diff = tmp;
+ if (diff == 0) break;
+ }
+ }
+ ++p;
+ }
+
+ if (diff == 99)
+ goto on_error;
+
+ enc_mode = (pj_int8_t)(enc_mode + diff);
+
+ break;
+ }
+ }
+
+ /* Initialize AMR specific settings */
+ s = PJ_POOL_ZALLOC_T(pool, amr_settings_t);
+ codec_data->codec_setting = s;
+
+ s->enc_setting.amr_nb = (pj_uint8_t)(ippc->pt == PJMEDIA_RTP_PT_AMR);
+ s->enc_setting.octet_aligned = octet_align;
+ s->enc_setting.reorder = PJ_TRUE;
+ s->enc_setting.cmr = 15;
+
+ s->dec_setting.amr_nb = (pj_uint8_t)(ippc->pt == PJMEDIA_RTP_PT_AMR);
+ s->dec_setting.octet_aligned = octet_align;
+ s->dec_setting.reorder = PJ_TRUE;
+
+ /* Apply encoder mode/bitrate */
+ s->enc_mode = enc_mode;
+ codec_data->info->params.modes.bitrate = s->enc_setting.amr_nb?
+ pjmedia_codec_amrnb_bitrates[s->enc_mode]:
+ pjmedia_codec_amrwb_bitrates[s->enc_mode];
+ ippc->fxns->std.Control(&codec_data->info->params.modes,
+ codec_data->enc);
+
+ PJ_LOG(4,(THIS_FILE, "AMR%s encoding mode: %d (%dbps)",
+ (s->enc_setting.amr_nb?"":"-WB"),
+ s->enc_mode,
+ codec_data->info->params.modes.bitrate));
+
+ /* Return back bitrate info to application */
+ attr->info.avg_bps = codec_data->info->params.modes.bitrate;
+ }
+#endif
+
+#if PJMEDIA_HAS_INTEL_IPP_CODEC_G722_1
+ if (ippc->pt >= PJMEDIA_RTP_PT_G722_1_16 &&
+ ippc->pt <= PJMEDIA_RTP_PT_G7221_RSV2)
+ {
+ codec_data->g7221_pcm_shift = ipp_factory.g7221_pcm_shift;
+ }
+#endif
+
+ return PJ_SUCCESS;
+
+on_error:
+ return PJMEDIA_CODEC_EFAILED;
+}
+
+/*
+ * Close codec.
+ */
+static pj_status_t ipp_codec_close( pjmedia_codec *codec )
+{
+ PJ_UNUSED_ARG(codec);
+
+ return PJ_SUCCESS;
+}
+
+
+/*
+ * Modify codec settings.
+ */
+static pj_status_t ipp_codec_modify(pjmedia_codec *codec,
+ const pjmedia_codec_param *attr )
+{
+ ipp_private_t *codec_data = (ipp_private_t*) codec->codec_data;
+ struct ipp_codec *ippc = &ipp_codec[codec_data->codec_idx];
+
+ codec_data->vad_enabled = (attr->setting.vad != 0);
+ codec_data->plc_enabled = (attr->setting.plc != 0);
+
+ if (ippc->has_native_vad) {
+ USC_Modes modes;
+
+ modes = codec_data->info->params.modes;
+ modes.vad = codec_data->vad_enabled;
+ ippc->fxns->std.Control(&modes, codec_data->enc);
+ }
+
+ return PJ_SUCCESS;
+}
+
+/*
+ * Get frames in the packet.
+ */
+static pj_status_t ipp_codec_parse( pjmedia_codec *codec,
+ void *pkt,
+ pj_size_t pkt_size,
+ const pj_timestamp *ts,
+ unsigned *frame_cnt,
+ pjmedia_frame frames[])
+{
+ ipp_private_t *codec_data = (ipp_private_t*) codec->codec_data;
+ struct ipp_codec *ippc = &ipp_codec[codec_data->codec_idx];
+ unsigned count = 0;
+
+ PJ_ASSERT_RETURN(frame_cnt, PJ_EINVAL);
+
+ if (ippc->parse != NULL) {
+ return ippc->parse(codec_data, pkt, pkt_size, ts, frame_cnt, frames);
+ }
+
+ while (pkt_size >= codec_data->frame_size && count < *frame_cnt) {
+ frames[count].type = PJMEDIA_FRAME_TYPE_AUDIO;
+ frames[count].buf = pkt;
+ frames[count].size = codec_data->frame_size;
+ frames[count].timestamp.u64 = ts->u64 + count*ippc->samples_per_frame;
+
+ pkt = ((char*)pkt) + codec_data->frame_size;
+ pkt_size -= codec_data->frame_size;
+
+ ++count;
+ }
+
+ if (pkt_size && count < *frame_cnt) {
+ frames[count].type = PJMEDIA_FRAME_TYPE_AUDIO;
+ frames[count].buf = pkt;
+ frames[count].size = pkt_size;
+ frames[count].timestamp.u64 = ts->u64 + count*ippc->samples_per_frame;
+ ++count;
+ }
+
+ *frame_cnt = count;
+ return PJ_SUCCESS;
+}
+
+/*
+ * Encode frames.
+ */
+static pj_status_t ipp_codec_encode( pjmedia_codec *codec,
+ const struct pjmedia_frame *input,
+ unsigned output_buf_len,
+ struct pjmedia_frame *output)
+{
+ ipp_private_t *codec_data = (ipp_private_t*) codec->codec_data;
+ struct ipp_codec *ippc = &ipp_codec[codec_data->codec_idx];
+ unsigned samples_per_frame;
+ unsigned nsamples;
+ pj_size_t tx = 0;
+ pj_int16_t *pcm_in = (pj_int16_t*)input->buf;
+ pj_uint8_t *bits_out = (pj_uint8_t*) output->buf;
+ pj_uint8_t pt;
+
+ /* Invoke external VAD if codec has no internal VAD */
+ if (codec_data->vad && codec_data->vad_enabled) {
+ pj_bool_t is_silence;
+ pj_int32_t silence_duration;
+
+ silence_duration = pj_timestamp_diff32(&codec_data->last_tx,
+ &input->timestamp);
+
+ is_silence = pjmedia_silence_det_detect(codec_data->vad,
+ (const pj_int16_t*) input->buf,
+ (input->size >> 1),
+ NULL);
+ if (is_silence &&
+ (PJMEDIA_CODEC_MAX_SILENCE_PERIOD == -1 ||
+ silence_duration < (PJMEDIA_CODEC_MAX_SILENCE_PERIOD *
+ (int)ippc->clock_rate / 1000)))
+ {
+ output->type = PJMEDIA_FRAME_TYPE_NONE;
+ output->buf = NULL;
+ output->size = 0;
+ output->timestamp = input->timestamp;
+ return PJ_SUCCESS;
+ } else {
+ codec_data->last_tx = input->timestamp;
+ }
+ }
+
+ nsamples = input->size >> 1;
+ samples_per_frame = ippc->samples_per_frame;
+ pt = ippc->pt;
+
+ PJ_ASSERT_RETURN(nsamples % samples_per_frame == 0,
+ PJMEDIA_CODEC_EPCMFRMINLEN);
+
+ /* Encode the frames */
+ while (nsamples >= samples_per_frame) {
+ USC_PCMStream in;
+ USC_Bitstream out;
+
+ in.bitrate = codec_data->info->params.modes.bitrate;
+ in.nbytes = samples_per_frame << 1;
+ in.pBuffer = (char*)pcm_in;
+ in.pcmType.bitPerSample = codec_data->info->params.pcmType.bitPerSample;
+ in.pcmType.nChannels = codec_data->info->params.pcmType.nChannels;
+ in.pcmType.sample_frequency = codec_data->info->params.pcmType.sample_frequency;
+
+ out.pBuffer = (char*)bits_out;
+
+#if PJMEDIA_HAS_INTEL_IPP_CODEC_AMR
+ /* For AMR: reserve two octets for AMR frame info */
+ if (pt == PJMEDIA_RTP_PT_AMR || pt == PJMEDIA_RTP_PT_AMRWB) {
+ out.pBuffer += 2;
+ }
+#endif
+
+#if PJMEDIA_HAS_INTEL_IPP_CODEC_G722_1
+ /* For G722.1: adjust the encoder input signal level */
+ if (pt >= PJMEDIA_RTP_PT_G722_1_16 &&
+ pt <= PJMEDIA_RTP_PT_G7221_RSV2 &&
+ codec_data->g7221_pcm_shift)
+ {
+ unsigned i;
+ for (i = 0; i < samples_per_frame; ++i)
+ pcm_in[i] >>= codec_data->g7221_pcm_shift;
+ }
+#endif
+
+ if (USC_NoError != ippc->fxns->Encode(codec_data->enc, &in, &out)) {
+ break;
+ }
+
+#if PJMEDIA_HAS_INTEL_IPP_CODEC_AMR
+ /* For AMR: put info (frametype, degraded, last frame, mode) in the
+ * first two octets for payload packing.
+ */
+ if (pt == PJMEDIA_RTP_PT_AMR || pt == PJMEDIA_RTP_PT_AMRWB) {
+ pj_uint16_t *info = (pj_uint16_t*)bits_out;
+
+ /* Two octets for AMR frame info, 0=LSB:
+ * bit 0-3 : frame type
+ * bit 5 : STI flag
+ * bit 6 : last frame flag
+ * bit 7 : quality flag
+ * bit 8-11 : mode
+ */
+ out.nbytes += 2;
+ if (out.frametype == 0 || out.frametype == 4 ||
+ (pt == PJMEDIA_RTP_PT_AMR && out.frametype == 5) ||
+ (pt == PJMEDIA_RTP_PT_AMRWB && out.frametype == 6))
+ {
+ /* Speech frame type */
+ *info = (char)pjmedia_codec_amr_get_mode(out.bitrate);
+ /* Quality */
+ if (out.frametype == 5 || out.frametype == 6)
+ *info |= 0x80;
+ } else if (out.frametype == 1 || out.frametype == 2 ||
+ (pt == PJMEDIA_RTP_PT_AMR && out.frametype == 6) ||
+ (pt == PJMEDIA_RTP_PT_AMRWB && out.frametype == 7))
+ {
+ /* SID frame type */
+ *info = (pj_uint8_t)(pt == PJMEDIA_RTP_PT_AMRWB? 9 : 8);
+ /* Quality */
+ if (out.frametype == 6 || out.frametype == 7)
+ *info |= 0x80;
+ /* STI */
+ if (out.frametype != 1)
+ *info |= 0x20;
+ } else {
+ /* Untransmited */
+ *info = 15;
+ out.nbytes = 2;
+ }
+
+ /* Mode */
+ *info |= (char)pjmedia_codec_amr_get_mode(out.bitrate) << 8;
+
+ /* Last frame flag */
+ if (nsamples == samples_per_frame)
+ *info |= 0x40;
+ }
+#endif
+
+ pcm_in += samples_per_frame;
+ nsamples -= samples_per_frame;
+ tx += out.nbytes;
+ bits_out += out.nbytes;
+
+#if PJMEDIA_HAS_INTEL_IPP_CODEC_G729
+ if (pt == PJMEDIA_RTP_PT_G729) {
+ if (out.frametype == 1) {
+ /* SID */
+ break;
+ } else if (out.frametype == 0) {
+ /* Untransmitted */
+ tx -= out.nbytes;
+ break;
+ }
+ }
+#endif
+
+ }
+
+ if (ippc->pack != NULL) {
+ ippc->pack(codec_data, output->buf, &tx, output_buf_len);
+ }
+
+ /* Check if we don't need to transmit the frame (DTX) */
+ if (tx == 0) {
+ output->buf = NULL;
+ output->size = 0;
+ output->timestamp.u64 = input->timestamp.u64;
+ output->type = PJMEDIA_FRAME_TYPE_NONE;
+ return PJ_SUCCESS;
+ }
+
+ output->size = tx;
+ output->type = PJMEDIA_FRAME_TYPE_AUDIO;
+ output->timestamp = input->timestamp;
+
+ return PJ_SUCCESS;
+}
+
+/*
+ * Decode frame.
+ */
+static pj_status_t ipp_codec_decode( pjmedia_codec *codec,
+ const struct pjmedia_frame *input,
+ unsigned output_buf_len,
+ struct pjmedia_frame *output)
+{
+ ipp_private_t *codec_data = (ipp_private_t*) codec->codec_data;
+ struct ipp_codec *ippc = &ipp_codec[codec_data->codec_idx];
+ unsigned samples_per_frame;
+ USC_PCMStream out;
+ USC_Bitstream in;
+ pj_uint8_t pt;
+
+ pt = ippc->pt;
+ samples_per_frame = ippc->samples_per_frame;
+
+ PJ_ASSERT_RETURN(output_buf_len >= samples_per_frame << 1,
+ PJMEDIA_CODEC_EPCMTOOSHORT);
+
+ if (input->type == PJMEDIA_FRAME_TYPE_AUDIO) {
+ if (ippc->predecode) {
+ ippc->predecode(codec_data, input, &in);
+ } else {
+ /* Most IPP codecs have frametype==0 for speech frame */
+ in.pBuffer = (char*)input->buf;
+ in.nbytes = input->size;
+ in.frametype = 0;
+ in.bitrate = codec_data->info->params.modes.bitrate;
+ }
+
+ out.pBuffer = output->buf;
+ }
+
+ if (input->type != PJMEDIA_FRAME_TYPE_AUDIO ||
+ USC_NoError != ippc->fxns->Decode(codec_data->dec, &in, &out))
+ {
+ pjmedia_zero_samples((pj_int16_t*)output->buf, samples_per_frame);
+ output->size = samples_per_frame << 1;
+ output->timestamp.u64 = input->timestamp.u64;
+ output->type = PJMEDIA_FRAME_TYPE_AUDIO;
+ return PJ_SUCCESS;
+ }
+
+#if PJMEDIA_HAS_INTEL_IPP_CODEC_G726
+ /* For G.726: amplify decoding result (USC G.726 encoder deamplified it) */
+ if (pt == PJMEDIA_RTP_PT_G726_16 || pt == PJMEDIA_RTP_PT_G726_24 ||
+ pt == PJMEDIA_RTP_PT_G726_32 || pt == PJMEDIA_RTP_PT_G726_40 ||
+ pt == PJMEDIA_RTP_PT_G721)
+ {
+ unsigned i;
+ pj_int16_t *s = (pj_int16_t*)output->buf;
+
+ for (i = 0; i < samples_per_frame; ++i)
+ s[i] <<= 2;
+ }
+#endif
+
+#if PJMEDIA_HAS_INTEL_IPP_CODEC_G722_1
+ /* For G722.1: adjust the decoder output signal level */
+ if (pt >= PJMEDIA_RTP_PT_G722_1_16 &&
+ pt <= PJMEDIA_RTP_PT_G7221_RSV2 &&
+ codec_data->g7221_pcm_shift)
+ {
+ unsigned i;
+ pj_int16_t *s = (pj_int16_t*)output->buf;
+
+ for (i = 0; i < samples_per_frame; ++i)
+ s[i] <<= codec_data->g7221_pcm_shift;
+ }
+#endif
+
+ output->type = PJMEDIA_FRAME_TYPE_AUDIO;
+ output->size = samples_per_frame << 1;
+ output->timestamp.u64 = input->timestamp.u64;
+
+ /* Invoke external PLC if codec has no internal PLC */
+ if (codec_data->plc && codec_data->plc_enabled)
+ pjmedia_plc_save(codec_data->plc, (pj_int16_t*)output->buf);
+
+ return PJ_SUCCESS;
+}
+
+/*
+ * Recover lost frame.
+ */
+static pj_status_t ipp_codec_recover(pjmedia_codec *codec,
+ unsigned output_buf_len,
+ struct pjmedia_frame *output)
+{
+ ipp_private_t *codec_data = (ipp_private_t*) codec->codec_data;
+ struct ipp_codec *ippc = &ipp_codec[codec_data->codec_idx];
+ unsigned samples_per_frame;
+
+ PJ_UNUSED_ARG(output_buf_len);
+
+ samples_per_frame = ippc->samples_per_frame;
+
+ output->type = PJMEDIA_FRAME_TYPE_AUDIO;
+ output->size = samples_per_frame << 1;
+
+ if (codec_data->plc_enabled) {
+ if (codec_data->plc) {
+ pjmedia_plc_generate(codec_data->plc, (pj_int16_t*)output->buf);
+ } else {
+ USC_PCMStream out;
+ out.pBuffer = output->buf;
+ ippc->fxns->Decode(codec_data->dec, NULL, &out);
+ }
+ } else {
+ pjmedia_zero_samples((pj_int16_t*)output->buf, samples_per_frame);
+ }
+
+ return PJ_SUCCESS;
+}
+
+
+#if defined(_MSC_VER) && PJMEDIA_AUTO_LINK_IPP_LIBS
+# pragma comment( lib, "ippcore.lib")
+# pragma comment( lib, "ipps.lib")
+# pragma comment( lib, "ippsc.lib")
+# if defined(IPP_VERSION_MAJOR) && IPP_VERSION_MAJOR<=6
+# pragma comment( lib, "ippsr.lib")
+# endif
+//# pragma comment( lib, "ippcorel.lib")
+//# pragma comment( lib, "ippsemerged.lib")
+//# pragma comment( lib, "ippsmerged.lib")
+//# pragma comment( lib, "ippscemerged.lib")
+//# pragma comment( lib, "ippscmerged.lib")
+//# pragma comment( lib, "ippsremerged.lib")
+//# pragma comment( lib, "ippsrmerged.lib")
+# if defined(IPP_VERSION_MAJOR) && IPP_VERSION_MAJOR>=6
+# pragma comment( lib, "speech.lib")
+# else
+# pragma comment( lib, "usc.lib")
+# endif
+#endif
+
+
+#endif /* PJMEDIA_HAS_INTEL_IPP */
+
diff --git a/jni/pjproject-android/.svn/pristine/af/afbf0cb8a6baf28c3f4913ea7f0ad2a5e311c1d8.svn-base b/jni/pjproject-android/.svn/pristine/af/afbf0cb8a6baf28c3f4913ea7f0ad2a5e311c1d8.svn-base
new file mode 100644
index 0000000..76ff13b
--- /dev/null
+++ b/jni/pjproject-android/.svn/pristine/af/afbf0cb8a6baf28c3f4913ea7f0ad2a5e311c1d8.svn-base
@@ -0,0 +1,27 @@
+# $Id$
+import inc_sip as sip
+import inc_sdp as sdp
+
+# The unknown media uses static payload type
+sdp = \
+"""
+v=0
+o=- 0 0 IN IP4 127.0.0.1
+s=-
+c=IN IP4 127.0.0.1
+t=0 0
+m=xapplicationx 4000 RTP/AVP 54
+m=audio 5000 RTP/AVP 0
+"""
+
+pjsua_args = "--null-audio --auto-answer 200"
+extra_headers = ""
+include = ["Content-Type: application/sdp", # response must include SDP
+ "m=xapplicationx 0 RTP/AVP[\\s\\S]+m=audio [1-9]+[0-9]* RTP/AVP"
+ ]
+exclude = []
+
+sendto_cfg = sip.SendtoCfg("Mixed audio and unknown", pjsua_args, sdp, 200,
+ extra_headers=extra_headers,
+ resp_inc=include, resp_exc=exclude)
+
diff --git a/jni/pjproject-android/.svn/pristine/af/afbf2e8a877089a26b8f6b506cce7beed37fe34d.svn-base b/jni/pjproject-android/.svn/pristine/af/afbf2e8a877089a26b8f6b506cce7beed37fe34d.svn-base
new file mode 100644
index 0000000..7c1536b
--- /dev/null
+++ b/jni/pjproject-android/.svn/pristine/af/afbf2e8a877089a26b8f6b506cce7beed37fe34d.svn-base
@@ -0,0 +1,27 @@
+# $Id$
+import inc_sip as sip
+import inc_sdp as sdp
+
+sdp = \
+"""
+v=0
+o=- 0 0 IN IP4 127.0.0.1
+s=pjmedia
+c=AF IP4 127.0.0.1
+t=0 0
+m=audio 4000 RTP/AVP 0 101
+a=rtpmap:0 PCMU/8000
+a=sendrecv
+a=rtpmap:101 telephone-event/8000
+a=fmtp:101 0-15
+"""
+
+pjsua_args = "--null-audio --auto-answer 200"
+extra_headers = ""
+include = [ "Warning: " ] # better have Warning header
+exclude = []
+sendto_cfg = sip.SendtoCfg("Bad SDP network type", pjsua_args, sdp, 400,
+ extra_headers=extra_headers,
+ resp_inc=include, resp_exc=exclude)
+
+
diff --git a/jni/pjproject-android/.svn/pristine/af/afc0ffef03803116f7586d87b9d8740b67c90baf.svn-base b/jni/pjproject-android/.svn/pristine/af/afc0ffef03803116f7586d87b9d8740b67c90baf.svn-base
new file mode 100644
index 0000000..230dda6
--- /dev/null
+++ b/jni/pjproject-android/.svn/pristine/af/afc0ffef03803116f7586d87b9d8740b67c90baf.svn-base
@@ -0,0 +1,523 @@
+/*
+ * crypto_kernel.c
+ *
+ * header for the cryptographic kernel
+ *
+ * David A. McGrew
+ * Cisco Systems, Inc.
+ */
+/*
+ *
+ * Copyright(c) 2001-2006 Cisco Systems, Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following
+ * disclaimer in the documentation and/or other materials provided
+ * with the distribution.
+ *
+ * Neither the name of the Cisco Systems, Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+
+#include "alloc.h"
+
+#include "crypto_kernel.h"
+
+/* the debug module for the crypto_kernel */
+
+debug_module_t mod_crypto_kernel = {
+ 0, /* debugging is off by default */
+ "crypto kernel" /* printable name for module */
+};
+
+/*
+ * other debug modules that can be included in the kernel
+ */
+
+extern debug_module_t mod_auth;
+extern debug_module_t mod_cipher;
+extern debug_module_t mod_stat;
+extern debug_module_t mod_alloc;
+
+/*
+ * cipher types that can be included in the kernel
+ */
+
+extern cipher_type_t null_cipher;
+extern cipher_type_t aes_icm;
+extern cipher_type_t aes_cbc;
+
+
+/*
+ * auth func types that can be included in the kernel
+ */
+
+extern auth_type_t null_auth;
+extern auth_type_t hmac;
+
+/* crypto_kernel is a global variable, the only one of its datatype */
+
+crypto_kernel_t
+crypto_kernel = {
+ crypto_kernel_state_insecure, /* start off in insecure state */
+ NULL, /* no cipher types yet */
+ NULL, /* no auth types yet */
+ NULL /* no debug modules yet */
+};
+
+#define MAX_RNG_TRIALS 25
+
+err_status_t
+crypto_kernel_init() {
+ err_status_t status;
+
+ /* check the security state */
+ if (crypto_kernel.state == crypto_kernel_state_secure) {
+
+ /*
+ * we're already in the secure state, but we've been asked to
+ * re-initialize, so we just re-run the self-tests and then return
+ */
+ return crypto_kernel_status();
+ }
+
+ /* initialize error reporting system */
+ status = err_reporting_init("crypto");
+ if (status)
+ return status;
+
+ /* load debug modules */
+ status = crypto_kernel_load_debug_module(&mod_crypto_kernel);
+ if (status)
+ return status;
+ status = crypto_kernel_load_debug_module(&mod_auth);
+ if (status)
+ return status;
+ status = crypto_kernel_load_debug_module(&mod_cipher);
+ if (status)
+ return status;
+ status = crypto_kernel_load_debug_module(&mod_stat);
+ if (status)
+ return status;
+ status = crypto_kernel_load_debug_module(&mod_alloc);
+ if (status)
+ return status;
+
+ /* initialize random number generator */
+ status = rand_source_init();
+ if (status)
+ return status;
+
+ /* run FIPS-140 statistical tests on rand_source */
+ status = stat_test_rand_source_with_repetition(rand_source_get_octet_string, MAX_RNG_TRIALS);
+ if (status)
+ return status;
+
+ /* initialize pseudorandom number generator */
+ status = ctr_prng_init(rand_source_get_octet_string);
+ if (status)
+ return status;
+
+ /* run FIPS-140 statistical tests on ctr_prng */
+ status = stat_test_rand_source_with_repetition(ctr_prng_get_octet_string, MAX_RNG_TRIALS);
+ if (status)
+ return status;
+
+ /* load cipher types */
+ status = crypto_kernel_load_cipher_type(&null_cipher, NULL_CIPHER);
+ if (status)
+ return status;
+ status = crypto_kernel_load_cipher_type(&aes_icm, AES_128_ICM);
+ if (status)
+ return status;
+ status = crypto_kernel_load_cipher_type(&aes_cbc, AES_128_CBC);
+ if (status)
+ return status;
+
+ /* load auth func types */
+ status = crypto_kernel_load_auth_type(&null_auth, NULL_AUTH);
+ if (status)
+ return status;
+ status = crypto_kernel_load_auth_type(&hmac, HMAC_SHA1);
+ if (status)
+ return status;
+
+ /* change state to secure */
+ crypto_kernel.state = crypto_kernel_state_secure;
+
+ return err_status_ok;
+}
+
+err_status_t
+crypto_kernel_status() {
+ err_status_t status;
+ kernel_cipher_type_t *ctype = crypto_kernel.cipher_type_list;
+ kernel_auth_type_t *atype = crypto_kernel.auth_type_list;
+ kernel_debug_module_t *dm = crypto_kernel.debug_module_list;
+
+ /* run FIPS-140 statistical tests on rand_source */
+ printf("testing rand_source...");
+ status = stat_test_rand_source_with_repetition(rand_source_get_octet_string, MAX_RNG_TRIALS);
+ if (status) {
+ printf("failed\n");
+ crypto_kernel.state = crypto_kernel_state_insecure;
+ return status;
+ }
+ printf("passed\n");
+
+ /* for each cipher type, describe and test */
+ while(ctype != NULL) {
+ printf("cipher: %s\n", ctype->cipher_type->description);
+ printf(" instance count: %d\n", ctype->cipher_type->ref_count);
+ printf(" self-test: ");
+ status = cipher_type_self_test(ctype->cipher_type);
+ if (status) {
+ printf("failed with error code %d\n", status);
+ exit(status);
+ }
+ printf("passed\n");
+ ctype = ctype->next;
+ }
+
+ /* for each auth type, describe and test */
+ while(atype != NULL) {
+ printf("auth func: %s\n", atype->auth_type->description);
+ printf(" instance count: %d\n", atype->auth_type->ref_count);
+ printf(" self-test: ");
+ status = auth_type_self_test(atype->auth_type);
+ if (status) {
+ printf("failed with error code %d\n", status);
+ exit(status);
+ }
+ printf("passed\n");
+ atype = atype->next;
+ }
+
+ /* describe each debug module */
+ printf("debug modules loaded:\n");
+ while (dm != NULL) {
+ printf(" %s ", dm->mod->name);
+ if (dm->mod->on)
+ printf("(on)\n");
+ else
+ printf("(off)\n");
+ dm = dm->next;
+ }
+
+ return err_status_ok;
+}
+
+err_status_t
+crypto_kernel_list_debug_modules() {
+ kernel_debug_module_t *dm = crypto_kernel.debug_module_list;
+
+ /* describe each debug module */
+ printf("debug modules loaded:\n");
+ while (dm != NULL) {
+ printf(" %s ", dm->mod->name);
+ if (dm->mod->on)
+ printf("(on)\n");
+ else
+ printf("(off)\n");
+ dm = dm->next;
+ }
+
+ return err_status_ok;
+}
+
+err_status_t
+crypto_kernel_shutdown() {
+ err_status_t status;
+
+ /*
+ * free dynamic memory used in crypto_kernel at present
+ */
+
+ /* walk down cipher type list, freeing memory */
+ while (crypto_kernel.cipher_type_list != NULL) {
+ kernel_cipher_type_t *ctype = crypto_kernel.cipher_type_list;
+ crypto_kernel.cipher_type_list = ctype->next;
+ debug_print(mod_crypto_kernel,
+ "freeing memory for cipher %s",
+ ctype->cipher_type->description);
+ crypto_free(ctype);
+ }
+
+ /* walk down authetication module list, freeing memory */
+ while (crypto_kernel.auth_type_list != NULL) {
+ kernel_auth_type_t *atype = crypto_kernel.auth_type_list;
+ crypto_kernel.auth_type_list = atype->next;
+ debug_print(mod_crypto_kernel,
+ "freeing memory for authentication %s",
+ atype->auth_type->description);
+ crypto_free(atype);
+ }
+
+ /* walk down debug module list, freeing memory */
+ while (crypto_kernel.debug_module_list != NULL) {
+ kernel_debug_module_t *kdm = crypto_kernel.debug_module_list;
+ crypto_kernel.debug_module_list = kdm->next;
+ debug_print(mod_crypto_kernel,
+ "freeing memory for debug module %s",
+ kdm->mod->name);
+ crypto_free(kdm);
+ }
+
+ /* de-initialize random number generator */ status = rand_source_deinit();
+ if (status)
+ return status;
+
+ /* return to insecure state */
+ crypto_kernel.state = crypto_kernel_state_insecure;
+
+ return err_status_ok;
+}
+
+err_status_t
+crypto_kernel_load_cipher_type(cipher_type_t *new_ct, cipher_type_id_t id) {
+ kernel_cipher_type_t *ctype, *new_ctype;
+ err_status_t status;
+
+ /* defensive coding */
+ if (new_ct == NULL)
+ return err_status_bad_param;
+
+ /* check cipher type by running self-test */
+ status = cipher_type_self_test(new_ct);
+ if (status) {
+ return status;
+ }
+
+ /* walk down list, checking if this type is in the list already */
+ ctype = crypto_kernel.cipher_type_list;
+ while (ctype != NULL) {
+ if ((new_ct == ctype->cipher_type) || (id == ctype->id))
+ return err_status_bad_param;
+ ctype = ctype->next;
+ }
+
+ /* put new_ct at the head of the list */
+ /* allocate memory */
+ new_ctype = (kernel_cipher_type_t *) crypto_alloc(sizeof(kernel_cipher_type_t));
+ if (new_ctype == NULL)
+ return err_status_alloc_fail;
+
+ /* set fields */
+ new_ctype->cipher_type = new_ct;
+ new_ctype->id = id;
+ new_ctype->next = crypto_kernel.cipher_type_list;
+
+ /* set head of list to new cipher type */
+ crypto_kernel.cipher_type_list = new_ctype;
+
+ /* load debug module, if there is one present */
+ if (new_ct->debug != NULL)
+ crypto_kernel_load_debug_module(new_ct->debug);
+ /* we could check for errors here */
+
+ return err_status_ok;
+}
+
+err_status_t
+crypto_kernel_load_auth_type(auth_type_t *new_at, auth_type_id_t id) {
+ kernel_auth_type_t *atype, *new_atype;
+ err_status_t status;
+
+ /* defensive coding */
+ if (new_at == NULL)
+ return err_status_bad_param;
+
+ /* check auth type by running self-test */
+ status = auth_type_self_test(new_at);
+ if (status) {
+ return status;
+ }
+
+ /* walk down list, checking if this type is in the list already */
+ atype = crypto_kernel.auth_type_list;
+ while (atype != NULL) {
+ if ((new_at == atype->auth_type) || (id == atype->id))
+ return err_status_bad_param;
+ atype = atype->next;
+ }
+
+ /* put new_at at the head of the list */
+ /* allocate memory */
+ new_atype = (kernel_auth_type_t *)crypto_alloc(sizeof(kernel_auth_type_t));
+ if (new_atype == NULL)
+ return err_status_alloc_fail;
+
+ /* set fields */
+ new_atype->auth_type = new_at;
+ new_atype->id = id;
+ new_atype->next = crypto_kernel.auth_type_list;
+
+ /* set head of list to new auth type */
+ crypto_kernel.auth_type_list = new_atype;
+
+ /* load debug module, if there is one present */
+ if (new_at->debug != NULL)
+ crypto_kernel_load_debug_module(new_at->debug);
+ /* we could check for errors here */
+
+ return err_status_ok;
+
+}
+
+
+cipher_type_t *
+crypto_kernel_get_cipher_type(cipher_type_id_t id) {
+ kernel_cipher_type_t *ctype;
+
+ /* walk down list, looking for id */
+ ctype = crypto_kernel.cipher_type_list;
+ while (ctype != NULL) {
+ if (id == ctype->id)
+ return ctype->cipher_type;
+ ctype = ctype->next;
+ }
+
+ /* haven't found the right one, indicate failure by returning NULL */
+ return NULL;
+}
+
+
+err_status_t
+crypto_kernel_alloc_cipher(cipher_type_id_t id,
+ cipher_pointer_t *cp,
+ int key_len) {
+ cipher_type_t *ct;
+
+ /*
+ * if the crypto_kernel is not yet initialized, we refuse to allocate
+ * any ciphers - this is a bit extra-paranoid
+ */
+ if (crypto_kernel.state != crypto_kernel_state_secure)
+ return err_status_init_fail;
+
+ ct = crypto_kernel_get_cipher_type(id);
+ if (!ct)
+ return err_status_fail;
+
+ return ((ct)->alloc(cp, key_len));
+}
+
+
+
+auth_type_t *
+crypto_kernel_get_auth_type(auth_type_id_t id) {
+ kernel_auth_type_t *atype;
+
+ /* walk down list, looking for id */
+ atype = crypto_kernel.auth_type_list;
+ while (atype != NULL) {
+ if (id == atype->id)
+ return atype->auth_type;
+ atype = atype->next;
+ }
+
+ /* haven't found the right one, indicate failure by returning NULL */
+ return NULL;
+}
+
+err_status_t
+crypto_kernel_alloc_auth(auth_type_id_t id,
+ auth_pointer_t *ap,
+ int key_len,
+ int tag_len) {
+ auth_type_t *at;
+
+ /*
+ * if the crypto_kernel is not yet initialized, we refuse to allocate
+ * any auth functions - this is a bit extra-paranoid
+ */
+ if (crypto_kernel.state != crypto_kernel_state_secure)
+ return err_status_init_fail;
+
+ at = crypto_kernel_get_auth_type(id);
+ if (!at)
+ return err_status_fail;
+
+ return ((at)->alloc(ap, key_len, tag_len));
+}
+
+err_status_t
+crypto_kernel_load_debug_module(debug_module_t *new_dm) {
+ kernel_debug_module_t *kdm, *new;
+
+ /* defensive coding */
+ if (new_dm == NULL)
+ return err_status_bad_param;
+
+ /* walk down list, checking if this type is in the list already */
+ kdm = crypto_kernel.debug_module_list;
+ while (kdm != NULL) {
+ if (strncmp(new_dm->name, kdm->mod->name, 64) == 0)
+ return err_status_bad_param;
+ kdm = kdm->next;
+ }
+
+ /* put new_dm at the head of the list */
+ /* allocate memory */
+ new = (kernel_debug_module_t *)crypto_alloc(sizeof(kernel_debug_module_t));
+ if (new == NULL)
+ return err_status_alloc_fail;
+
+ /* set fields */
+ new->mod = new_dm;
+ new->next = crypto_kernel.debug_module_list;
+
+ /* set head of list to new cipher type */
+ crypto_kernel.debug_module_list = new;
+
+ return err_status_ok;
+}
+
+err_status_t
+crypto_kernel_set_debug_module(char *name, int on) {
+ kernel_debug_module_t *kdm;
+
+ /* walk down list, checking if this type is in the list already */
+ kdm = crypto_kernel.debug_module_list;
+ while (kdm != NULL) {
+ if (strncmp(name, kdm->mod->name, 64) == 0) {
+ kdm->mod->on = on;
+ return err_status_ok;
+ }
+ kdm = kdm->next;
+ }
+
+ return err_status_fail;
+}
+
+err_status_t
+crypto_get_random(unsigned char *buffer, unsigned int length) {
+ if (crypto_kernel.state == crypto_kernel_state_secure)
+ return ctr_prng_get_octet_string(buffer, length);
+ else
+ return err_status_fail;
+}
diff --git a/jni/pjproject-android/.svn/pristine/af/affa286fa46d825cdbb852d8cdc3ece2b5ace218.svn-base b/jni/pjproject-android/.svn/pristine/af/affa286fa46d825cdbb852d8cdc3ece2b5ace218.svn-base
new file mode 100644
index 0000000..63dd811
--- /dev/null
+++ b/jni/pjproject-android/.svn/pristine/af/affa286fa46d825cdbb852d8cdc3ece2b5ace218.svn-base
@@ -0,0 +1,27 @@
+# $Id$
+import inc_sip as sip
+import inc_sdp as sdp
+
+sdp = \
+"""
+v=0
+o=- 0 0 IN IP4 127.0.0.1
+s=pjmedia
+c=IN IP4 127.0.0.1
+t=0 0
+m=audio 4000 RTP/XAVP 0 101
+a=rtpmap:0 PCMU/8000
+a=sendrecv
+a=rtpmap:101 telephone-event/8000
+a=fmtp:101 0-15
+"""
+
+pjsua_args = "--null-audio --auto-answer 200"
+extra_headers = ""
+include = []
+exclude = []
+sendto_cfg = sip.SendtoCfg("Unsupported transport type", pjsua_args, sdp, 488,
+ extra_headers=extra_headers,
+ resp_inc=include, resp_exc=exclude)
+
+