News from Industry

These days “free” software seems to be a scary prospect to the general public. The association between open-source software and malicious “click here for free stuff” ads is strong and the fear of unknown “hackers” runs rampant. The old adage that “nothing good in life comes for free” has ingrained the idea that free is synonymous with scams. Why would anyone in their right mind give away a great product for free? This thought process is why most of the general public limits themselves to costly, proprietary services. The tech industry is huge and understanding it all is impossible, but buying trust isn’t the answer to guaranteed safety. There is plenty of fantastic open-source software available and it shouldn’t only be accessible to experienced, tech savvy individuals. And, as we move toward a more tech based culture, the up and coming generations can have an especially difficult time trying to explain this misconstrued conclusion to their older peers. Jim Salter from Opensource.com addressed this issue with an open letter to all parents with kids that want to use open-source software. He goes on to say free open-source software (FOSS) “is not “stolen” software. Free software licenses like the GPL and the BSD and Apache licenses allow users the ability to freely use, and developers the ability to freely develop, the software placed under those licenses. Another important thing to understand about FOSS is that it is not merely “free” in the sense of “free in every box of cereal.” Making a new copy of a piece of software literally costs nothing at all—this has made it possible for community efforts to produce world-class products in a way material goods never could be.” Helping the general public to understand the definition and motivation behind open-source will bring it out of the shadows of the industry and help it become mainstream. You can read his letter here: https://opensource.com/life/15/12/dear-parents-let-your-kids-use-open-source-software

A few days back my old friend Chris Koehnke, better known as “Kranky” asked me how hard it would be to implement a wild idea he had to monitor what percentage of the time you spent talking instead of listening on a call when using WebRTC. When I said “one day” that made him wonder whether he could offshore it to save money. Well… good luck!

A week later Kranky showed me some code. Wait, he is writing code? It was not bad – it was using the WebAudio API so going in the right direction. It was enough to prod me to finish writing the app for him.

The audio stream volume sample application from Google calculates the root mean square (RMS) of the audio signal which is extracted from the input stream using a script processor every 200ms. There is a lot of tuning options here of course.

Instead of starting from scratch, I decided to use hark, a small open source module for this task that my coworker Philip Roberts had built in mid-2013 when the WebAudio API became first available.

Instead of the RMS, hark uses the Fast Fourier Transformation to obtain a frequency domain representation of the input signal. Then, hark picks the maximum amplitude as an indication for the volume of the signal. Let’s try this (full code here):

var hark = require('../hark.js') var getUserMedia = require('getusermedia') getUserMedia(function(err, stream) { if (err) throw err var options = {}; var speechEvents = hark(stream, options); speechEvents.on('volume_change', function(volume) { console.log('current volume', volume); }); });

On top of this, hark uses a simple speech detection algorithm that considers speech to be started when the maximum amplitude stays above a threshold for a number of milliseconds. Much less complicated than typical voice activity detection algorithms but pretty effective. And easy to use as well, just subscribe to two additional events:

speechEvents.on('speaking', function() { console.log('speaking'); }); speechEvents.on('stopped_speaking', function() { console.log('stopped_speaking'); });

Tuning the threshold for accurate speech detection is pretty tricky. So I needed visualization (and just requiring hark only took five minutes so I had plenty of time). Using the awesome Highcharts graph library I quickly added plot bands to the graph I was generating:

With the visualization I could easily see that the speech detection events happened a bit later than I expected since hark requires a certain history over the threshold for the trigger to work (say: 400ms).  To adjust for this in the graph had to substract this speech starting to trigger time from my x-axis (now()– 400ms for example).

That graph is still visibile on the more techie variant of the website so if you think the results are not accurate… it might help you figure out what is going on. I am happy with the current behavior.

The percentage of speech then calculated as the sum of the intervals that speech is detected divided by the duration of the call. As a display, a gauge chart is used with three different colors:

• up to 65% speech time: green
• up to 79%: yellow
• more than 80%: red

Adding remote audio to this would be awesome. However, while the WebAudio API is supported for local media streams in Chrome, Firefox and Edge, it is only supported for remote streams in Firefox. Hooking this up with the getStats API (in Chrome) to get the audio level would certainly be possible, but would require calling getStats at a very high frequency to get proper averages.

Check out the app in action at talklessnow and let us know what you think.

{“author”: “Philipp Hancke“}

Want to keep up on our latest posts? Please click here to subscribe to our mailing list if you have not already. We only email post updates. You can also follow us on twitter at @webrtcHacks for blog updates and news of technical WebRTC topics or our individual feeds @chadwallacehart, @victorpascual and @tsahil.

The post Shut up! Monitoring audio volume in getUserMedia appeared first on webrtcHacks.

