News from Industry

Here’s what to expect during November.

Just wanted to share two things during this weekend.

WebRTC Summit, testing and San Francisco

I am traveling on the first week of November to San Francisco. The idea is to talk about WebRTC testing (and testRTC) at the WebRTC Summit.

I’ll be touching the challenges of testing WebRTC, which is somethings that isn’t discussed a lot out there:

1. Either there’s no challenge or problem and all is well
2. Or we’re still in the exploration phase with WebRTC, with little commercial value to it

I think there needs to be more focus in that area, and not just because I co-founded a WebRTC testing company.

I plan on being at the WebRTC Summit in Santa Clara on November 3-4. Here’s more about my session if you need. I am already filling up my days around that summit with meetings in both Santa Clara and San Francisco – if you wish to meet – contact me and I’ll see if I can still squeeze you in to my agenda.

Virtual Coffee with Tsahi

The first Virtual Coffee event took place a bit over a week ago. The recording of that session still isn’t available, but will be in a week or two.

It went well and I truly enjoyed the experience – the ability to handpick the people who can participate, get them signed in through my membership area on this website, and do it all under my own brand – it was great.

I’d like to thank (again) Drum’s team with their Share Anywhere service. It is as close to what I needed as could be – and easily customizable. Their team is great to work with as well (and no – they haven’t paid for me to say this).

The next session

When? November 11, 13:30 EDT

Where? Online, of course

Agenda:

• Microsoft Edge, ORTC – what you should know about it, and how to prepare for 2016?
• Open Q&A – on the topic above, or on any other topic

Who?

• These sessions are closed sessions. They are available to the following groups
• Employees of companies who have an active subscription for my WebRTC API Platforms report
• And employees of companies who I currently consult

Last but not least

I noticed recently people contacting me and asking me not to share their stories on this blog.

To make it clear – there are three reasons for me to share stories here:

1. I heard or read about it online, in a public setting. So the assumption is that the information is already public and sharable
2. I specifically asked if this can be shared – and got permission. Usually this ends up as an interview on my site
3. I share a story, but not the details about the specific company or the people involved

I put the bread on the table mainly through consulting. This means being able to assist vendors, and that requires doing things in confidence and without sharing strategies, roadmaps, status and intents with others. If you contact me through my site, my immediate assumption is that what you share is private unless you say otherwise.

 

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

The post Upcoming: WebRTC Summit and my Next Virtual Coffee appeared first on BlogGeek.me.

Kamailio and VoIP Wild World from 2600Hz

Daniel Constantin Mierla discusses Kamailio and Kazoo integrations at KazooCon

Why reminisce in the future when we’ve got so much to do in the here and now.

This week Chad wrote a post titled What’s Next for WebRTC? It is a good post, so don’t get this one as a rant or a critique about Chad. It is just the moment I saw the title and some of the words on the accompanying visual (AR, VR, drones, Industrial, Computer Vision, 3D, Connected Cars) – I immediately knew there’s something that bugs me.

It wasn’t about the fact that WebRTC isn’t used for any of these things. It was due to two reasons:

1. We’re still not scratching the surface of WebRTC yet, so what’s the rush with what’s next?
2. I hate it when people stick a technology on anything remotely/marginally related. This is the case for the soup of words I saw in the visual…

The second one, of buzzword abuse, I can only say this: WebRTC may play a role in each and everyone of these buzzwords, but its place in these market will be minuscule compared to the market itself. For many use cases in these markets, it won’t be needed at all.

For the first one, I have decided to write this.

There are many challenges for those who wish to use WebRTC today. This is something I tried to address in the last Kranky Geek event – WebRTC is both easy and hard – depending on your pedigree.

VoIP developers will see it as the easiest way to implement VoIP. Web developers will find it hard – it is the hardest thing that you can add to a browser these days, with many moving parts.

Here’s the whole session if you are interested:

Here’s what I think we should strive for with WebRTC and even ask those who work to make it available for us as a technology:

#1 – Become TCP

TCP works. We expect it to work. There are no interoperability issues with TCP. And if there are, they are limited to a minuscule number of people who need to deal with it. WebRTC isn’t like it today.

WebRTC requires a lot of care and attention. This fresh interview with Dan about the WebRTC standard shows that. You’ll find there words about versioning, deprecation, spec changes, etc. – and the problem is they affect us all.

This brings us to this minor nagging issue – if you want to use and practice WebRTC, you need to be on top of your game and have your hand on the WebRTC pulse at all times – it isn’t going to be a one-off project where you invest in developing a web app or an app and then monetize and bask in the sun for years.

The other alternative is to use a WebRTC API vendor, who needs to take care of all that on his own. This can’t be easily achieved by those who need an on premise deployment or more control over the data. This alternative also speaks louder to developers than it does to IT managers in enterprises, leaving out part of the industry of potential adopters of WebRTC.

The faster WebRTC becomes like TCP the better.

#2 – More success stories of a variety of simple use cases

There are a lot of areas where I see vendors using WebRTC. Healthcare, learning, marketplaces, contact centers, etc.

In many cases, these are startups trying to create a new market or change how the market works today. While great, it isn’t enough. What we really need is stories of enterprises who took the plunge – like the story told by AMEX last year. We also need to see these startups grow and become profitable companies – or larger vendors who acquire technology (I am talking to you Slack, Atlassian and Blackboard) use them in their products.

These stories that I am interested in? They should be able the business side of things – how using WebRTC transformed the business, improved it, got adopted by the end customers.

Where are we?

With all the impressive numbers of WebRTC flying around, we still are in the early adopters phase.

We are also still struggling with the basics.

There are many great areas to explore with WebRTC – the large scale streaming space is extremely interesting to me. So is the potential of where WebRTC fits in IOT – which is even further out than the large scale streaming one. I love to be a part of these projects and those that seek them are at the forefront of this technology.

We’re not there yet.

But we will be.

There’s no stopping this train any time soon.

 

Test and Monitor your WebRTC Service like a pro - check out how testRTC can improve your service' stability and performance.

 

The post The What’s Next for WebRTC Can Wait Until We Deal With What’s Now appeared first on BlogGeek.me.

