[asterisk-commits] oej: branch oej/roibos-cng-support-1.8 r411923 - in /team/oej/roibos-cng-supp...
SVN commits to the Asterisk project
asterisk-commits at lists.digium.com
Tue Apr 8 09:14:14 CDT 2014
Author: oej
Date: Tue Apr 8 09:14:08 2014
New Revision: 411923
URL: http://svnview.digium.com/svn/asterisk?view=rev&rev=411923
Log:
Updating before the big merge!
Stay tuned folks, this is exciting stuff. Soon time for champagne and popcorn. At least one of them.
Added:
team/oej/roibos-cng-support-1.8/patches/
team/oej/roibos-cng-support-1.8/patches/roibos-cng-support-1.8.diff (with props)
team/oej/roibos-cng-support-1.8/patches/silence-detection-games-1.8.diff (with props)
Modified:
team/oej/roibos-cng-support-1.8/README.roibos-cng.txt
Modified: team/oej/roibos-cng-support-1.8/README.roibos-cng.txt
URL: http://svnview.digium.com/svn/asterisk/team/oej/roibos-cng-support-1.8/README.roibos-cng.txt?view=diff&rev=411923&r1=411922&r2=411923
==============================================================================
--- team/oej/roibos-cng-support-1.8/README.roibos-cng.txt (original)
+++ team/oej/roibos-cng-support-1.8/README.roibos-cng.txt Tue Apr 8 09:14:08 2014
@@ -3,14 +3,14 @@
Started: 2012-09-18
-Updated: 2013-12-05
+Updated: 2014-04-07
-Comfort Noise support in Asterisk 1.8
-=====================================
+Silence Suppression and Comfort Noise support in Asterisk 1.8
+=============================================================
Comfort Noise in SIP/RTP is
- negotiated in the SDP as a codec
@@ -67,15 +67,11 @@
=================
The current silence detector in Asterisk only supports signed linear audio.
This means that for a g.729 call we have to transcode to signed linear, listen
-for audio and then transcode back. Not a good efficient solution. I will implement
-this as a showcase in the first step.
+for audio and in some cases, but not all, transcode back.
Later we have to
- Add silence detection to the codec modules so they can signal silence
in an incoming stream to the core
-- Add silence detection as a framehook procedure. This way we only have to
- convert the media once and have a "fork" listen for silence. We keep
- the media in the existing format over the bridge.
Debugging
=========
@@ -91,12 +87,6 @@
-----------------------------
- Check how this affects RTP bridge and queue bridge
- Add CN support in SDP for outbound calls
- - As step 2, add silence detection to calls
- - Measure noise level
- - Start sending CNG
- - Listen for talk detection
- - Stop sending CNG, send media
- - Ask Matt J and File about frame hooks and how this solution should look
Done:
- Support in core bridge
@@ -105,6 +95,7 @@
This includes a noise generator
- Add SIP negotiation in SDP - done
- Support CN codec on incoming INVITEs - done
+ - Silence detection and suppression added for SIP calls
References
----------
Added: team/oej/roibos-cng-support-1.8/patches/roibos-cng-support-1.8.diff
URL: http://svnview.digium.com/svn/asterisk/team/oej/roibos-cng-support-1.8/patches/roibos-cng-support-1.8.diff?view=auto&rev=411923
==============================================================================
--- team/oej/roibos-cng-support-1.8/patches/roibos-cng-support-1.8.diff (added)
+++ team/oej/roibos-cng-support-1.8/patches/roibos-cng-support-1.8.diff Tue Apr 8 09:14:08 2014
@@ -1,0 +1,1155 @@
+Index: channels/chan_sip.c
+===================================================================
+--- channels/chan_sip.c (.../branches/1.8) (revision 411922)
++++ channels/chan_sip.c (.../team/oej/roibos-cng-support-1.8) (revision 411922)
+@@ -4768,6 +4768,10 @@
+ * implied else case here
+ */
+ break;
++ case AST_OPTION_CNG_SUPPORT:
++ /* Check if the current dialog has agreed on Comfort Noise support */
++ res = (p->noncodeccapability & AST_RTP_CN);
++ break;
+ default:
+ break;
+ }
+@@ -5762,6 +5766,10 @@
+ dialog->noncodeccapability |= AST_RTP_DTMF;
+ else
+ dialog->noncodeccapability &= ~AST_RTP_DTMF;
++
++ if (ast_test_flag(&dialog->flags[1], SIP_PAGE2_ALLOW_CN)) {
++ dialog->noncodeccapability |= AST_RTP_CN;
++ }
+ dialog->directmediaha = ast_duplicate_ha_list(peer->directmediaha);
+ if (peer->call_limit)
+ ast_set_flag(&dialog->flags[0], SIP_CALL_LIMIT);
+@@ -9733,7 +9741,7 @@
+ they are acceptable */
+ p->jointcapability = newjointcapability; /* Our joint codec profile for this call */
+ p->peercapability = newpeercapability; /* The other side's capability in latest offer */
+- p->jointnoncodeccapability = newnoncodeccapability; /* DTMF capabilities */
++ p->jointnoncodeccapability = newnoncodeccapability; /* CN and DTMF capabilities */
+
+ /* respond with single most preferred joint codec, limiting the other side's choice */
+ if (ast_test_flag(&p->flags[1], SIP_PAGE2_PREFERRED_CODEC)) {
+@@ -11521,6 +11529,7 @@
+ fmt = ast_codec_pref_getsize(pref, codec);
+ } else /* I don't see how you couldn't have p->rtp, but good to check for and error out if not there like earlier code */
+ return;
++
+ ast_str_append(m_buf, 0, " %d", rtp_code);
+ ast_str_append(a_buf, 0, "a=rtpmap:%d %s/%d\r\n", rtp_code,
+ ast_rtp_lookup_mime_subtype2(1, codec,
+@@ -11640,7 +11649,7 @@
+ }
+ }
+
+-/*! \brief Add RFC 2833 DTMF offer to SDP */
++/*! \brief Add CN and RFC 2833 DTMF offer to SDP */
+ static void add_noncodec_to_sdp(const struct sip_pvt *p, int format,
+ struct ast_str **m_buf, struct ast_str **a_buf,
+ int debug)
+@@ -12006,10 +12015,12 @@
+ add_tcodec_to_sdp(p, x, &m_text, &a_text, debug, &min_text_packet_size);
+ }
+
+- /* Now add DTMF RFC2833 telephony-event as a codec */
++ /* Now add Comfort Noise and DTMF RFC2833 telephony-event as a codec */
+ for (x = 1LL; x <= AST_RTP_MAX; x <<= 1) {
+- if (!(p->jointnoncodeccapability & x))
++ if (!(p->jointnoncodeccapability & x)) {
++ ast_debug(1, "NOT Adding non-codec 0x%lx (%s) to SDP\n", (int64_t)x, ast_rtp_lookup_mime_subtype2(0, x, 0));
+ continue;
++ }
+
+ add_noncodec_to_sdp(p, x, &m_audio, &a_audio, debug);
+ }
+@@ -16806,6 +16817,9 @@
+ p->noncodeccapability |= AST_RTP_DTMF;
+ else
+ p->noncodeccapability &= ~AST_RTP_DTMF;
++ if (ast_test_flag(&p->flags[1], SIP_PAGE2_ALLOW_CN)) {
++ p->noncodeccapability |= AST_RTP_CN;
++ }
+ p->jointnoncodeccapability = p->noncodeccapability;
+ p->rtptimeout = peer->rtptimeout;
+ p->rtpholdtimeout = peer->rtpholdtimeout;
+@@ -18268,6 +18282,7 @@
+ ast_cli(fd, " User=Phone : %s\n", AST_CLI_YESNO(ast_test_flag(&peer->flags[0], SIP_USEREQPHONE)));
+ ast_cli(fd, " Video Support: %s\n", AST_CLI_YESNO(ast_test_flag(&peer->flags[1], SIP_PAGE2_VIDEOSUPPORT) || ast_test_flag(&peer->flags[1], SIP_PAGE2_VIDEOSUPPORT_ALWAYS)));
+ ast_cli(fd, " Text Support : %s\n", AST_CLI_YESNO(ast_test_flag(&peer->flags[1], SIP_PAGE2_TEXTSUPPORT)));
++ ast_cli(fd, " Comfort Noise: %s\n", AST_CLI_YESNO(ast_test_flag(&peer->flags[1], SIP_PAGE2_ALLOW_CN)));
+ ast_cli(fd, " Ign SDP ver : %s\n", AST_CLI_YESNO(ast_test_flag(&peer->flags[1], SIP_PAGE2_IGNORESDPVERSION)));
+ ast_cli(fd, " Trust RPID : %s\n", AST_CLI_YESNO(ast_test_flag(&peer->flags[0], SIP_TRUSTRPID)));
+ ast_cli(fd, " Send RPID : %s\n", AST_CLI_YESNO(ast_test_flag(&peer->flags[0], SIP_SENDRPID)));
+@@ -18380,6 +18395,7 @@
+ astman_append(s, "SIP-T.38Support: %s\r\n", (ast_test_flag(&peer->flags[1], SIP_PAGE2_T38SUPPORT)?"Y":"N"));
+ astman_append(s, "SIP-T.38EC: %s\r\n", faxec2str(ast_test_flag(&peer->flags[1], SIP_PAGE2_T38SUPPORT)));
+ astman_append(s, "SIP-T.38MaxDtgrm: %d\r\n", peer->t38_maxdatagram);
++ astman_append(s, "SIP-ComfortNoise: %s\r\n", (ast_test_flag(&peer->flags[1], SIP_PAGE2_ALLOW_CN)?"Y":"N"));
+ astman_append(s, "SIP-Sess-Timers: %s\r\n", stmode2str(peer->stimer.st_mode_oper));
+ astman_append(s, "SIP-Sess-Refresh: %s\r\n", strefresherparam2str(peer->stimer.st_ref));
+ astman_append(s, "SIP-Sess-Expires: %d\r\n", peer->stimer.st_max_se);
+@@ -18833,6 +18849,7 @@
+ "Disabled");
+ ast_cli(a->fd, " Videosupport: %s\n", AST_CLI_YESNO(ast_test_flag(&global_flags[1], SIP_PAGE2_VIDEOSUPPORT)));
+ ast_cli(a->fd, " Textsupport: %s\n", AST_CLI_YESNO(ast_test_flag(&global_flags[1], SIP_PAGE2_TEXTSUPPORT)));
++ ast_cli(a->fd, " Comfort Noise: %s\n", AST_CLI_YESNO(ast_test_flag(&global_flags[1], SIP_PAGE2_ALLOW_CN)));
+ ast_cli(a->fd, " Ignore SDP sess. ver.: %s\n", AST_CLI_YESNO(ast_test_flag(&global_flags[1], SIP_PAGE2_IGNORESDPVERSION)));
+ ast_cli(a->fd, " AutoCreate Peer: %s\n", AST_CLI_YESNO(sip_cfg.autocreatepeer));
+ ast_cli(a->fd, " Match Auth Username: %s\n", AST_CLI_YESNO(global_match_auth_username));
+@@ -19356,6 +19373,7 @@
+ ast_cli(a->fd, " Format: %s\n", ast_getformatname_multiple(formatbuf, sizeof(formatbuf), cur->owner ? cur->owner->nativeformats : 0) );
+ ast_cli(a->fd, " T.38 support %s\n", AST_CLI_YESNO(cur->udptl != NULL));
+ ast_cli(a->fd, " Video support %s\n", AST_CLI_YESNO(cur->vrtp != NULL));
++ ast_cli(a->fd, " Comfort Noise support %s\n", AST_CLI_YESNO(ast_test_flag(&cur->flags[1],SIP_PAGE2_ALLOW_CN)));
+ ast_cli(a->fd, " MaxCallBR: %d kbps\n", cur->maxcallbitrate);
+ ast_cli(a->fd, " Theoretical Address: %s\n", ast_sockaddr_stringify(&cur->sa));
+ ast_cli(a->fd, " Received Address: %s\n", ast_sockaddr_stringify(&cur->recv));
+@@ -27790,6 +27808,9 @@
+ } else if (!strcasecmp(v->name, "buggymwi")) {
+ ast_set_flag(&mask[1], SIP_PAGE2_BUGGY_MWI);
+ ast_set2_flag(&flags[1], ast_true(v->value), SIP_PAGE2_BUGGY_MWI);
++ } else if (!strcasecmp(v->name, "comfort-noise")) {
++ ast_set_flag(&mask[1], SIP_PAGE2_ALLOW_CN);
++ ast_set2_flag(&flags[1], ast_true(v->value), SIP_PAGE2_ALLOW_CN);
+ } else
+ res = 0;
+
+Index: channels/sip/include/sip.h
+===================================================================
+--- channels/sip/include/sip.h (.../branches/1.8) (revision 411922)
++++ channels/sip/include/sip.h (.../team/oej/roibos-cng-support-1.8) (revision 411922)
+@@ -347,6 +347,7 @@
+ #define SIP_PAGE2_VIDEOSUPPORT_ALWAYS (1 << 27) /*!< DP: Always set up video, even if endpoints don't support it */
+ #define SIP_PAGE2_HAVEPEERCONTEXT (1 << 28) /*< Are we associated with a configured peer context? */
+ #define SIP_PAGE2_USE_SRTP (1 << 29) /*!< DP: Whether we should offer (only) SRTP */
++#define SIP_PAGE2_ALLOW_CN (1 << 30) /*!< DP: If we allow Comfort Noise generation */
+
+ #define SIP_PAGE2_FLAGS_TO_COPY \
+ (SIP_PAGE2_ALLOWSUBSCRIBE | SIP_PAGE2_ALLOWOVERLAP | SIP_PAGE2_IGNORESDPVERSION | \
+@@ -354,7 +355,8 @@
+ SIP_PAGE2_BUGGY_MWI | SIP_PAGE2_TEXTSUPPORT | SIP_PAGE2_FAX_DETECT | \
+ SIP_PAGE2_UDPTL_DESTINATION | SIP_PAGE2_VIDEOSUPPORT_ALWAYS | SIP_PAGE2_PREFERRED_CODEC | \
+ SIP_PAGE2_RPID_IMMEDIATE | SIP_PAGE2_RPID_UPDATE | SIP_PAGE2_SYMMETRICRTP |\
+- SIP_PAGE2_Q850_REASON | SIP_PAGE2_HAVEPEERCONTEXT | SIP_PAGE2_USE_SRTP)
++ SIP_PAGE2_Q850_REASON | SIP_PAGE2_HAVEPEERCONTEXT | SIP_PAGE2_USE_SRTP |\
++ SIP_PAGE2_ALLOW_CN )
+
+
+ #define SIP_PAGE3_SNOM_AOC (1 << 0) /*!< DPG: Allow snom aoc messages */
+Index: funcs/func_frame_trace.c
+===================================================================
+--- funcs/func_frame_trace.c (.../branches/1.8) (revision 411922)
++++ funcs/func_frame_trace.c (.../team/oej/roibos-cng-support-1.8) (revision 411922)
+@@ -326,6 +326,9 @@
+ case AST_CONTROL_UPDATE_RTP_PEER:
+ ast_verbose("SubClass: UPDATE_RTP_PEER\n");
+ break;
++ case AST_CONTROL_CNG_END:
++ ast_verbose("SubClass: CNG_END");
++ break;
+ }
+
+ if (frame->subclass.integer == -1) {
+Index: include/asterisk/channel.h
+===================================================================
+--- include/asterisk/channel.h (.../branches/1.8) (revision 411922)
++++ include/asterisk/channel.h (.../team/oej/roibos-cng-support-1.8) (revision 411922)
+@@ -2370,6 +2370,42 @@
+ void ast_channel_stop_silence_generator(struct ast_channel *chan, struct ast_silence_generator *state);
+
+ /*!
++ * \brief An opaque 'object' structure use by noise generators on channels.
++ */
++struct ast_noise_generator;
++
++/*!
++ * \brief Starts a noise generator on the given channel.
++ * \param chan The channel to generate silence on
++ * \param level The noise level in negative (dBOV)
++ * \return An ast_noise_generator pointer, or NULL if an error occurs
++ *
++ * \details
++ * This function will cause SLINEAR noise to be generated on the supplied
++ * channel until it is disabled; if the channel cannot be put into SLINEAR
++ * mode then the function will fail.
++ *
++ * \note
++ * The pointer returned by this function must be preserved and passed to
++ * ast_channel_stop_noise_generator when you wish to stop the noise
++ * generation.
++ */
++struct ast_noise_generator *ast_channel_start_noise_generator(struct ast_channel *chan, const float level);
++
++/*!
++ * \brief Stops a previously-started noise generator on the given channel.
++ * \param chan The channel to operate on
++ * \param state The ast_noise_generator pointer return by a previous call to
++ * ast_channel_start_noise_generator.
++ * \return nothing
++ *
++ * \details
++ * This function will stop the operating noise generator and return the channel
++ * to its previous write format.
++ */
++void ast_channel_stop_noise_generator(struct ast_channel *chan, struct ast_noise_generator *state);
++
++/*!
+ * \brief Check if the channel can run in internal timing mode.
+ * \param chan The channel to check
+ * \return boolean
+Index: include/asterisk/frame.h
+===================================================================
+--- include/asterisk/frame.h (.../branches/1.8) (revision 411922)
++++ include/asterisk/frame.h (.../team/oej/roibos-cng-support-1.8) (revision 411922)
+@@ -301,6 +301,8 @@
+ #define AST_FORMAT_SPEEX16 (1ULL << 33)
+ /*! Raw mu-law data (G.711) */
+ #define AST_FORMAT_TESTLAW (1ULL << 47)
++/*! Comfort noise. Not a frame type per se, but needs to be added as a codec */
++#define AST_FORMAT_CN (1ULL << 48)
+ /*! Reserved bit - do not use */
+ #define AST_FORMAT_RESERVED (1ULL << 63)
+
+@@ -362,6 +364,7 @@
+ *
+ * WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING
+ */
++ AST_CONTROL_CNG_END = 32, /*!< Disable CNG playout in bridge */
+ };
+
+ enum ast_frame_read_action {
+@@ -524,6 +527,10 @@
+ #define AST_OPTION_SECURE_SIGNALING 18
+ #define AST_OPTION_SECURE_MEDIA 19
+
++/*! Support of CNG transmission,
++ if not enabled a noise generator will kick in */
++#define AST_OPTION_CNG_SUPPORT 20
++
+ struct oprmode {
+ struct ast_channel *peer;
+ int mode;
+Index: main/channel.c
+===================================================================
+--- main/channel.c (.../branches/1.8) (revision 411922)
++++ main/channel.c (.../team/oej/roibos-cng-support-1.8) (revision 411922)
+@@ -4425,6 +4425,7 @@
+ case AST_CONTROL_AOC:
+ case AST_CONTROL_END_OF_Q:
+ case AST_CONTROL_UPDATE_RTP_PEER:
++ case AST_CONTROL_CNG_END:
+ break;
+
+ case AST_CONTROL_INCOMPLETE:
+@@ -4594,6 +4595,7 @@
+ case AST_CONTROL_SRCUPDATE:
+ case AST_CONTROL_SRCCHANGE:
+ case AST_CONTROL_RADIO_KEY:
++ case AST_CONTROL_CNG_END:
+ case AST_CONTROL_RADIO_UNKEY:
+ case AST_CONTROL_OPTION:
+ case AST_CONTROL_WINK:
+@@ -7330,6 +7332,12 @@
+ ast_indicate_data(other, f->subclass.integer, f->data.ptr, f->datalen);
+ }
+ break;
++ case AST_CONTROL_CNG_END:
++ /* If we are playing out CNG noise on the bridged channel, stop it now.
++ otherwise, ignore this frame. */
++ ast_debug(1, "*** Bridge got CNG END frame \n");
++ ast_channel_stop_noise_generator(other, NULL);
++ break;
+ case AST_CONTROL_HOLD:
+ case AST_CONTROL_UNHOLD:
+ case AST_CONTROL_VIDUPDATE:
+@@ -7351,6 +7359,21 @@
+ if (bridge_exit)
+ break;
+ }
++ if (f->frametype == AST_FRAME_CNG) {
++ /* We got a CNG frame
++ Check if the bridged channel has active CNG
++ */
++ int cngsupport = 0;
++ int len = sizeof(cngsupport);
++ ast_channel_queryoption(other, AST_OPTION_CNG_SUPPORT, &cngsupport, &len, 0);
++ if (cngsupport) {
++ ast_debug(1, "*** Bridge got CNG frame. Forwarding it \n");
++ ast_write(other, f);
++ } else {
++ ast_debug(1, "*** Bridge got CNG frame. Playing out noise. (CNG not supported by other channel) Level: - %d\n", f->subclass.integer );
++ ast_channel_start_noise_generator(other, (float) -f->subclass.integer);
++ }
++ }
+ if ((f->frametype == AST_FRAME_VOICE) ||
+ (f->frametype == AST_FRAME_DTMF_BEGIN) ||
+ (f->frametype == AST_FRAME_DTMF) ||
+@@ -8358,6 +8381,305 @@
+ }
+
+
++#ifdef HAVE_EXP10L
++#define FUNC_EXP10 exp10l
++#elif (defined(HAVE_EXPL) && defined(HAVE_LOGL))
++#define FUNC_EXP10(x) expl((x) * logl(10.0))
++#elif (defined(HAVE_EXP) && defined(HAVE_LOG))
++#define FUNC_EXP10(x) (long double)exp((x) * log(10.0))
++#endif
++
++/*! \brief Noise generator default frame */
++static struct ast_frame noiseframedefaults = {
++ .frametype = AST_FRAME_VOICE,
++ .subclass.codec = AST_FORMAT_SLINEAR,
++ .offset = AST_FRIENDLY_OFFSET,
++ .mallocd = 0,
++ .data.ptr = NULL,
++ .datalen = 0,
++ .samples = 0,
++ .src = "noisegenerator",
++ .delivery.tv_sec = 0,
++ .delivery.tv_usec = 0
++};
++
++struct ast_noise_generator {
++ int old_write_format;
++ float level;
++};
++
++
++#ifndef LOW_MEMORY
++/*
++ * We pregenerate 64k of white noise samples that will be used instead of
++ * generating the samples continously and wasting CPU cycles. The buffer
++ * below stores these pregenerated samples.
++ */
++static float pregeneratedsamples[65536L];
++#endif
++
++/*
++ * We need a nice, not too expensive, gaussian random number generator.
++ * It generates two random numbers at a time, which is great.
++ * From http://www.taygeta.com/random/gaussian.html
++ */
++static void box_muller_rng(float stddev, float *rn1, float *rn2) {
++ const float twicerandmaxinv = 2.0 / RAND_MAX;
++ float x1, x2, w;
++
++ do {
++ x1 = random() * twicerandmaxinv - 1.0;
++ x2 = random() * twicerandmaxinv - 1.0;
++ w = x1 * x1 + x2 * x2;
++ } while (w >= 1.0);
++
++ w = stddev * sqrt((-2.0 * logf(w)) / w);
++ *rn1 = x1 * w;
++ *rn2 = x2 * w;
++}
++
++static void *noise_generator_alloc(struct ast_channel *chan, void *params) {
++ struct ast_noise_generator *state = params;
++ float level = state->level; /* level is noise level in dBov */
++ float *pnoisestddev; /* pointer to calculated noise standard dev */
++ const float maxsigma = 32767.0 / 3.0;
++
++ /*
++ * When level is zero (full power, by definition) standard deviation
++ * (sigma) is calculated so that 3 * sigma equals max sample value
++ * before overload. For signed linear, which is what we use, this
++ * value is 32767. The max value of sigma will therefore be
++ * 32767.0 / 3.0. This guarantees that roughly 99.7% of the samples
++ * generated will be between -32767 and +32767. The rest, 0.3%,
++ * will be clipped to comform to the channel limits, i.e., +/-32767.
++ *
++ */
++ pnoisestddev = malloc(sizeof (float));
++ if(pnoisestddev) {
++ *pnoisestddev = maxsigma * FUNC_EXP10(level / 20.0);
++ }
++
++ return (void *) pnoisestddev;
++}
++
++static void noise_generator_release(struct ast_channel *chan, void *data) {
++ free((float *)data);
++}
++
++/*! \brief Generator of White Noise at a certain level.
++
++Current level is defined in the generator data structure as noiselevel (float) in dBov's
++
++
++ Level is a non-positive number. For example, WhiteNoise(0.0) generates
++ white noise at full power, while WhiteNoise(-3.0) generates white noise at
++ half full power. Every -3dBov's reduces white noise power in half. Full
++ power in this case is defined as noise that overloads the channel roughly 0.3%
++ of the time. Note that values below -69 dBov's start to give out silence
++ frequently, resulting in intermittent noise, i.e, alternating periods of
++ silence and noise.
++
++This code orginally contributed to Asterisk by cmantunes in issue ASTERISK-5263
++as part of res_noise.c
++*/
++static int noise_generate(struct ast_channel *chan, void *data, int len, int samples) {
++#ifdef LOW_MEMORY
++ float randomnumber[2];
++ float sampleamplitude;
++ int j;
++#else
++ uint16_t start;
++#endif
++ float noisestddev = *(float *)data;
++ struct ast_frame f;
++ int16_t *buf, *pbuf;
++ int i;
++
++#ifdef LOW_MEMORY
++ /* We need samples to be an even number */
++ if (samples & 0x1) {
++ ast_log(LOG_WARNING, "Samples (%d) needs to be an even number\n", samples);
++ return -1;
++ }
++#endif
++
++ /* Allocate enough space for samples.
++ * Remember that slin uses signed dword samples */
++ len = samples * sizeof (int16_t);
++ if(!(buf = ast_alloca(len))) {
++ ast_log(LOG_WARNING, "Unable to allocate buffer to generate %d samples\n", samples);
++ return -1;
++ }
++
++ /* Setup frame */
++ memcpy(&f, &noiseframedefaults, sizeof (f));
++ f.data.ptr = buf;
++ f.datalen = len;
++ f.samples = samples;
++
++ /* Let's put together our frame "data" */
++ pbuf = buf;
++
++#ifdef LOW_MEMORY
++ /* We need to generate samples every time we are called */
++ for (i = 0; i < samples; i += 2) {
++ box_muller_rng(noisestddev, &randomnumber[0], &randomnumber[1]);
++ for (j = 0; j < 2; j++) {
++ sampleamplitude = randomnumber[j];
++ if (sampleamplitude > 32767.0)
++ sampleamplitude = 32767.0;
++ else if (sampleamplitude < -32767.0)
++ sampleamplitude = -32767.0;
++ *(pbuf++) = (int16_t)sampleamplitude;
++ }
++ }
++#else
++ /*
++ * We are going to use pregenerated samples. But we start at
++ * different points on the pregenerated samples buffer every time
++ * to create a little bit more randomness
++ *
++ */
++ start = (uint16_t) (65536.0 * random() / RAND_MAX);
++ for (i = 0; i < samples; i++) {
++ *(pbuf++) = (int16_t)(noisestddev * pregeneratedsamples[start++]);
++ }
++#endif
++
++ /* Send it out */
++ if (ast_write(chan, &f) < 0) {
++ ast_log(LOG_WARNING, "Failed to write frame to channel '%s'\n", chan->name);
++ return -1;
++ }
++ return 0;
++}
++
++static struct ast_generator noise_generator =
++{
++ alloc: noise_generator_alloc,
++ release: noise_generator_release,
++ generate: noise_generate,
++} ;
++
++static void *cng_channel_params_copy(void *data)
++{
++ const struct ast_noise_generator *src = data;
++ struct ast_noise_generator *dest = ast_calloc(1, sizeof(struct ast_noise_generator));
++ if (!dest) {
++ return NULL;
++ }
++ dest->level = src->level;
++ dest->old_write_format = src->old_write_format;
++ return dest;
++}
++
++static void cng_channel_params_destroy(void *data)
++{
++ struct ast_noise_generator *ng = data;
++ ast_free(ng);
++}
++
++static const struct ast_datastore_info cng_channel_datastore_info = {
++ .type = "Comfort Noise Generator",
++ .duplicate = cng_channel_params_copy,
++ .destroy = cng_channel_params_destroy,
++};
++
++static int ast_channel_cng_params_init(struct ast_channel *chan, int level, int old_write_format)
++{
++ struct ast_noise_generator *new_cng;
++ struct ast_datastore *cng_datastore;
++
++ /* If we already have a datastore, reuse it */
++ if ((cng_datastore = ast_channel_datastore_find(chan, &cng_channel_datastore_info, NULL))) {
++ new_cng = cng_datastore->data;
++ } else {
++ /* Create new datastore */
++ new_cng = ast_calloc(1, sizeof(struct ast_noise_generator));
++ if (!new_cng) {
++ return -1;
++ }
++
++ if (!(cng_datastore = ast_datastore_alloc(&cng_channel_datastore_info, NULL))) {
++ cng_channel_params_destroy(new_cng);
++ return -1;
++ }
++ cng_datastore->data = new_cng;
++ ast_channel_datastore_add(chan, cng_datastore);
++ }
++ new_cng->level = level;
++ new_cng->old_write_format = old_write_format;
++
++ return 0;
++}
++
++struct ast_noise_generator *ast_channel_start_noise_generator(struct ast_channel *chan, const float level)
++{
++ struct ast_noise_generator *state;
++ int i;
++
++#ifndef LOW_MEMORY
++ /* This should only be done once per asterisk instance */
++ if (pregeneratedsamples[0] == 0.0) {
++ for (i = 0; i < sizeof (pregeneratedsamples) / sizeof (pregeneratedsamples[0]); i += 2) {
++ box_muller_rng(1.0, &pregeneratedsamples[i], &pregeneratedsamples[i + 1]);
++ }
++ }
++#endif
++
++ if (level > 0) {
++ ast_log(LOG_ERROR, "Noise generator: Invalid argument - non-positive floating-point argument for noise level in dBov's required \n");
++ return NULL;
++ }
++
++ if (!(state = ast_calloc(1, sizeof(*state)))) {
++ return NULL;
++ }
++
++ state->old_write_format = chan->writeformat;
++ state->level = level;
++
++ if (ast_set_write_format(chan, AST_FORMAT_SLINEAR) < 0) {
++ ast_log(LOG_ERROR, "Could not set write format to SLINEAR\n");
++ ast_free(state);
++ return NULL;
++ }
++
++ /* Store noise generation data in a channel datastore */
++ ast_channel_cng_params_init(chan, level, chan->writeformat);
++
++ ast_activate_generator(chan, &noise_generator, state);
++
++ ast_debug(1, "Started noise generator on '%s'\n", chan->name);
++
++ return state;
++}
++
++void ast_channel_stop_noise_generator(struct ast_channel *chan, struct ast_noise_generator *state)
++{
++ struct ast_datastore *cng_datastore;
++ struct ast_noise_generator *cngstate = state;
++
++ if (!cngstate) {
++ if (!(cng_datastore = ast_channel_datastore_find(chan, &cng_channel_datastore_info, NULL))) {
++ return;
++ }
++ cngstate = cng_datastore->data;
++ }
++
++ /* We will leave the allocated channel datastore in memory for reuse */
++ ast_deactivate_generator(chan);
++
++ ast_debug(1, "Stopped silence generator on '%s'\n", chan->name);
++
++ if (ast_set_write_format(chan, cngstate->old_write_format) < 0)
++ ast_log(LOG_ERROR, "Could not return write format to its original state\n");
++
++ ast_free(state);
++}
++
++
++
+ /*! \ brief Convert channel reloadreason (ENUM) to text string for manager event */
+ const char *channelreloadreason2txt(enum channelreloadreason reason)
+ {
+Index: main/features.c
+===================================================================
+--- main/features.c (.../branches/1.8) (revision 411922)
++++ main/features.c (.../team/oej/roibos-cng-support-1.8) (revision 411922)
+@@ -4232,6 +4232,12 @@
+ }
+ ast_indicate_data(other, f->subclass.integer, f->data.ptr, f->datalen);
+ break;
++ case AST_CONTROL_CNG_END:
++ /* If we are playing out CNG noise on the bridged channel, stop it now.
++ otherwise, ignore this frame. */
++ ast_debug(2, "*** Bridge got CNG END frame \n");
++ ast_channel_stop_noise_generator(other, NULL);
++ break;
+ case AST_CONTROL_AOC:
+ case AST_CONTROL_HOLD:
+ case AST_CONTROL_UNHOLD:
+@@ -4351,6 +4357,21 @@
+ ast_debug(1, "Set feature timer to %ld ms\n", config->feature_timer);
+ }
+ }
++ } else if (f->frametype == AST_FRAME_CNG) {
++ /* We got a CNG frame
++ Check if the bridged channel has active CNG
++ */
++ int cngsupport = 0;
++ int len = sizeof(cngsupport);
++ ast_channel_queryoption(other, AST_OPTION_CNG_SUPPORT, &cngsupport, &len, 0);
++ if (cngsupport) {
++ ast_debug(1, "*** Bridge got CNG frame. Forwarding it \n");
++ ast_write(other, f);
++ } else {
++ ast_debug(1, "*** Bridge got CNG frame. Playing out noise. (CNG not supported by other channel) \n");
++ ast_moh_start(other, NULL, NULL);
++ }
++
+ }
+ if (f)
+ ast_frfree(f);
+Index: main/frame.c
+===================================================================
+--- main/frame.c (.../branches/1.8) (revision 411922)
++++ main/frame.c (.../team/oej/roibos-cng-support-1.8) (revision 411922)
+@@ -126,6 +126,7 @@
+ { AST_FORMAT_SIREN14, "siren14", 32000, "ITU G.722.1 Annex C, (Siren14, licensed from Polycom)", 120, 20, 80, 20, 20 }, /*!< Binary commercial distribution */
+ { AST_FORMAT_TESTLAW, "testlaw", 8000, "G.711 test-law", 80, 10, 150, 10, 20 }, /*!< codec_ulaw.c */
+ { AST_FORMAT_G719, "g719", 48000, "ITU G.719", 160, 20, 80, 20, 20 },
++ { AST_FORMAT_CN, "cn", 8000, "Comfort Noise"},
+ };
+
+ struct ast_frame ast_null_frame = { AST_FRAME_NULL, };
+Index: main/rtp_engine.c
+===================================================================
+--- main/rtp_engine.c (.../branches/1.8) (revision 411922)
++++ main/rtp_engine.c (.../team/oej/roibos-cng-support-1.8) (revision 411922)
+@@ -162,7 +162,7 @@
+ [16] = {1, AST_FORMAT_ADPCM}, /* 11.025 kHz */
+ [17] = {1, AST_FORMAT_ADPCM}, /* 22.050 kHz */
+ [18] = {1, AST_FORMAT_G729A},
+- [19] = {0, AST_RTP_CN}, /* Also used for CN */
++ [19] = {1, AST_FORMAT_CN}, /* Also used for CN */
+ [26] = {1, AST_FORMAT_JPEG},
+ [31] = {1, AST_FORMAT_H261},
+ [34] = {1, AST_FORMAT_H263},
+Index: configs/sip.conf.sample
+===================================================================
+--- configs/sip.conf.sample (.../branches/1.8) (revision 411922)
++++ configs/sip.conf.sample (.../team/oej/roibos-cng-support-1.8) (revision 411922)
+@@ -300,6 +300,12 @@
+ ;allow=ulaw ; Allow codecs in order of preference
+ ;allow=ilbc ; see https://wiki.asterisk.org/wiki/display/AST/RTP+Packetization
+ ; for framing options
++;comfort-noise=yes ; Enable Comfort Noise generation on RTP streams
++; ; Available per device too
++; ; Generating comfort noise is a burden to your CPU
++; ; This should not be enabled on low-end devices.
++; ; You should not enable this unless you have internal
++; ; timing support enabled in asterisk.conf
+ ;autoframing=yes ; Set packetization based on the remote endpoint's (ptime)
+ ; preferences. Defaults to no.
+ ;
+Index: res/res_noise.c
+===================================================================
+--- res/res_noise.c (.../branches/1.8) (revision 0)
++++ res/res_noise.c (.../team/oej/roibos-cng-support-1.8) (revision 411922)
+@@ -0,0 +1,164 @@
++/*
++ * Asterisk -- An open source telephony toolkit.
++ *
++ * Copyright (C) 1999 - 2005, Digium, Inc.
++ *
++ * Contributed by Carlos Antunes <cmantunes at gmail.com>
++ *
++ * See http://www.asterisk.org for more information about
++ * the Asterisk project. Please do not directly contact
++ * any of the maintainers of this project for assistance;
++ * the project provides a web site, mailing lists and IRC
++ * channels for your use.
++ *
++ * This program is free software, distributed under the terms of
++ * the GNU General Public License Version 2. See the LICENSE file
++ * at the top of the source tree.
++ */
++
++/*! \file
++ *
++ * \brief Just generate white noise
++ *
++ */
++
++/*** MODULEINFO
++ <support_level>random</support_level>
++ ***/
++
++
++#include "asterisk.h"
++
++ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
++
++#include "asterisk/lock.h"
++#include "asterisk/file.h"
++#include "asterisk/logger.h"
++#include "asterisk/channel.h"
++#include "asterisk/pbx.h"
++#include "asterisk/module.h"
++#include "asterisk/app.h"
++
++#include <math.h>
++
++static char *app = "WhiteNoise";
++
++
++/*** DOCUMENTATION
++ <application name="WhiteNoise" language="en_US">
++ <synopsis>
++ Generates white noise
++ </synopsis>
++ <syntax>
++ <parameter name="args">
++ <argument name="timeout" required="true" />
++ <argument name="level" required="false" />
++ </parameter>
++ </syntax>
++ <description>
++ <para>Generates white noise at 'level' dBov's for 'timeout' seconds or indefinitely if timeout
++ is absent or is zero.</para>
++ <para>Level is a non-positive number. For example, WhiteNoise(0.0) generates
++ white noise at full power, while WhiteNoise(-3.0) generates white noise at
++ half full power. Every -3dBov's reduces white noise power in half. Full
++ power in this case is defined as noise that overloads the channel roughly 0.3%
++ of the time. Note that values below -69 dBov's start to give out silence
++ frequently, resulting in intermittent noise, i.e, alternating periods of
++ silence and noise.</para>
++
++ </description>
++ </application>
++***/
++
++static int noise_exec(struct ast_channel *chan, const char *data) {
++
++ struct ast_module_user *u;
++ char *excessdata;
++ float level = 0;
++ float timeout = 0;
++ char *s;
++ int res;
++ struct ast_noise_generator *gendata;
++
++ AST_DECLARE_APP_ARGS(args,
++ AST_APP_ARG(timeout);
++ AST_APP_ARG(level);
++ );
++
++ /* Verify we potentially have arguments and get local copy */
++ if (!data) {
++ ast_log(LOG_WARNING, "WhiteNoise usage following: WhiteNoise([timeout[, level]])\n");
++ return -1;
++ }
++
++ /* Separate arguments */
++ s = ast_strdupa(data);
++ AST_STANDARD_APP_ARGS(args, s);
++
++ if (args.timeout) {
++ /* Extract second argument, if available, and validate
++ * timeout is non-negative. Zero timeout means no timeout */
++ args.timeout = ast_trim_blanks(args.timeout);
++ timeout = strtof(args.timeout, &excessdata);
++ if ((excessdata && *excessdata) || timeout < 0) {
++ ast_log(LOG_WARNING, "Invalid argument 'timeout': WhiteNoise requires non-negative floating-point argument for timeout in seconds\n");
++ return -1;
++ }
++
++ /* Convert timeout to milliseconds
++ * and ensure minimum of 20ms */
++ timeout = roundf(timeout * 1000.0);
++ if (timeout > 0 && timeout < 20) {
++ timeout = 20;
++ }
++ }
++
++ if (args.level) {
++ /* Extract first argument and ensure we have
++ * a valid noise level argument value */
++ args.level = ast_trim_blanks(args.level);
++ level = strtof(args.level, &excessdata);
++ if ((excessdata && *excessdata) || level > 0) {
++ ast_log(LOG_ERROR, "Invalid argument 'level': WhiteNoise requires non-positive floating-point argument for noise level in dBov's\n");
++ return -1;
++ }
++ }
++
++ ast_debug(1, "Setting up white noise generator with level %.1fdBov's and %.0fms %stimeout\n", level, timeout, timeout == 0 ? "(no) " : "");
++
++ u = ast_module_user_add(chan);
++ if (chan->_state != AST_STATE_UP) {
++ ast_answer(chan);
++ }
++ gendata = ast_channel_start_noise_generator(chan, level);
++ if (data == NULL) {
++ ast_log(LOG_WARNING, "Failed to activate white noise generator on '%s'\n",chan->name);
++ res = -1;
++ } else {
++ /* Just do the noise... */
++ res = -1;
++ if (timeout > 0) {
++ res = ast_safe_sleep(chan, timeout);
++ } else {
++ while(!ast_safe_sleep(chan, 10000));
++ }
++ ast_channel_stop_noise_generator(chan, gendata);
++ }
++ ast_module_user_remove(u);
++ return res;
++}
++
++static int unload_module(void) {
++ ast_module_user_hangup_all();
++
++ return ast_unregister_application(app);
++}
++
++static int load_module(void) {
++ return ast_register_application_xml(app, noise_exec);
++}
++
++AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_GLOBAL_SYMBOLS, "White Noise Generator Application",
++ .load = load_module,
++ .unload = unload_module,
++ );
+
+Property changes on: res/res_noise.c
+___________________________________________________________________
+Added: svn:eol-style
+## -0,0 +1 ##
++native
+\ No newline at end of property
+Added: svn:mime-type
+## -0,0 +1 ##
++text/plain
+\ No newline at end of property
+Added: svn:keywords
+## -0,0 +1 ##
++Author Date Id Revision
+\ No newline at end of property
+Index: res/res_rtp_asterisk.c
+===================================================================
+--- res/res_rtp_asterisk.c (.../branches/1.8) (revision 411922)
++++ res/res_rtp_asterisk.c (.../team/oej/roibos-cng-support-1.8) (revision 411922)
+@@ -114,6 +114,7 @@
+ #define FLAG_NAT_INACTIVE_NOWARN (1 << 1)
+ #define FLAG_NEED_MARKER_BIT (1 << 3)
+ #define FLAG_DTMF_COMPENSATE (1 << 4)
++#define FLAG_CN_ACTIVE (1 << 5)
+
+ /*! \brief RTP session description */
+ struct ast_rtp {
+@@ -1753,17 +1754,8 @@
+ /* Convert comfort noise into audio with various codecs. Unfortunately this doesn't
+ totally help us out becuase we don't have an engine to keep it going and we are not
+ guaranteed to have it every 20ms or anything */
+- if (rtpdebug)
++ if (rtpdebug) {
+ ast_debug(0, "- RTP 3389 Comfort noise event: Level %" PRId64 " (len = %d)\n", rtp->lastrxformat, len);
+-
+- if (ast_test_flag(rtp, FLAG_3389_WARNING)) {
+- struct ast_sockaddr remote_address = { {0,} };
+-
+- ast_rtp_instance_get_remote_address(instance, &remote_address);
+-
+- ast_log(LOG_NOTICE, "Comfort noise support incomplete in Asterisk (RFC 3389). Please turn off on client if possible. Client address: %s\n",
+- ast_sockaddr_stringify(&remote_address));
+- ast_set_flag(rtp, FLAG_3389_WARNING);
+ }
+
+ /* Must have at least one byte */
+@@ -1780,10 +1772,22 @@
+ rtp->f.datalen = 0;
+ }
+ rtp->f.frametype = AST_FRAME_CNG;
++ /* The noise level is expressed in -dBov with values 0 to 127, representing 0 to -127 dBov
++ It's in bits 1-7 in the payload. Bit 0 is always 0.
++ */
+ rtp->f.subclass.integer = data[0] & 0x7f;
+ rtp->f.samples = 0;
+ rtp->f.delivery.tv_usec = rtp->f.delivery.tv_sec = 0;
+
++ if(!ast_test_flag(rtp, FLAG_CN_ACTIVE)) {
++ ast_set_flag(rtp, FLAG_CN_ACTIVE);
++ ast_debug(2, "ACTIVATING Comfort Noise on channel Level - %d\n", rtp->f.subclass.integer);
++ /* Start the generator on the other end. */
++
++ } else {
++ /* Check if the level is the same. If not, reactivate. */
++ }
++
+ return &rtp->f;
+ }
+
+@@ -2368,6 +2372,15 @@
+ /* If the payload is not actually an Asterisk one but a special one pass it off to the respective handler */
+ if (!payload.asterisk_format) {
+ struct ast_frame *f = NULL;
++ if (payload.code != AST_RTP_CN && ast_test_flag(rtp, FLAG_CN_ACTIVE)) {
++ /* Insert a control frame to indicate that we need to shut down Comfort Noise generators, if active */
++ struct ast_frame cngoff = { AST_FRAME_CONTROL, { AST_CONTROL_CNG_END, } };
++ ast_debug(2, "DEACTIVATING Comfort Noise \n");
++ ast_clear_flag(rtp, FLAG_CN_ACTIVE);
++ f = ast_frdup(&cngoff);
++ AST_LIST_INSERT_TAIL(&frames, f, frame_list);
++ f = NULL;
++ }
+ if (payload.code == AST_RTP_DTMF) {
+ /* process_dtmf_rfc2833 may need to return multiple frames. We do this
+ * by passing the pointer to the frame list to it so that the method
+@@ -2395,6 +2408,15 @@
+ }
+ return &ast_null_frame;
+ }
++ if (ast_test_flag(rtp, FLAG_CN_ACTIVE)) {
++ struct ast_frame *f = NULL;
++ struct ast_frame cngoff = { AST_FRAME_CONTROL, { AST_CONTROL_CNG_END, } };
++ ast_debug(2, "DEACTIVATING Comfort Noise \n");
++ ast_clear_flag(rtp, FLAG_CN_ACTIVE);
++ f = ast_frdup(&cngoff);
++ AST_LIST_INSERT_TAIL(&frames, f, frame_list);
++ f = NULL;
++ }
+
+ rtp->lastrxformat = rtp->f.subclass.codec = payload.code;
+ rtp->f.frametype = (rtp->f.subclass.codec & AST_FORMAT_AUDIO_MASK) ? AST_FRAME_VOICE : (rtp->f.subclass.codec & AST_FORMAT_VIDEO_MASK) ? AST_FRAME_VIDEO : AST_FRAME_TEXT;
+Index: README.roibos-cng.txt
+===================================================================
+--- README.roibos-cng.txt (.../branches/1.8) (revision 0)
++++ README.roibos-cng.txt (.../team/oej/roibos-cng-support-1.8) (revision 411922)
+@@ -0,0 +1,174 @@
++Edvina AB
++Olle E. Johansson
++
++
++Started: 2012-09-18
++Updated: 2013-12-05
++
++
++
++
++
++Comfort Noise support in Asterisk 1.8
++=====================================
++
++Comfort Noise in SIP/RTP is
++- negotiated in the SDP as a codec
++- starts activated by a silence in the media stream
++- the sender stops sending media, sends a single CNG RTP packet that indicates
++ a noise level
++- the receiver activated a Comfort Noise Generator in the call until media
++ reappears from the sender
++
++A requirement for using this is that it is included as a codec with payload
++13 (or dynamic) in the SDP
++
++Asterisk Architecture
++=====================
[... 998 lines stripped ...]
More information about the asterisk-commits
mailing list