Your private 911 system.

[If you are new around here, then you should know I’ve been writing about WebRTC lately. You can skim through the WebRTC post series or just read what WebRTC is all about.]

I have seen a lot of applications lately that target public safety. Some offer you a “ghost” partner to “walk” with you home, while others focus on the reporting aspects.

SaferMobility targets the authorities as the owners of the system (college campuses, municipalities, business zones, etc) and provides a mobile application to the users. It is reimagining how a 911 service would look like if it was being specified today.

Matthew Mah, CTO of SaferMobility, was kind enough to answer my questions on what role WebRTC plays in their service.

 

What is SaferMobility all about?

SaferMobility focuses on using the capabilities of modern smartphones for enhancing safety. The public safety system in the United States is built around wired telephones, and it is more difficult for authorities to respond to mobile phones because they are harder to locate than fixed telephones. The modern smartphone has audio, video, location, and text capability that just are not being used efficiently yet.

 

There are many other safety related apps out there. What differentiates you from the rest of the pack?

Our systems focus on real-time interaction with authorities. Authorities receive enhanced calls with audio, video, location, and text information in real-time without it having to filter through friends or storage systems.

 

You told me you launched your service using Flash. Why did you migrate to WebRTC?

WebRTC is a huge improvement over Flash in terms of security, support, and capability. Adobe is not really interested in supporting Flash for mobile devices, so capabilities like acoustic echo suppression are not available. This makes a huge difference in communication quality.

 

What signaling have you decided to integrate on top of WebRTC?

We use a proprietary message system built on websockets.

 

Backend. What technologies and architecture are you using there?

Our Java application server runs Tomcat with a PostgreSQL database. It handles the signaling and issues commands to a media server for recording capabilities. We currently run on Dialogic’s Extended Media Server (XMS).

Mobile. You decided to port WebRTC to iOS and Android on your own. How was the experience?

Porting was difficult because of compatibility issues between our WebRTC media server with web, iOS, and Android clients. We would get two clients to work with the server, then upgrade the server and have two different clients work.

For stability on the web side, the nwjs project has been very helpful for producing an application that works even while the web browser updates are racing ahead and frequently breaking things.

 

Where do you see WebRTC going in 2-5 years?

WebRTC will replace stagnant technologies like Flash. The ability to communicate through the browser will also lower the barrier for application development.

 

If you had one piece of advice for those thinking of adopting WebRTC, what would it be?

Be prepared for things to change quickly because WebRTC is still growing and maturing.

 

Given the opportunity, what would you change in WebRTC?

Aside from the expected growing pains, I am pleased with WebRTC.

 

What’s next for SaferMobility?

There’s a huge opportunity to improve public safety, security services, and general communication with modern mobile devices, and SaferMobility will be part of making those improvements.

–

The interviews are intended to give different viewpoints than my own – you can read more WebRTC interviews.

The post SaferMobility and WebRTC: An Interview With Matthew Mah appeared first on BlogGeek.me.

WebRTC GetUserMedia is more important than the rest of this communication stack.

Who would have believed? With all the magic and distraction that video calling from a browser brings with it, the real treasure trove resides in the basics – WebRTC GetUserMedia.

Simplifying things, WebRTC has 3 distinct areas/APIs to it:

1. GetUserMedia, allowing access to camera and microphone inside the browser
2. PeerConnection, taking care of all the mess that is a voice/video call
3. Data Channel, making it possible to send any arbitrary message across browsers directly

I’ve pointed up in the past how WebRTC GetUserMedia gets used by Mailchimp and WhatsApp. Taking a camera snapshot is nice, but what else can we achieve with this access we’ve been given?

TalkLessNow

Chris Kranky had an idea a few weeks ago. Measuring how much you’re yapping in a call as opposed to listening. So he made it happen. On a shoestring budget, some connections and a bit of time and TalkLessNow was born.

How it works?

The website is quite spartan. When you go on a phone call (not a WebRTC one), you just press the green Call button on talklessnow.com.

The code on the site “listens” through the machine’s microphone to your call. Whenever it hears enough of a volume – it assumes you’re talking. If the volume is lower than its configured threshold – you’re listening.

Just WebRTC GetUserMedia. No PeerConnection or any other fuss.

Will it work?

Here in Israel, I am sure the results won’t be good. We’re used to talking over each other and interrupting. Efficiency at its best. If in a call between Israelis it shows less than 70% of talk time per participant, I’ll crown that session a success.

Seriously though, we should be listening a lot more than we’re talking.

Same but different

The now defunct Guitar Tuner works the same way. It doesn’t work anymore because the site is served on HTTP and WebRTC GetUserMedia now requires HTTPS to work with the latest Chrome release (progress, you know).