Links:
http://www.kamailio.org/events/2015-I…
http://www.kamailio.org/events/2015-A…
http://kb.asipto.com/freeswitch:index
http://kb.asipto.com/freeswitch:kamai…

If you are new to WebRTC then you have missed out on years of drama in the standards bodies over various issues like SDP and codecs. These standards dictate what vendors must implement so they ultimately dictate the industry roadmap.  To get a deep perspective and appreciation of the issues, we like to ask Dan Burnett, W3C editor to comment on where we are at with the standardization process. I caught up with Dan at this year’s IIT Real Time Communications Conference and had the more detailed Q&A with him shortly thereafter.

We asked Dan to comment on recent spec changes, ORTC, the next version of WebRTC, codecs, Apple, when the 1.0 spec might ever be finalized, and a whole lot more.

{“editor”, “chad hart“}

New Governance

webrtcHacks: Hi Dan. Can you describe some of the recent changes to the W3C WebRTC governance?

Dan: Yes. There was a long-running but productive discussion among the members of the WebRTC Working Group (WG), ORTC Community Group (CG), and the some of the members of the W3C advisory committee – which is the group that officially determines group charters.

As part of the Charter renewal process, we decided that there would be one additional Chair of the WebRTC Working Group –  Eric Lagerway of Hookflash who was one of the initiators of ORTC. Also the decision was that the WebRTC WG is the official group where all future standardization work in WebRTC will happen, meaning the ORTC work will gradually fold into that group.

Additionally, the group was chartered to work on another version beyond 1.0 – WebRTC Next Version or WebRTC-NV.

There are 2 requirements on that version:

1. There is no requirement that new features introduced in the specification have an SDP equivalent
2. WebRTC NV is not a replacement for WebRTC 1.0 – it is an extension. It is expected that all browsers that support WebRTC NV will support 1.0 functionality as well.

One other thing has happened that is not official, but is probably good is that Bernard Aboba from Microsoft has joined the WebRTC 1.0 editing team.

The Next Version

webrtcHacks: yeah, Bernard mentioned that in the interview I did with him last week. Can you explain WebRTC NV? Why didn’t you just call it 2.0, or 1.1, or whatever?

Dan: I have been working on standards for a long time. I have seen groups spend ridiculous amounts of time deciding on a name for a specification.  In this particular case a “1.1” sounds like a minor change from “1.0” while “2.0” sounds like a major change. Some people want a minor change. Some people want a major change. If enough people want different minor changes it will end up being a 2.0 anyway because of the number of changes. The goal was to avoid that disagreement now so that we can move forward,.

webrtcHacks: So what is WebRTC NV then, beyond what you stated earlier about no SDP?

Dan: Nothing is officially decided but I expect that there will continue to be more low-level controls as in ORTC. This is complicated by the fact that new feature proposals are continuing to come in for 1.0. Many of these features are from ORTC.

In the Sapporo meeting coming up, Google will be sharing their idea for what should go into WebRTC-NV when we finally start working on it.

Dan at the IIT-RTC Conference

webrtcHacks: How do you see ORTC influencing the WebRTC spec? Is WebRTC-NV really just ORTC?

Dan: If it had to summarize WebRTC-NV I would say that it is the combination of WebRTC 1.0 and ORTC. It is a requirement that 1.0 applications continue to work in WebRTC-NV implementations. It is not required that ORTC applications work directly in WebRTC-NV.

I believe the ORTC community intends to modify ORTC as necessary to remain consistent with WebRTC as it evolves.

webrtcHacks: Is there an end-date to ORTC-then? When it is mostly merged with WebRTC-NV will it cease to exist?

Dan: I can’t speak for the ORTC group. I have not heard of an end date. You’ll have to ask one of the primary ORTC contributors.

Spec Changes

webrtcHacks: What are some of changes made to the specs recently. Particularly those that impact the developers out there?

Dan: First I would like to give a little plug for my webrtcstandards.info site where I have been putting exactly that sort of information over the past few months. I will mention some things here, but you can get more details on that site.

webrtcHacks: ok, we’ll give you one plug (laughs)

Dan: One of the biggest and most relevant changes on what we were just talking about is the introduction of the RTCsenders and RTCreceivers. These are objects that allow for both information and more direct control over how tracks are sent over a PeerConnection. Notice as part of this that we have moved from a stream based API to a track based API.

webrtcHacks: And what advantage does the track approach provide?

Dan: It turns out developers want to have more control over exactly how tracks are sent and received. For example being able to specify which codecs are to be used and the parameters used to configure those codecs. They should be able to configure some transport properties as well on a per track basis such as FEC, retransmission, and bandwidth. Because of this it really didn’t make sense to talk about streams as the primary primitive being sent over a PeerConnection since they are really just a collection of tracks.

One of Peter Thatcher ORTC update slide’s showing the differences between the WebRTC and ORTC API. source: IIT-RTC 2015

webrtcHacks: So the others?

Dan: First, on the one we just mentioned – that was a foundational change where we are going to be seeing many other changes later on. Now I’ll talk about the others that are not related to that.

One big change was the API’s have been converted to use ECMAScript Promises. I think I mentioned this last year.

webrtchacks: You did.

Dan: It has happened. It is now in the specifications.

Promises are now the recommended mechanism for WebRTC specifications and for web specifications in general for dealing with asynchronous function calls. Not so much for things that generate multiple events, but definitely for any single asynchronous function call.

This is part of the move of ECMAscript toward truly asynchronous function calls as you can see if you look at some of the thoughts or future versions of ECMAscript.

The original callback based API’s currently still exist but will eventually be deprecated. Developers should start using the Promise versions.

webrtcHacks: I know media capture from the DOM is another one.

Dan: There has been good progress on capturing media directly from media elements such as audio, video and canvas. Developers have had to use hacks up to this point to be able to capture a canvas for example. Maybe they would take snapshots, but that is not the same as a realtime media stream as you would get from a getUserMedia call.

The major changes going into the specification soon  are to try to reproduce the resulting media stream as faithfully as possible to what a user would experience from that element. For example, if the user is playing a video and pauses it and then resumes, the resulting stream should show the paused video for the amount of time it was paused and then resume again.