Ziggeo

Here’s another example.

Ziggeo is making use of WebRTC to record videos. They do that by employing WebRTC GetUserMedia, storing the resulting media locally and at the end of the recording sending it to their servers. The sending part doesn’t occur via WebRTC.

There’s an interesting interview with Susan Danziger, CEO of Ziggeo from last week that you should read.

Is this Real Time Communications?

WHO CARES?

It works. It gives business value – and in ways that weren’t really possible up until today.

There’s a lot more to WebRTC than classic VoIP.

 

Planning on introducing WebRTC to your existing service? Schedule your free strategy session with me now.

The post The Hidden Gems of WebRTC Goodness May Well Lie Within GetUserMedia Itself appeared first on BlogGeek.me.

The FreeSWITCH project is nearly ten years old, and the FreeSWITCH git repo has commits from about 214 different authors and over 3.2 million lines of code with 875k of those lines under the src directory. Some of the maintenance challenges associated with such a large software project include: detecting and resolving human errors such as typos, logic inversions, and dangerous formatting. Implementing code review is a must, and there are different techniques common to the industry used to reduce the defect density and standardize the code format: autobuilding against multiple compilers, routine testing, and static code analysis. The core development team at FreeSWITCH uses all three techniques.

Both autobuilding and routine testing can be applied with in-house system workflows. Routinely building the packages against different compilers allows for consistent tracking to make sure additional commits won’t break existing code in any of the prepackaged builds. This also allows for consistent handling of packages for multiple operating systems. By autobuilding against different compilers, we can make sure that a commit for one set of packages doesn’t break the builds for the others. Routine testing is another viable option for code review, and routinely testing and implementing a bug tracking system allows the community members to report bugs found in unique environmental circumstances. Open-source software relies on many different eyes to keep bugs shallow, and this practice opens up different configurations and applications of the software for a more thorough testing. Each year hundreds of tickets are opened on the FreeSWITCH project JIRA, and the developers work tirelessly to address all of them.

Static analyzers can scan thousands to millions of lines of code without getting tired and usually don’t require many manual steps to run. The relationship between a project’s developers and the creators of a static code analyzer can be a symbiotic one. The analyzer works by using a database of multiple tiers of positive and negative heuristics. First, it runs the low cost patterns against the entire code base to generate a large list of possible issues, then runs more accurate and higher cost patterns against the bug candidates to reduce the number of false positives, and finally evaluates the severity and more accurately classifies the issues. Once the analyzer has completed its run, it requires an experienced software developer familiar with the code base to review each issue reported.

Most static analyzers are built to report possible candidates in the first pass, and thus immature analyzers are perceived to red flag everything. They tend to create a lot of noise by reporting a large number of false positives and misclassifying the severity of issues. After the developers for the software being analyzed have reviewed the results of the analysis, they can give specific examples of why they determined it to be a false positive which can be used to improve the static analyzer’s heuristics. As the database matures, the quality of the negative heuristics improves and reduces the volume of false positives. The advantage here is that each report triaged leads to a commit resolving a bug or an improvement to the analyzer.

The team over at Program Verification Systems have built a static analyzer for C/C++ code that integrates into Microsoft Visual Studio. According to their website, the program allows the user to scan of lines of code to locate various typos and other errors. Their analyzer supports C/C++, C++/CLI, and C++/CX with support for C# language coming soon. The PVS-Studio is also available as a standalone utility through the distribution packages which allows for viewing the analysis logs on a machine without Visual Studio. It can also be used to track multiple sub-builds and analyze non-standard build systems. The reports for the open-source projects that have been analyzed with this software can be found on their website in the Checked Projects section.

The FreeSWITCH team ran the open-source FreeSWITCH project through the PVS analyzer. A decent majority of the issues reviewed were determined to be minor Windows-specific bugs not previously flagged by compilers currently implemented by the team. The team is continuing to review and resolve the alerts from the analysis and have integrated this analyzer into the code review workflow. They look forward to continuing this symbiotic relationship with the goal of improving the quality of software.

If you would like to replicate the results you can use the following steps.

• Set up an instance of Microsoft Windows 10, install Microsoft Visual Studio 2015, and install the analyzer from the http://www.viva64.com/en/ website.
  

• Create a new FreeSWITCH project.
  

• Clone the FreeSWITCH repo into your project.
  

• Open the FreeSWITCH project.
  

• Set the debug to ‘x64’ if not already set.
  

• Click the PVS studio drop down box and select “check solution” to run the analyzer.
  

• Settle in and wait for the results.
  

Our features this week include: improvements to the auto bitrate features in mod_conference, the addition of the Debian install script for the verto communicator, and separate controls for gain and volume for verto. Join us Wednesdays at 12:00 CT for some more FreeSWITCH fun! This week we have Tsahi Levent-Levi talking about WebRTC! And head over to freeswitch.com to learn more about FreeSWITCH support.

New features that were added:

• FS-8595 [mod_conference] Improve auto bitrate in personal canvas mode and do not let auto bitrate exceed native picture size

Improvements in build system, cross platform support, and packaging:

• FS-8614 [verto_communicator] Add Debian developers install script and update README.md to reference it

The following bugs were squashed:

• FS-8585 [mod_commands] Expanded {} and <> to [] for each dial string in group_call to allow for multiple device registrations for the same user
• FS-8589 [mod_conference] Fixed using conference playback with full-screen=true not working correctly
• FS-8354 [mod_conference] Fixed G722 audio issues with mod_conference caused by previous commit fab43547
• FS-8602 [mod_conference] Fixed conference not auto-generating layouts properly when callers with no camera are present
• FS-8615 [mod_conference] Fixed a crash when quickly changing layouts and setting reservation ids
• FS-8588 [mod_httapi] Fixed a crash found while fixing unreliable digit collection
• FS-8599 [verto] Removed a workaround for Mozilla that is no longer needed for video size
• FS-8590 [verto_communicator] Fixed sending malformed vid-res-id command when changing layouts by treating no res-id the same as clear
• FS-8612 [core] Fixed a rare IVR originated calls crash due to read codec leak
• FS-8619 [mod_rayo] Reply with conflict stanza error if bind is attempted with duplicate JID. Improve error handling when ‘ready’ callback fails.

The FreeSWITCH 1.4 branch had a couple of bug fixes back ported. And again, keep in mind that 1.4 is quickly moving toward end of life and won’t be supported any longer except for high level security issues.

The following bugs were squashed:

• FS-8582 [mod_httapi] Fixed a crashed caused by null URL being passed

 

Links: http://www.dslreports.com/speedtest 

Links:https://support.flowroute.com/customer/en/portal/articles/2205573-freeswitch—add-flowroute-as-sip-gatewayhttps://developer.flowroute.com/

The future isn’t what it used to be.

I’ve been babbling here a lot about the enterprise video conferencing market and WebRTC’s role in disrupting it. When it first came out, I believed the existing companies are going to be struggling with it. I was mostly ignored by these companies – it is hard to see what’s just around the corner when you’re stuck in the echo chamber of your company and its immediate industry.

When I meet old colleagues of mine from the video conferencing industry and see them working in the same companies, I suggest they leave. Find another company or industry, because the outcome is known – just the timing factor is missing. They dismiss it, probably thinking that I am saying it our of a grudge to the company. I am not.

What happened in November should hit home.

We had two separate news items that in some cosmic way happened in the same week:

1. Cisco acquired Acano. For $700M USD. A company with around 350 employees (that’s $2M per employee)
2. Polycom announced closing its Israeli office. Moving the operations to India. That’s 200 employees + 80 contractors

Dumbing things down a bit:

• Acano was about building a cloud MCU. Polycom Israel was about building an on-premise MCU
• Acano started life in 2012, making immediate use of WebRTC. Polycom just launched their first MCU to support WebRTC this year (2015)

It isn’t that WebRTC is the reason why Acano succeeded and Polycom Israel has failed. It is that the mindset of these two companies was different. Acano looked into what can be done in this modern age and made use of WebRTC to get there. Polycom looked at how they slowly evolve their product offering. I am sure people in Polycom knew about WebRTC. It probably was on roadmaps and discussions since 2012, never to be given priority, because who needs it? It can’t compete with the high end systems of Polycom. But then the basis of competition changed. What customers care about changed. It isn’t anymore about resolutions and frame rates. It’s about utility and usability – something most video conferencing companies never knew how to handle.

Polycom Israel didn’t have the foresight to make themselves attractive enough to their corporate overlords in San Jose. Probably because they weren’t given the opportunity to do so. The end result? They just weren’t important. Their technology and architecture is now stable and understood enough to move it to countries with lower salaries.

—

I remember doing a training to developers about WebRTC in 2014. I asked people in the room what they do. There were media engineers and signaling protocols developers. I told them that they are going to be out of work. They saw it as a joke. Some of them are now updating their resume.

What is it that you are doing for a living? What is your company developing? Does it make sense? Do you take the effect WebRTC (and other technologies) have on your job seriously?

 

Planning on introducing WebRTC to your existing service? Schedule your free strategy session with me now.

The post The First WebRTC Earthquake in Video Conferencing: Acano vs Polycom appeared first on BlogGeek.me.