This seems to be what developers are most interested in.

webrtcHacks: can you talk about some of the use cases that are being referenced around this feature?

Dan: Shared whiteboard is probably the best example, but there maybe some instances for training purposes where you want to capture how the user has interacted with existing elements – video or audio.

webrtcHacks: What about screensharing?

Dan: There is good progress happening there as well on the specification. It still has some tricky issues in terms of what apps should be able to request to be shared and what users should have control over. An example of this is Microsoft Powerpoint – if a user has 3 powerpoint documents up – say different presentations for different clients; they are likely to only want to share one one of those presentations – one window of that application. That works great until they go into presentation mode, which is far as the computer is concerned is a different window. So is this a case where the user should decide or is this a case where the application should decide what is shared?

In general the WG believes that the user should have the control, but browsers may have to make special cases for known applications such as Powerpoint so that it just works.

webrtcHacks: How about simulcast?

Dan: At the Seattle meeting there were some strong opinions on how simulcast should work and some proposals. Each time we get to the details the discussions diverge rather than converge. We all want it but we do not agree on how it should be signaled.

Timelines

webrtcHacks: Now for an easier one. When will 1.0 be done?

(laughs)

Dan: I am tempted to give a similar answer as last year.

There are 2 primary specifications. The media capture specification is right now finishing up addressing the comments from its Last Call review which is the wide range review that is required in order to go forward. There aren’t any new features being requested by group members – it’s just cleaning up and fixing.

It probably will be stable within another 6 months.

webrtcHacks: Stable meaning not changing any more?

Dan: Yes – meaning no contentful changes. Only editorial fixes.

Now the WebRTC specification has the problem that new features keep coming in.

werbrtcHacks: Just to clarify – the Media Capture group is the getUserMedia API and when you WebRTC, that means the RTCPeerConnection and DataChannel related API’s?

Dan: Yes.

These are features that have come from ORTC. At each meeting we have tried to finalize the list, but new proposals continue to creep in. Within 6 months we will know whether the chairs have been able to hold the line on the most recent list agreed to in Seattle.

webrtcHacks: So is this why it is taking so long?

Dan: Yes.. The good news about it is that the features that are going in are the most requested ones from ORTC.

IP Leakage

webrtcHacks: The IP leakage issue was a hot topic on webrtcHacks and elsewhere? Many have labeled it as a flaw; other say this behaviour was by design? Can you share the “standards” perspective on this topic and the considerations that were discussed?

Dan: The summary is this – there are 2 problems with IP leakage:

One kind is the leakage of public addresses that the user doesn’t want leaked. This can happen when a user is using a VPN and not all of the traffic is sent over the VPN – a so called split tunnel VPN.  This is an issue if the user doesn’t want their non-VPN public address to be revealed. This is not a WebRTC problem; this is a split tunnel VPN problem. That doesn’t mean that people don’t blame the browser vendors even though it’s not their fault (laughs}

Technically any application running on your machine could do the same thing if you’re running a split tunnel VPN. There are extensions to turn off WebRTC for people who are very concerned about this.

The other kind of leakage is leakage of your local IP address. the reason this concerns some people is that it can be used to map the topology of your local network, say within an enterprise. However it turns out that applications can use an XmlHttpRequest to do the same thing.  Despite that, the browser vendors are working on ways to turn off the reporting of these local addresses.

There will be more details coming up in an upcoming post on my site.

Dan talking to webrtcHacks guest author Alan Jonhston at the IIT-RTC show

What’s Apple Doing?

webrtcHacks: Now the only major browser vendor left is Apple. Can you comment on public participation by Apple?

Dan: It is clear that people from Apple are continue to follow the work, but they still don’t contribute.

webrtcHacks: Do you know if they contribute to other WG more actively.

Dan: Yes, Apple does contribute more actively in other WG within W3C.

Codecs

webrtcHacks: Anything new with video codecs now that the market has had some time to react to the decision to include both VP8 & H.264 for browsers? How is the VP9 vs. H.265 and Alliance for Open Media (AOM) discussion changed the discussion?

Dan: The gauntlet has been thrown for the creation of free and open source video codecs. MPEG-LA needs to take notice that the media producers and distributors are serious about coming up with lower cost alternatives. This pressure just continually increases. The AOM is a prime example of that.

webrtcHacks: Has the Alliance for Open Media come up in standards discussion? In the past I know there was discussion of just allowing software codecs that could defined on the fly.

Dan: Codecs still need to be created.  The discussions of VP8 vs H.265 and VP9 vs. H.265 are not really technical discussions. They are all about intellectual property because of the cost of licensing the codecs. The issue is not being able to select a codec – the issue is having a codec that you want to choose.

One API change that is just gone in is being able to choose which codec of the browser supported ones to use.

Microsoft

webrtcHacks: Anything else to add?

Dan: I think we’re finally on a good track in respect to a path forward for ORTC and WebRTC and thus the inclusion of Microsoft as a true and complete WebRTC vendor eventually. We just need the feature inflow from ORTC to stop right now to be able to declare victory and move on.

I think this is evidence that the industry really does want this to happen.

I spoke with a number of people who talk to HTML developer groups and they all agree that even today no more than 50% of the developers have heard of WebRTC – still! It is likely that one reason for that is for many developers a technology isn’t real until it is in Internet Explorer or its successor – Edge.

So having Microsoft fully engaged on a plan that we can all agree on now is a good thing for everyone.

 

{
  “Q&A”:{
    “interviewer”:“chad hart“,
    “interviewee”:“Dan Burnett“
  }
}

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 Are we There Yet? WebRTC standards Q&A with Dan Burnett appeared first on webrtcHacks.

On Wednesday, October 21, 2015, at 17:00GMT (12:00CT, 18:00 London, 19:00 Berlin), the Cluecon weekly conference call will focus on Kamailio and FreeSwitch. I will be joining the call, answering the questions about Kamailio and its options to integrate with FreeSwitch. Expect the FreeSwitch core developers to be around to handle the questions about their project.Participation is open for anyone, you can dial in for audio or video sessions using a SIP phone or webrtc capable browser:

• sip:888@conference.freeswitch.org
• https://cantina.freeswitch.org/vc

More dial in options (PSTN) are presented at:

• https://freeswitch.org/confluence/display/FREESWITCH/ClueCon+Weekly+Conference+call

Enjoy!

A lot more than pure messaging.

Messaging used to be about presence and IM. Then the VoIP people came and placed the voice and video chat stickers on it. That then became unified communications. Which is all nice and well, but it is both boring and useless at this point. Useless not because the utility of the service isn’t there, but because the expectation of such a service is to be free – or close to that. Or as I like saying, it has now become a feature within another service more than a service in its own right.

While this is killing unified communications, it doesn’t seem to be making much of a dent on messaging just yet. And the reason I think is the two very different trajectories these are taking:

• Unified Communications is focused on being the one true source of everything that gets federated with all other communication means
• Messaging shifted towards becoming platforms, where the size of the ecosystem and its utility outweighs any desire or need to federate with other similar services

This migration of messaging towards becoming platforms isn’t so easy to explain. There’s no silver bullet of how this is done. No secret recipe that gets you there.

Here are a few strategies that different messaging platforms are employing in their attempt to gain future growth.

Whatsapp and Simplicity

Whatsapp is all about simplicity. It offers pure messaging that replaces the SMS for many, coupled with group messaging that makes it sticky and viral in many countries.

Features don’t make it into Whatsapp fast. The only thing that was added in the past two years of any notable value is voice calling.

With this approach, Whatsapp still is the largest player in town when it comes to messaging; and it is probably doing so with the smallest possible team size.

The problem with such an approach, is that there isn’t enough room for many such players – and soon, to be a viable player in this domain will require a billion monthly active users.

Apple and iMessage

In that same token, the Apple iMessage is similar. It is simple, and it is impossible to miss or ignore if you have an iPhone.

But it is limited to Apple’s ecosystem which only runs on iOS devices.

Google Hangout (and now Jibe Mobile)

Google Hangouts was supposed to do the same/similar on Android, but didn’t live up to the expectation:

• Unlike Whatsapp, group chat is available in Hangouts, but isn’t viral or “mandatory”
• Unlike Apple iMessage, the user needs to make a mental note of using Hangouts instead of the SMS app. There are two of those, and as a user, you are free to choose which one to us. Choice adds friction and omplexity

With the acquisition of Jibe Mobile, this may change in the future. Will others follow suit? Is there enough utility and need in connecting messaging with Telco messaging, and especially with RCS, that many (myself included, at least until this acquisition) see as dead on arrival?

Facebook and Artificial Intelligence

Facebook is experimenting with artificial intelligence that is embedded into their Facebook Messenger service – not the social network where e-commerce is the current focus.

This new AI initiative is called Facebook M and is planned to be driven by part machine part humans.

In many ways, this is akin to the integration LivePerson (a chat widget for contact centers) has with knowledge bases that can cater to customer’s needs without “harassing” live agents in some cases. But this one is built into the messaging service the customer uses.

It is compared to Siri and Cortana, but you can also compare it to Google Now – once Facebook fleshes out the service, they can open up APIs for third parties to integrate to it, making it a platform for engaging with businesses.

WeChat and the Digital Life Platform

WeChat is large in Asia and dominant in many ways. It is an e-commerce platform and a digital life ecosystem.

Connie Chan of Andreessen Horowitz gives a good overview of what makes WeChat a platform:

Along with its basic communication features, WeChat users in China can access services to hail a taxi, order food delivery, buy movie tickets, play casual games, check in for a flight, send money to friends, access fitness tracker data, book a doctor appointment, get banking statements, pay the water bill, find geo-targeted coupons, recognize music, search for a book at the local library, meet strangers around you, follow celebrity news, read magazine articles, and even donate to charity … all in a single, integrated app.

WeChat transitioned from being a communication tool to becoming a platform. It has APIs that makes it easy for third parties to integrate with it and offer their own services on top of WeChat’s platform.

While I use the term “from service to feature” when talking about VoIP and WebRTC, Connie Chan uses “where social is just a feature” to explain the transition WeChat has made in this space.

The ability to send messages back and forth and communicate in real time via voice and video is now considered table stakes. It is also not expected to be a paid service but a feature that gets monetized elsewhere.

Meanwhile in Enterprise Messaging

Slack, which Connie Chan also briefly notes in his account of WeChat, is the guiding light of enterprise messaging these days.

Unlike other players in this space, Slack has built itself around the premise of three strong characteristics:

• Integration – third parties can integrate their apps into Slack, and in many cases, Slack integrates automatically through links that get shared inside messages. Integrations that make sense and bring value to larger audiences of Slack gets wrapped into Slack – the acquisition of Screenhero and the plans to enhance it to video conferencing shows this route
• Omnisearch – everything in Slack is searchable. Including the content of links shared on Slack. This makes for a powerful search capability
• Slackbot – the slackbot is a Slack bot you can interact with inside the service. It offers guidance and some automation – and is about to enjoy artificial intelligence (or at the very least machine learning)

The enterprise platform is all about utility.

Slack is introducing AI and has its own marketplace of third party apps via integrations. The more enterprises use it, the more effect these two capabilities will have in enforcing its growth and effectiveness.

While the fight seems to be these days between Unified Communications and Enterprise Messaging, I believe that fight is already behind us. The winner will be Enterprise Messaging – either because UC vendors will evolve into Enterprise Messaging (or acquire such vendors) or because they will lose ground fast to Enterprise Messaging vendors.

The real fight will be between modern Enterprise Messaging platforms such as Slack and consumer messaging platforms such as WeChat – enterprises will choose one over the other to manage and run their internal workforce.

 

Kranky and I are planning the next Kranky Geek - Q1 2016. Interested in speaking? Just ping me through my contact page.

The post The Future of Messaging is… appeared first on BlogGeek.me.

Hello, again. This past week in the FreeSWITCH master branch we had 25 commits. Our feature this week in the verto communicator is the addition of ngSanitize as a dependency, vertoFilters module and picturify filter, and a change to the chat image display behavior (break line before rendering).