Kamailio project is pleased to announce that the date and location for next Kamailio World Conference and Exhibition were decided – May 18-20, 2016, in Berlin, Germany.Kamailio project is celebrating 15 years of development in 2016, therefore we plan to have a special edition, many guests that impacted the evolution of the project since its start in 2001 at FhG Fokus Institute.Website of the event and call for presentations will be launched very soon. Meanwhile, if you haven’t participated at a past edition, you can check the previous edition website in order to get an idea about the structure and content of the event:

• http://www.kamailioworld.com/k03/

Keep an eye on this news feed for updates in the near future!

During the Kamailio IRC level meeting this summer, a need for refreshing the logotype of the project was discussed. The current (embedded in the upper right corner of kamailio.org main page) is based on the one used for during the former OpenSER name of the project, with changes of the text to reflect the SIP Router and Kamailio names, somehow not longer very balanced, lacking good quality and high resolution graphics. The participants agreed that a refresh would be better than keeping that version.One option was to reuse the graphics from Kamailio World Conference logo, simply with Kamailio name. It was used even before as alternative logo by various peoples and companies.We now want to finish this process and we considered also the possibility of a new logo design. Thanks to Asipto and their deal with 99Designs, we ran a design contest and see if someone proposes an interesting logotype. Based on the result of the contest, followed by discussions on management group and the people interested in updating the logotype, we are proposing a new logo for the project:During the next days we are expecting feedback from community, especially if it looks too similar with other logos they know or if they like it or not. Based on that, a final decision will be taken and either we will switch to the new proposed logo or keep looking for a new one.Join the discussion about the new logo on users mailing list: sr-users@lists.sip-router.org .2D and 3D variants in different formats, as well as some combinations with few pictures, can be found at:

• https://www.kamailio.org/pub/kamailio-logos/new/

As a preview, a few variants are embedded here:

isVisible=false; function show_hide_searchbox(w){ if(isVisible){ document.getElementById('filterBoxSelection').style.display = 'none'; w.innerText='Filter ▼'; }else{ document.getElementById('filterBoxSelection').style.display = 'block'; w.innerText='Filter ▲'; } isVisible=!isVisible; } function checkIfSelected(chk){ if(chk.checked==1) chk.parentNode.className = "selected"; else chk.parentNode.className = "notselected"; getSelectedValues(); } function getSelectedValues(){ var a=document.getElementsByClassName('selected'); var vtVal=[] , ctVal=[] , ftVal=[]; var ct=0,vt=0,ft=0; for (x = 0; x < a.length; ++x) { try{ if(a[x].getElementsByTagName('input')[0].className=='companyType'){ ctVal[ct]= a[x].getElementsByTagName('input')[0].value; ct++; } if(a[x].getElementsByTagName('input')[0].className=='vendorType'){ vtVal[vt]= a[x].getElementsByTagName('input')[0].value; vt++; } if(a[x].getElementsByTagName('input')[0].className=='focusType'){ ftVal[ft]= a[x].getElementsByTagName('input')[0].value; ft++; } }catch(err){ } } search_VType(vtVal); search_CType(ctVal); search_FType(ftVal); } function search_VType(val){ var a=document.getElementsByClassName('interview-block'); for(x=0;x=0 && val[i]!=null){ a[x].style.display='block'; } } if(val.length==0){ a[x].style.display='block'; } } } function search_CType(val){ var a=document.getElementsByClassName('interview-block'); for(x=0;x=0 && val[i]!=null && a[x].style.display=='block'){ break; } if(i==val.length-1){ a[x].style.display='none'; } } } } function search_FType(val){ var a=document.getElementsByClassName('interview-block'); for(x=0;x=0 && val[i]!=null && a[x].style.display=='block'){ break; } if(i==val.length-1){ a[x].style.display='none'; } } } }Check out all webRTC interviews >>

Ziggeo: Susan Danziger

December 2015

Video recording

Other

Small

Video

Asynchronous video meets WebRTC.

[If you are new around here, then you should know I’ve been writing about WebRTC lately. You can skim through the WebRTC post series or just read what WebRTC is all about.]

One area where WebRTC is making strides recently is video streaming. Some of the hyped use cases today are those that enable broadcasting in real time, but there’s another interesting approach – one where WebRTC is employed when the video consumption is asynchronous from its creation.

Ziggeo is an API provider in this specific niche. I met with Susan Danziger, CEO of Ziggeo, and asked her to share a bit of what it is they do with WebRTC and how it is being adopted by their customers.

 

What is Ziggeo all about?

Ziggeo is the leader in asynchronous (recorded) video offering a programmable video recorder/player through our API/native SDKs.

 

You started by working on an HR interviews platform. What made you pivot towards a video recording API platform instead?

In building our own video recording/playback solution for the platform, we realized what a complicated and time-consuming process building our own solution was.  We had to make sure that videos could be recorded and played across all devices and browsers (even as new ones were released) and build a permissions-based security solution that would withstand hackers.  We were surprised there were no off-the-shelf solutions available so decided a bigger opportunity would be to release our technology as an API — and then native SDKs (and shortly thereafter closed our B2C platform).

 

On the same token – you have Flash there. Why did you add WebRTC? Wasn’t Flash enough for your needs?

For the most part our customers hate Flash.  And no wonder: browsers that support Flash have an awful user experience in which you need to basically hit 3 different buttons before you can begin recording from your web camera (once to resume the suspended Flash applet and twice to access the camera).

We added WebRTC to avoid Flash whenever possible.  That said, for certain browsers, e.g. Safari and Internet Explorer we need to default to Flash as they don’t yet support WebRTC.

 

How are customers reacting to the introduction of WebRTC to Ziggeo?

Customers love it!  In fact, our customers seek us out in part because we’re the only API for asynchronous video recording that supports WebRTC.

 

Can you share a few ways customers are using Ziggeo?

In addition to recruiting (where candidates introduce themselves on video), we’ve seen Ziggeo used for training (e.g. trainees record video sales pitches for feedback); dating (potential dates exchange video messages); “Ask Me Anything” (both questions and responses on video); e-commerce (products introduced on video and video reviews recorded); advertising (user-generated videos submitted for contests or for use in commercials); and journalism (crowd-sourcing videos for news from around the world).  I’m still waiting for someone to create a video version of Wikipedia where pieces of knowledge are recorded on video from around the world — that would be the most amazing use case of all.

 

A video version of Wikipedia. Have it in Hebrew and I’ll sign up my daughter on it.

You don’t use the Peer Connection APIs at all – Just getUserMedia. Why did you make the decision to record locally and not use the Peer Connection and record on the server?

Folks like to re-record locally so we chose not to use unnecessary resources.  We pride ourselves on making our technology as efficient and seamless as possible.

How do you store the file locally and how do you then get it to your data centers?

We use IndexedDB to store the file locally and then push it using chunked http.

 

Viewing. Over what protocols do you do it, and how do you handle the different codecs and file formats?

Protocols: Http pseudo streaming, HLS, rtmp, rtsp

Formats: we transcode videos to different formats (mp4, webm) and resolutions

 

Where do you see WebRTC going in 2-5 years?

We imagine there will be full support of WebRTC across all browsers and devices as well as better support for client-side encoding of video data.

 

Given the opportunity, what would you change in WebRTC?

We’d like to see improved support for consistent resolution settings as well as for encoding

 

What’s next?

We’re planning the 2nd Annual Video Hack Day in NYC for this coming May.  You can find more information here at: videohackday.com or follow @videohacknyc on Twitter

–

The interviews are intended to give different viewpoints than my own – you can read more WebRTC interviews.

The post Ziggeo and WebRTC: An Interview With Susan Danziger appeared first on BlogGeek.me.

This week we had a few features including: allowing building with OpenSSL without EC support, a video quality parameter to allow for conference configuration for verto, and some improvements to conference layouts for verto as well. If you haven’t already, it is highly recommended that you upgrade to the newest 1.6 release as soon as possible to avoid the vulnerability from last week. Join us Wednesdays at 12:00 CT for some more FreeSWITCH fun! This week we have James Tagg! And head over to freeswitch.com to learn more about FreeSWITCH support.

New features that were added:

• FS-8568 [core] Allow building using system OpenSSL without EC support
• FS-8293 [verto][mod_conference] Made sanity level based on 1080p and added a video-quality conference profile parameter for specifying the motion factor when calculating video bitrate, defaulting to 1.
• FS-8264 [verto_communicator][verto]  Adapted the layout select to new response, added a separated menu in members list to set its reservation id, and added all the reservation IDs in the return of “list-videoLayouts” command
• FS-8433 [mod_sofia] Allow hangup cause to be set inside redirect data

Improvements in build system, cross platform support, and packaging:

• FS-8592 [Windows] Fixed some simple compiler errors
• FS-8578 [mod_verto] Fixed build error for missing __bswap_64 on osx
• FS-8152 [Debian] Make sure to package the image directories too
• FS-8576 [Debian] Fixed a package upgrade issue related to the fonts being installed in multiple packages

The following bugs were squashed:

• FS-8569 [mod_conference] Fixed undefined symbol conference_cdr_test_mflag
• FS-8574 [mod_conference] Fixed a read write lock issue
• FS-8566 [core] Fixed calls failing when put on hold in bypass media mode with inbound late negotiation set to false
• FS-8573 [core] Fixed one way audio after resuming from hold in bypass media mode
• FS-8575 [core] Fixed DTMF not being passed from a to b during rfc 2833 events
• FS-8582 [mod_httapi] Fixed a crashed caused by null URL being passed

 

The FreeSWITCH 1.4 branch had a couple of bug fixes back ported as well as the release of 1.4.26. And again, keep in mind that 1.4 is quickly moving toward end of life and won’t be supported any longer except for high level security issues.

New features that were added:

• FS-8547 [core] Add error log into stats to log when quality impacting events begin and end

The following bugs were squashed:

• FS-8537 [mod_lua] Fixed a segfault caused by passing nil to various lua functions

Atom is an open source editor developed by Github. One of its useful features is ability to preview the markdown files while editing them. The Kamailio source tree includes a few such markdown files (e.g., README.md in the root folder). They are nicely displayed when browsing the GIT repository at github.com.Another feature would be auto-completion suggestion based on the content of the edited file, so, for example, if you define a route block, then its name appears when adding the statement to execute that route.A syntax highlighting package for kamailio.cfg has been made available at:

• https://github.com/miconda/atom-extensions/tree/master/language-kamailio

Information about how to install it are available in the readme at the above link.For now, it does rather basic matching of configuration file elements, still relevant to make them easier to spot. Contributions to enhance it are more than welcome!A screenshot with a part of default configuration:.Enjoy!

You are not always connected.

You are not always connected.

You are not always connected.

Truely you aren’t.

I know you like to think you are, but get over it – this isn’t the case.

From the unveiling of AWS IOT platform @ re:Invent 2015

Every week I need to take my daughter to her artistic gymnastics lessons. And then I have 90 minutes of quality time. With myself. While I usually use it to continue reading on my Kindle, I try once in awhile to actually work at that time. The problem is, that the cellular reception in the waiting hall is less than satisfactory and the mosquitoes make it impossible to sit outside – where it is a lot nicer with much better reception.

I quickly learned that working there is close to impossible, as reception is flaky – not something I can rely on with my line of work which requires an intravenous internet connection at all times. But there are quick things that I can do at that time – which most usually than not includes messaging.

Offline Messaging

Here’s what I found out about the 3 top messaging apps on my phone recently:

 

WhatsApp

WhatsApp rocks when it comes to be able to send messages even when I am offline. It uses the store and forward technique both on the client and on the server:

• If the user has no internet connection, the message is stored locally until such a connection is restored. This approach works only for text messages – you can share images or videos with it
• If the receiver has no internet connection, then the message is stored on the WhatsApp server until a point in time when the recipient is available – this works for all types of messages

You just can’t ask for more.

Google Hangouts

Google Hangouts is rather poor when it comes to offline behavior. I does manage its own store and forward mechanism on the server side, which means that if you send a message when you are online – the recipient will see it when he becomes online.

But, you can’t send anything if you aren’t online. Hangouts isn’t kind enough to store it locally until you are online.

This makes for a poor experience for me in that gymnasium waiting room, where the network comes and goes as it pleases. Or when I am riding the elevator going downstairs from my apartment and need to send some quick messages.

Slack

Slack needs to be connected. At least as far as my understanding of it is.

If you open the app, it tries to connect. If you send a message while it is connected – great.

If you try sending when it isn’t connected – it will fail.

But sometimes, it believes that it is connected and it isn’t. In such a case, killing the Android app and restarting it will be the only remedy to be able to send anything out.

Yuck.

Offline Frameworks

Communication frameworks are tricky. The idea is that you have a network to be able to communicate, but as we’ve just seen – this isn’t always the case.

So where do we stand with different frameworks? I had these 3 examples readily available out the top of my head for you:

Matrix History Storage

Matrix (interviewed here in the past) also went to great lengths to deal with offline scenarios. In the case of Matrix, it was about decentralization of the network itself, and how can you “self heal” and synchronized servers that go down min-conversation.

This makes it easy to add and remove servers during runtime, but it doesn’t help me in my daughter’s gymnasium class. I haven’t found any information stating that Matrix can (or can’t) send a message while the sender client is offline.

Twilio and Message History

Twilio announced its own IP Messaging capability. While this isn’t yet generally available, the concepts behind these APIs are outlined on that page.

To make things simple – it includes store and forward on the server (recipient can be offline when sender sends and vice versa); but it probably doesn’t include sending while the sender is offline.

As this is still under development/testing, my suggestion would be to add the “sender is offline” scenario and support it from the SDK.

Amazon Device Shadow

At AWS re:Invent 2015, Amazon unveiled its IOT platform – the building blocks it has on offer for the Internet of Things.