Join this Wednesdays at 12:00 CT for some more FreeSWITCH fun with Daniel-Constantin Mierla! And head over to freeswitch.com to learn more about FreeSWITCH support.

New features that were added:

• FS-8030 [verto_communicator] Added ngSanitize as a dependency, vertoFilters module and picturify filter and changed chat image display behavior (break line before rendering).

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

• FS-8194 FS-7910 FS-7937 Various systemd service improvements
• FS-8350 [build] Fix Windows build errors.
• FS-7928 FS-7618 [Debian] Systemd and package build improvements

The following bugs were squashed:

• FS-8328 [mod_conference] Fixed missing ‘else’ keyword
• FS-8306 [mod_amqp] If the exchange doesn’t exist, then create it, else fail. This resolves several error cases. And now command queues can specify the queue to subscribe to. This enables very interesting use cases that would involve single job queue, and multiple consumers.
• FS-8331 [verto_communicator] Do not show reconnect splash when user has clicked logout
• FS-8335 [mod_easyroute] Fixed a small error check that results in error message not being displayed
• FS-6833 FS-6834 [mod_sofia] Found and fixed a few missing content-types in requests/responses with SDP that were outside the norm
• FS-8338 [core] Fix for ringback not working correctly on stereo channels
• FS-7834 [mod_sofia] Fixed MOH not working with inbound-bypass-media and resume-media-on-hold
• FS-8287 [mod_local_stream] Fixed a segfault from refactor

And, this past week in the FreeSWITCH 1.4 branch we had 2 new commits merged in from master. And the FreeSWITCH 1.4.23 release is here! Go check it out!

The following bugs were squashed:

• FS-8338 [core] Fix for ringback not working correctly on stereo channels
• FS-8354 [mod_conference] Reverted a back ported patch for rate change detection because it introduced a regression that caused an audio issue

We have an immediate WebRTC development contract opportunity that has just come up in the Seattle area. The contract requires 4-5 full-time developers onsite, remote will not fit the bill on this one.

For this contract we are looking for a team lead, 2 x Node.js, 2 x common JS developers

You have built commercial web applications using WebRTC libraries and are intimately familiar with the WebRTC and ORTC specs and respective libraries.

Start date: ASAP

If you are interested please forward your resume elagerway@gmail.com

Time for another WebRTC Basics: Video Codecs

I’ve been yapping about video codec more than once here on this blog. But what is it exactly?

If you’re a web developer and you are starting to use WebRTC, then there’s little reason (until now) for you to know about it. Consider this your primer to video coding.

Definition

A video codec takes the raw video stream, which can be of different resolution, color depth, frame rate, etc. – and compress it.

This compression can be lossless, where all data is maintained (so when you decompress it you get the exact same content), BUT it is almost always going to be lossy. The notion is that we can lose data that our human eye doesn’t notice anyway. So when we compress video, we take that into account, and throw stuff out relative to the quality we wish to get. The more we throw – the less quality we end up with.

The video codec comes in two pieces:

1. Encoder – takes the raw video data and compresses it
2. Decoder – takes the compressed data created by an encoder and decompresses it

The decoded stream will be different from the original one. It will be degraded in its quality.

The Decoder is the Spec

The thing many miss is that in order to define a video codec, the only thing we have is a specification for a decoder:

Given a compressed video stream, what actions need to take place to decompress it.

There is no encoder specification. It is assumed that if you know how the compressed result needs to look like, it is up to you to compress it as you see fit. Which brings us to the next point.

Generally speaking, decoders will differ from each other by their performance: how much CPU they take to run, how much memory they need, etc.

The Encoder is… Magic

Or more like a large set of heuristics.

In a video codec, you need to decide many things. How much time and effort to invest in motion estimation, how aggressive to be when compressing each part of the current frame, etc.

You can’t really get to the ultimate compression, as that would take too long a time to achieve. So you end up with a set of heuristics – some “guidelines” or “shortcuts” that your encoder is going to take when he compresses the video image.

Oftentimes, the encoder is based on experience, a lot of trial and error and tweaking done by the codec developers. The result is as much art as it is science.

Encoders will differ from each other not only by their performance but also by how well they end up compressing (and how well can’t be summed up in a single metric value).

Hardware Acceleration

A large piece of what a codec does is brute force.

As an example, most modern codecs today split an image into macroblocks, each requiring DCT. With well over 3,000 macroblocks in each frame of 720p resolution that’s a lot that need to get processed every second.

Same goes for motion estimation and other bits and pieces of the video codec.

To that end, many video codec implementations are hardware accelerated – either the codec runs completely by accelerated hardware, or the ugly pieces of it are, with “software” managing the larger picture of the codec implementation itself.

It is also why hardware support for a codec is critical for its market success and adoption.

Bandwidth Management

A video codec doesn’t work in a void. Especially not when the purpose of it all is to send the video over a network.

Networks have different characteristics of available bandwidth, packet loss, latency, jitter, etc.

When a video encoder is running, it has to take these things into account and compensate for them – reducing the bitrate it produces when there’s network congestion, reset its encoding and send a full frame instead of partial ones, etc.

There are also different implementations for a codec on how to “invest” its bitrate. Which again brings us to the next topic.

Different Implementations for Different Content Types (and use cases)

Not all video codec implementations are created equal. It is important to understand this when picking a codec to use.

When Google added VP9 to YouTube, it essentially made two compromises:

1. Having to implement only a decoder inside a browser
2. Stating the encoder runs offline and not in real-time

Real-tme encoding is hard. It means you can’t think twice on how to encode things. You can’t go back to fix things you’ve done. There’s just not enough time. So you use single-pass encoders. These encoders look at the incoming raw video stream only once and decide upon seeing a block of data how to compress it. They don’t have the option of waiting a few frames to decide how to compress best for example.

Your content is mostly static, coming from a Power Point presentation with mouse movements on top? That’s different from a head-shot video common in web meetings, which is in turn different than the latest James Bond Spectre trailer motion.

And in many ways – you pick your codec implementation based on the content type.

A Word about WebRTC