In many ways, the Internet of Things is… connected. But in many other ways it might not be connected at all times. I’ve seen several interesting IOT frameworks overcome these in various means. Here’s AWS take on it – they create what they call a device shadow.

 

Werner Vogels does a great job of explaining this. I suggest viewing the whole session and not just the 1 minute explainer on device shadow.

Why is it important?

We are never always truly online. As messaging becomes one of the central means of communicating – both between people as well as devices – it needs to take this into account. This means covering as many offline use cases as possible and not just assume everything is connected.

Doing this can be tricky to get right, and in many cases, it would preferable for developers to go with a solid framework or a service as opposed to building it on their own. What most frameworks still miss today is that nagging ability to send a message while the user is offline – storing it locally and sending once he comes online.

 

Planning on introducing WebRTC to your existing service? Schedule your free strategy session with me now.

The post The Unconnected Messaging World appeared first on BlogGeek.me.

We are currently having a special Black Friday sale, save $500 on your FreeSWITCH Bootcamp ticket - use the code: “blackfriday” to save now.

The FreeSWITCH Bootcamp is an intense three-day training, providing in-depth coverage of FreeSWITCH installation, configuration, maintenance and programming so that you can build your business. The bootcamp will be hosted in our brand new office in beautiful San Francisco. Go into the bootcamp as a Novice – and come out as a FreeSWITCH guru. Early bird pricing lasts until November 27th, but register now as there are limited spaces available.

Register Now! https://kazoosf.eventbrite.com

Thanks to Victor Seva from Sipwise, the Travis-CI jobs for building Kamailio were upgraded to useDocker containers.A part of continuous integration process for Kamailio project, the builds are triggered by commits to master and stable branches, helping to detect compilation issues on different OS distributions, which typically happen due to different versions of libraries.The bonus is that the same build system can be used locally by anyone, being it developer or VoIP engineer. Quite useful in cases when one wants to backport patches or develop its own extensions.You can read the description of the build system as well as get the scripts from the source code of Kamailio, in the folder test/travis-ci. You can browse the content of the folder online at:

• https://github.com/kamailio/kamailio/tree/master/test/travis

Enjoy!

Open-Source is an enormous component of what powers 2600Hz. Not only are we supporting and contributing to other open-source projects, the Kazoo platform is open-source. Open-source projects have been essential in building our incredible communications systems and we want to thank anyone who has contributed to our open infrastructure.

The Kazoo platform has been growing exponentially over the past five years and its scalability was recently validated at KazooCon. This October, over 200 people were in attendance at KazooCon, representing over twenty states and fourteen countries. We were blown away by the level of support of our platform, and in addition had largest Kazoo training following the conference.

Outside of the United States, our contributions have also taken off. Russia in fact, has garnered a very dedicated following. As of now, our top three 2015 contributors all hail from Russia.

We’re proud to announce that some of our Russian contributors of the Kazoo platform will be hosting Kazoo’s first independent community conference. Representatives from SIPLABS, Zebra Telecom, Telecom13, and OnNet will discuss how they’ve been utilizing the Kazoo platform. This will take place November 26th in Moscow. KAZOOMEETUP MOSCOW 2015 was conceived as a conference of users, developers, or people simply interested in our open telecommunications platform. 

So join our Russian friends as they host their first Kazoo meetup, and learn about Kazoo’s open-source contributions. Click Here.

Kamailio SIP Server v4.3.4 stable is out – a minor release including fixes in code and documentation since v4.3.3. The configuration file and database schema compatibility is preserved.Kamailio (former OpenSER) v4.3.4 is based on the latest version of GIT branch 4.3, therefore those running previous 4.3.x versions are advised to upgrade. There is no change that has to be done to configuration file or database structure comparing with older v4.3.x.Resources for Kamailio version 4.3.4Source tarballs are available at:

• http://www.kamailio.org/pub/kamailio/4.3.4/src/

Detailed changelog:

• http://www.kamailio.org/pub/kamailio/4.3.4/ChangeLog

Download via GIT: # git clone git://git.kamailio.org/kamailio kamailio
# cd kamailio
# git checkout -b 4.3 origin/4.3Binaries and packages will be uploaded at:

• http://www.kamailio.org/pub/kamailio/4.3.4/

Modules’ documentation:

• http://www.kamailio.org/docs/modules/4.3.x/

What is new in 4.3.x release series is summarized in the announcement of v4.3.0:

• http://www.kamailio.org/w/kamailio-v4-3-0-release-notes/

PS: note the dates and location for next Kamailio World – May 18-20, 2016, in Berlin, Germany – it is going to be a special edition, with Kamailio project celebrating 15 years of development.