WebRTC brings with it a huge challenge to the browser vendors.

They need to create a codec that is smart enough to deal with all these different types of contents while running on variety of hardware types and configurations.

From what we’ve seen in the past several years – it does quite well (though there’s always room for improvement).

 

Next time you think why use WebRTC and not build on your own – someone implementing this video codec for you is one of the reasons.

 

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

 

 

The post WebRTC Basics: What’s a Video Codec Anyway? appeared first on BlogGeek.me.

Chrome, Firefox, and Edge are all on the same party line. Image from Pillow Talk (1959)

For the first time, Chrome, Firefox and Edge can “talk” to each other via WebRTC and ORTC. Check the demo on Microsoft’s modern.ie testdrive.

tl;dr: don’t worry, audio works. codec interop issue…

Feature Interoperability Notes ICE yes Edge requires end-of-candidate signaling DTLS yes audio yes using G.722, Opus or G.711 codecs video no standard H.264 is not supported in Edge yet DataChannels no Edge does not support dataChannels

As a reader of this blog, you probably know what WebRTC is but let me quote this:

WebRTC is a new set of technologies that brings clear crisp voice, sharp high-definition (HD) video and low-delay communication to the web browser.

In order to succeed, a web-based communications platform needs to work across browsers. Thanks to the work and participation of the W3C and IETF communities in developing the platform, Chrome and Firefox can now communicate by using standard technologies such as the Opus and VP8 codecs for audio and video, DTLS-SRTP for encryption, and ICE for networking.

This description is taken from the early-2013 Chromium blog post that announced interoperability between Chrome and Firefox. And now Edge?

Codecs…

So we have interoperability – for audio calls.  It is just audio. No video interoperability yet. Now this is just an issue of all vendors implementing at least one common video codec:

• Edge currently implements a Microsoft variant of H264 called H264UC which adds some features like SVC
  • Adding H264 is work in progress
  • While there is a VP9 decoder for playing videos, that is not usable for ORTC so don’t get too excited
  • See Bernard’s comments for more information
• Chrome implements VP8; H264 is work in progress
• Firefox implements VP8 and H264

Audio interoperability is currently using G.722 instead of Opus because Edge still prefers Silk and G.722 over Opus.

APIs

But wait, how can those browsers talk if they do not agree on APIs?

Well, I implemented the PeerConnection API on top of ORTC. The gory details can be found here as part of a pull request for adapter.js. It has undergone a quite critical review and improved as a result of that. This process also showed some issues in the ORTC specification. While there has always been the assumption that it would be possible to implement the PeerConnection API using the lower-level ORTC API, nobody had actually done it.

The functionality provided is limited. More than a single audio and video track has not been tested and, since this is using an SDP similar to what is specified in the Unified Plan draft would likely not be interoperable with Chrome. But this is sufficient for quite a number of applications that are simple enough not to benefit from ORTC natively.

SDP!

Using this Javascript implementation, Edge will generate something that is close enough to the SDP used by the PeerConnection API:

v=0 o=thisisadapterortc 8169639915646943137 2 IN IP4 127.0.0.1 s=- t=0 0 m=audio 9 UDP/TLS/RTP/SAVPF 104 9 106 0 103 8 97 13 118 101 c=IN IP4 0.0.0.0 a=rtcp:9 IN IP4 0.0.0.0 a=rtpmap:104 SILK/16000 a=rtcp-fb:104 x-message app send:dsh recv:dsh a=rtpmap:9 G722/8000 a=rtcp-fb:9 x-message app send:dsh recv:dsh a=rtpmap:106 OPUS/48000/2 a=rtcp-fb:106 x-message app send:dsh recv:dsh a=rtpmap:0 PCMU/8000 a=rtcp-fb:0 x-message app send:dsh recv:dsh a=rtpmap:103 SILK/8000 a=rtcp-fb:103 x-message app send:dsh recv:dsh a=rtpmap:8 PCMA/8000 a=rtcp-fb:8 x-message app send:dsh recv:dsh a=rtpmap:97 RED/8000 a=rtpmap:13 CN/8000 a=rtpmap:118 CN/16000 a=rtpmap:101 telephone-event/8000 a=rtcp-mux a=ice-ufrag:lMRF a=ice-pwd:NR15fT4U6wHaOKa0ivn64MtQ a=setup:actpass a=fingerprint:sha-256 6A:D8:7D:05:1A:ED:DB:BD:6A:60:1A:BC:15:70:D1:6C:A1:D9:00:79:E5:5C:56:15:73:80:E2:82:9D:B9:FB:69 a=mid:nbiwo5l60z a=sendrecv a=msid:7E4272C7-2B6C-49BD-BF7A-A3E7B8DD44F5 D2945771-D7B4-4915-AC29-CEA9EC51EC9E a=ssrc:1001 msid:7E4272C7-2B6C-49BD-BF7A-A3E7B8DD44F5 D2945771-D7B4-4915-AC29-CEA9EC51EC9E a=ssrc:1001 cname:3s6hzpz1jj

Check the anatomy of a WebRTC SDP post to find out what each of these lines mean.

This allows quite a number of the WebRTC PeerConnection samples to work in Edge, just like many of the getUserMedia samples already work.

With that working, the next big challenge was browser interoperability. Would this underspecified blob of text be good enough to be accepted by Chrome and Firefox?

It turned out to be good enough. After adding ICE candidates on both sides the ice connection and DTLS states soon changed to completed and connected. Yay. In Chrome at least.
Firefox did not work because of trivial mistakes that took a while to figure out. But then, it just worked as well.

As far as I am concerned this shows the hard part, making ICE and DTLS interoperable, is solved. The rest is something for codec folks to work out. Not my area of interest

{“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 Hello Chrome and Firefox, this is Edge calling appeared first on webrtcHacks.

Here’s a thought. Why not get WebRTC to the operating system level and be done with it?

Today, there are different ways to get WebRTC going:

1. Use a browser…
2. Compile the code and link it to your own app (PC or mobile)
3. Wrap the browser within an app (PC)
4. Use a webview (Android)

That last option? This is the closest one to an OS level integration of WebRTC. You assume it is there and available, and use it in your app somehow.

But what if we could miraculously get the WebRTC APIs (Javascript or whatever) from he operation system itself? No compilation needed. No Cordova plugins to muck around with. Just good ol’ “system calls”?

While I don’t really expect this to happen, here’s what we’d gain from having that:

1# Smaller app sizes

Not needing to get WebRTC on a device means your app takes up less space. With the average app size on the increase, this is always a good thing.

The OpenH264 codec implementation binary alone is around 300k, depending on the platform. Assume you need 3-4 more codecs (and that number will be growing every couple of years), the other media algorithms, all the network implementation, code to integrate with device drivers, WebRTC specific wrappers, … – lots and lots of size.

And less app size means more space for other app and less app data to send over the network when intsalling the app.

2# Less variability

While the first one is obvious, and somewhat nagging – so it takes a second more to install an app – who cares?

This point has a lot more of a reason for it.

If there’s a single implementation of WebRTC, maintained by the OS itself, there’s a lot less hassle of dealing with the variance.

When people port WebRTC on their own and use it – they make changes and tweaks. They convince themselves (with or without any real reason) that they must make that small fix in that piece of algorithm in WebRTC – after all, they know their use case best.

But now, it is there, so you make do with what you have. And that piece of code gets updated magically and improves with time – you need not upgrade it manually and re-integrate all the changes you’ve made to it.

Less variability here is better.

3# Shorter TTM

Since you don’t need to muck around with the work of porting and integration – it takes less time to implement.

I’ve been working with many vendors on how to get WebRTC to work in their use case. Oftentimes, that requires that nasty app to get a WebRTC implementation into it. There’s no straightforward solution to it. Yes – it is getting easier with every passing day, but it is still work that needs to be done and taken into account.

Back to reality

This isn’t going to happen anytime soon.

Unless… it already has to some extent and in some operating systems.

Chrome is an OS – not only Chrome OS but Chrome itself. It has WebRTC built in – in newer Android versions as well, where you can open up webviews with it.

For the rest, it is unlikely to be the path this technology will be taking.

 

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

The post 3 Advantages of WebRTC Embedded in the OS appeared first on BlogGeek.me.

Voxter - Building Value with Kazoo - KazooCon 2015 from 2600Hz

The Voxter team discuss code contributions to the Kazoo platform, discuss how they are utilizing the platform, and give an in-depth demo of WhApps

SIPLABS - Hard Rocking Kazoo - KazooCon 2015 from 2600Hz

Founder and CEO Mikhail Rodionov discusses all the projects and code contributions that they have built for Kazoo over the past year.

Telnexus - Quote to Cash – KazooCon 2015 from 2600Hz

Telnexus CEO Vernon Keenan discuss how he built the Managed Service Provider Telnexus from the ground up and the lessons he has learned in the process.

Least Cost Routing in the Cloud from 2600Hz

The ThinQ team discuss how to set up your routing profile, carrier selection, high volume traffic management, and LCR routing

VirtualPBX - Back Office, Delivering Voice in a Competitive Market - KazooCon 2015 from 2600Hz

In a competitive market, high quality voice services alone are rarely enough. Lon will speak about the customer lifecycle, back office systems from Sales to CRM to deployment, and how to drive profitable growth while delivering an excellent customer experience.

Something is brewing at Google.

Last week it was announced that Symphony just raised another $100M lead by Google. Not Google Ventures mind you – Google Inc.

Who is Symphony?

• High profile Silicon Valley startup (obviously), soon to become a unicorn, if it isn’t already
• Well known founder from the Unified Communications industry – David Gurle
• Have been around for only a year
• Already has over 100 employees, most of them engineers
• Focused on enterprise messaging, and targeting highly regulated and security sensitive industries

The Symphony Service

The service itself is targeted at the enterprise, but a free variant of it is available. I tried logging into it, to see what is all about. It is a variant of the usual messaging app on the desktop, with bits and pieces of Facebook and Slack.

On face value, not much different than many other services.

Symphony Foundation

Symphony decided to build its service on top of an open source platform of its own, which it calls Symphony Foundation. It includes all the relevant washed-out words required in a good marketing brochure, but little else for now: a mission statement, some set of values. That’s about it.

It will be open source, when the time comes. It will be licensed under the Apache license (permissive enough). And you can leave an inquiry on the site. In the name of openness… that’s as open as Apple’s FaceTime protocol is/was supposed to be. I’ll believe it when I see it.

Why Invest in Symphony?

This is the bigger question here. Both for why Google put money in it, as well as others.

With a total of $166M of investment in two rounds and over 100 employees recruited in its first year of existence, there seems to be a gold rush happening. One that is hard to explain.

As a glaring reminder – Whatsapp on acquisition day had 32 developers and around 50 employees. Symphony has twice that already, but no active user base to back it up.

It might be because of its high profile. After all, this is David Gurle we’re talking about. But then again, Talko has Ray Ozzie. But they only raised $4M in the past 3 years, and have less than 10 employees (if you believe LinkedIn).

The only other reason I can see is the niche they went for.

The financial industry deals with money, so it has money. It also has regulations and laws, making it a hard nut to crack. While most other players are focused on bringing consumer technology to the SMB, Symphony is trying to start from the top and trickle to the bottom with a solution.

The feature set they are putting in place, based on their website, include:

• Connectivity across organizations, while maintaining “organizational compliance”
• Security and privacy
• Policy control on the enterprise level
• Oh… and it’s a platform – with APIs – and developers and partners

The challenge will be keeping a simple interface while maintaining the complex feature set regulated industries need (especially ones that love customization and believe they are somehow special in how they work and communicate).

On Messaging and Regulation

The smartphone is now 8 years old, if you count it from the launch of the iPhone.

Much has changed in 8 years, and most of it is left unregulated still.

Messaging has moved from SMS to IP based messaging services like Whatsapp in many countries of the world. Businesses are trying to kill email with tools like Slack. We now face BYOD phenomena, where employees use whatever device and tools they see fit to get their work done – and enterprises find it hard to force them to use specific tools.

If Hillary Clinton can use her own private email server during the course of her workday, what should others say or do?

While regulation is slow to catch up, I think some believe the time is ripe for that to happen. And having a messaging system that is fit for duty in those industries that are sensitive today means being able to support future regulation in other/all industries later.

This trend might raise the urgency or the reason for the capital that Symphony has been able to attract.

Google

Why did Google invest here? Why not Google Ventures? It doesn’t look like an Alphabet investment but rather a Google one. And why invest and not acquire?

Google’s assets in messaging include today:

• Google Hangouts
• The recent acquisition of Jibe Mobile and their RCS chops
• The acquisition of Firebase, a messaging API platform that hasn’t changed much under Google as far as I can tell
• Gmail to some extent

Jibe/RCS is about consumer and an SMS replacement in the long run. It may be targeted at Apple. Or Facebook. Or Skype. Or all of them.

None of its current assets is making a huge impact. They aren’t dominant in their markets.

And messaging may be big in the consumer, but the money is in the enterprise – it can be connectivity to enterprises, ecommerce or pure service. Google is finding it difficult there as well.

Symphony is a different approach to the same problem. Targets the enterprise directly. Focusing on highly regulated customers. Putting money into it as an investment is a no-brainer, especially if it includes down the road rights of first refusal on an acquisition proposal for example. So Google sits and waits, sees what happens with this market, and decides how to continue.

Is this a part of a bigger picture? A bigger move of Google in the messaging space? Who knows? I still can’t figure out the motivation behind this one…

Messaging and me

I’ve been writing on general messaging topics on and off throughout the years on this blog.

It seems this space is becoming a lot more active recently.

Expect more articles here about this topic of messaging from various angles in the near future.

 

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

The post Google Goes All in for Messaging, Invests in Symphony appeared first on BlogGeek.me.

Hello, again. This past week in the FreeSWITCH master branch we had 51 commits! There were some very important changes this week to the Debian packaging system. The default is now set to build packages with the upstream FS package repos. Since the system dependencies have been removed from the FS codebase the 1.6 branch is now required to use the FS public repo for dependencies.  The notable feature for this week is the addition of the variable media_mix_inbound_outbound_codecs, which mixes inbound and outbound codecs, and this is a behavior change.

Join us on Wednesdays at 12:00 CT for some more FreeSWITCH fun! And head over to freeswitch.com to learn more about FreeSWITCH support.

New features that were added:

• FS-8290 [verto_communicator] Automatically mark dedicated encoder if out/in bandwith isn’t set to ‘Server default’
• FS-8290 [verto_communicator] Adding help text on how to enable dedicated remote encoder
• FS-8321 [core] Add variable media_mix_inbound_outbound_codecs to mix inbound and outbound codecs. BEHAVIOR CHANGE

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

• FS-8316 [build][Debian] Fixed new build warning from latest clang and resolved the build warnings in the modules too
• FS-8271 [Debian] Adding some logging, and more cautious handling of spaces in parameters. Now the default will build packages with the upstream FS package repos. This is a change in the default behavior of the Debian packaging system with the justification that in 1.6 it is now required to use the FS public repo for dependencies because system dependencies have been removed from the FS codebase which used to be included. And defaulting to automatically download the binary dependencies because without major changes to package building in cowbuilder(which is the primary supported method of building FS packages), you can’t access the network to build the binary packages from the source package. If using system apt repo list, then include the supplementary ones too
• FS-8233 [automation] In order to clean up build dependencies for the automated tests, convert the tests/*/Makefile.am into an include file for the top level Makefile.am. This will greatly simplify dependency tracking, and allow tests to be rerun easily on FS source code changes.
• FS-7820 [automation] Use a more appropriate function for printing diagnostics

The following bugs were squashed:

• FS-8243 [mod_opus] Adding back the missing part removed in 8b088c2 so FEC works in most surroundings
• FS-8295 [mod_opus] FMTP fixes to continue the cleanup of FEC
• FS-8302 [mod_opus] Fix some printing/logging because switch_opus_show_audio_bandwidth() was not returning TRUE/FALSE as expected
• FS-8130 FS-8305 [mod_opus] Fix some warnings and errors caused by dtx and/or jittery webrtc, refactor of last patch, and add suppression of scary harmless message about opus FEC
• FS-8296 [mod_opus] Improve the way Opus is initialized when a call comes in
• FS-8179 [mod_opus] Fixed a regression setting fec_decode breaking output on stereo calls
• FS-8297 [mod_conference] A fix for auto STUN switching IPs quickly and WebRTC video not working
• FS-8130 [mod_conference] Fix for micro cut-offs and unstable voice issues
• FS-8317 [mod_conference] Fix for playing multiple files at once to stack them for immediate playback, sometimes breaking and the floor layer becoming unusable for the rest of the conference.
• FS-8067 [verto_communicator] When no email is present make sure mm is the default avatar in the circle this way the talk indicator works on PSTN and SIP callers.
• FS-8247 [verto_communicator] When websocket disconnects go to splash screen to wait for the reconnect
• FS-8300 [verto_communicator] Fixing reload bug so reloading twice is no longer needed
• FS-8315 [core] Fix for rtp_media_timeout not working
• FS-8304 [core] Fix for choppy audio during calls
• FS-8320 [core] Fixed broken ZRTP not responding to HELLO packet
• FS-8311 [mod_voicemail] Fix for leave-message event not containing verbose data for a forwarded voicemail
• FS-8318 [mod_av] Fix for recording being out of sync when video from chrome has packet loss
• FS-7929 [mod_sofia] Fixed an issue when processing SIP messages while using camp-on
• FS-6833 [mod_sofia] Add content-type header to ack with sdp

 

And, this past week in the FreeSWITCH 1.4 branch we had 3 new commits merged in from master. And the FreeSWITCH 1.4.23 release is here! Go check it out!

The following bugs were squashed:

• FS-8246 [mod_json_cdr] Use seconds as default value for delay parameter
• FS-8282 [core] Fix for sleep is not allowing interruption by uuid_transfer
• FS-8166 [core] Mute/unmute while shout is playing audio fails because the channel “has a media bug, hard mute not allowed”