Forem: Dolby.io

Top Reasons for Updating to the New OBS 30.0 Release

Jayson DeLancey — Tue, 10 Oct 2023 23:30:00 +0000

Open Broadcast Software (OBS) Studio has released 30.0.0 as a public release candidate with some new updates to the long popular streaming and recording tool. You may be wondering if it is worth downloading the latest version right away so I've highlighted a few of the more note-worthy updates that impact my broadcast workflows. Specifically, including support for WHIP opens up a whole range of new opportunities.

1 - Support for WHIP Outputs from OBS

WebRTC-HTTP Ingestion Protocol (WHIP) is an IETF standard protocol for streaming media ingress that was championed by the Millicast team (now part of Dolby.io). WebRTC has been used for many applications including real-time communications, server-rendered gaming, etc. where a protocol supporting use cases where ultra-low latency is prioritized over packet loss. You can find more background and learn more about WHIP from other posts, but some examples of where this has an impact right away:

Secure streaming services such as Dolby.io support WHIP for setting up protected private broadcasts for real-time applications like sports, betting, gaming, competitions, remote production, etc.
Some public commercial streaming services offer support for WHIP to enable streaming to audiences without sacrificing latency in delivering audio/video while lagging behind text chat and other messaging services.

For the access that WHIP provides alone is enough to justify an upgrade.

Here's an example using WHIP with the hosted player.

Learn more about why OBS Studio Adding Native WebRTC Streaming with WHIP is important for interactive streaming experiences.

2 - Status Bar Changes in OBS 30.0

The status bar has had a design refresh. The information is the same but structured a bit differently with some visual icons to help with identification of the stream health.

By comparison, the status bar from OBS 29:

You may also notice that encoders and capture screens are now sorted by name to make it easier to find devices in a predictable order. If you often share a screen or an application in your workflows this can prevent some fumbling around while live.

These changes offer some nice usability improvements.

3 - MacOS Compatibility Improvements

If your primary workstation for running OBS is a Mac, there are some substantial improvements.

The virtual camera is more widely compatible with other applications. If your primary use case with OBS is to add special effects and filters to regular conference tools, this can give your system some much needed reliability when switching from one application to another.

There is also audio capture fix and option to hide OBS windows from screen captures.

4 - Safe Mode for Complex Integrations

If you use third-party plugins, custom scripts, etc. then you've probably had to scrap a broadcast or two while debugging a problem. The ability to launch in a "Safe Mode" is added so that you can disable loading and investigate the root cause of the issue.

Download and Install OBS 30.0

There are lots of other fixes and details called out in the release notes that may be valuable for some, but those are a few of the top updates for my workflows.

You can find the latest release available for download from obsproject.com. You can also find preview version from the obsproject/obs-studio github release history.

A huge thanks and shoutout to all the contributors who made this release possible. If you have time and/or money consider contributing to their Patreon or Open Issues this Hacktober.

Interactive Live Streaming Through Virtual Cameras on Unity

Angelik Laboy — Fri, 04 Aug 2023 01:32:54 +0000

When it comes to the world of streaming, we have become accustomed to its widespread use, with various technologies striving for lower latency and faster integration. Amidst these advancements, one aspect remains to be tackled: interactivity.

I mean, look at Netflix's Black Mirror: Bandersnatch or Kaleidoscope, all part of their endeavor to immerse audiences in the stories, becoming an integral part of the narrative. And if you observe closely, that is where we get the key to interactivity: the integration. We have come so far in entertainment that we desire to belong to the stories in order to live the adventures of our favorite characters. Wouldn't it be cool to be in the kitchen with Carmy and Sdyney from The Bear? Or to be one of the fans cheering for AFC Richmond in Ted Lasso?

I would personally want to do that too but the challenge so far has been the immersion part. We haven't really been able to dissociate from life to believe we are actually in those stories. As of today (August 3, 2023), the stage is still being set for this new era of interactive streaming. By now, the XR community is ready to fire back saying their insert X product is doing it, and I genuinely believe they have the potential to deliver on this promise.

For example, at the 2021 Annecy International Animation Film Festival, "On The Morning You Wake (To The End Of The World)" was shown as an official selection which recounts the experiences of a few Hawaiians who received an SMS from the state's Emergency Management Agency about a missile threat. This documentary displayed a turbulent situation where everything is an unceasing chaos and instead gave us a reflective look about the fragility of life. On the visuals, its pointillism technique enhanced the sentiment of this experience being shared by not only one, but thousands of citizens at the same time.

Ultimately, one gets to feel like a part of the story.

Now, this experience is exclusively being offered through Meta's Quest lineup, but what if there was a way to experience another one's perspective on a headset like that? What if there was a way to allow us, the audience, to control how we want to watch the film?

Live Stream from Unity

I have talked your ear off about interactivity and being the main protagonist. Now, lets talk about the tech. Working within Dolby I have gotten the chance to experiment with our virtual world's plugins. As part of Dolby.io, the Unity/Unreal plugins offer the exciting capability to stream content from inside the engines. Whether it's viewing the 3rd person POV of the main character or streaming from a static virtual camera, the plugin introduces a groundbreaking way to actualize experiences in this space.

In this post, I aim to demonstrate how you can set up multiple cameras inside the engine and display them all through a single stream using a multi-view configuration.

Installing the Unity Plugin

To start, I will be using the Bitsize Samples from Unity - Client Driven for a multiplayer game where users pick up orbs and deposit them in their designated colors. With a fully actualized world, our focus can now shift to enhancing the cinematics.

To get started, follow these steps:

Open the project through Unity Hub.
Go to Windows > Package Manager.
In the Package Manager window, change the view to show only the "In-Project" packages.
To the left of it, click on the "+" icon, and select the option to Add package from git URL....
Insert the following URL into the space:

https://github.com/millicast/millicast-unity-sdk.git

The installed package should read out Millicast v 1.1.0.

Establishing Credentials and Stream Settings

Before starting with the stream, we will need to do one more thing. On Assets, create a new folder and title it “Credentials”. Once inside, right-click and navigate to Create > Millicast > Credentials. By completing this step, you'll set up credentials once and associate them with the plugin's components, eliminating the need to rewrite them for each instance.

The next step will require connecting your Dolby.io credentials so lets check that off. Go to Dolby.io and receive 50GBs each month for free to get started with a few examples. Once you're inside the Dolby.io Dashboard, ensure that the Streaming tab is selected on the top left. Here is where stream tokens would be created to enable a broadcast; press on the "+ Create" button and name the token label as desired. For Add stream names, click on the Allow any stream name. The reason why this option is selected is to center all of the cameras to be under the same stream token.

With the token made, navigate inside settings and view the API tab to collect your Account ID and Publishing Token.

In the same way Credentials was created, two other assets can be added: Video Configuration and Audio Configuration. The first one would have you control the codec, resolution, framerate, and many more while the audio asset is there to control the distance in which the sound would be emitted as well as the volume of the stream. Customize the settings to your choosing!

Publisher: How You Can Stream Out

Now, let's get started! In your Playground, begin by creating an empty GameObject and name it "Production." Within "Production," we will craft four different cameras, each serving a unique purpose. Position these cameras strategically throughout the environment, ensuring they capture crucial action points that the audience would want to witness. Think of these cameras as virtual security cameras, recording the exciting moments at the scoring platforms.

By incorporating a variety of camera perspectives, you'll create an immersive experience for the audience, drawing them deeper into the virtual world and enhancing their enjoyment of the content.

With those set, visit the first camera's inspector view and click Add component. Next, search Mc Publisher; this is a component from Dolby.io that will allow for the game to be streamed out. The first information we need to give is a Stream Name. Since the stream token was created as a wild card, any name can be used. However, if the stream token was specifically named, return to the streaming dashboard to find the token’s API information, where you will see the Stream Name (e.g., “leqgbgh9”). In the Credentials space, drag and drop the asset containing all the necessary information (previously named Credentials). Do the same in the space asking for the Video Config Data, providing the required video configuration asset.

Check off the Publish On Start to link the Start button on the engine to starting the stream on Dolby.io. For Stream Type, there are three options: Video + Audio, Video Only, or Audio Only. As the options read, this is the field to select how you would like your stream to be shown.

For the next two settings, Video Source Type and Video Source Camera, simply select "Camera" and the name of the specific camera where this component is added. This space allows you to control the stream without directly adding the component to the camera itself. For example, if you prefer to manage all four cameras from a single GameObject, that is also a viable option.

Next, you will notice that it asks to use the Audio Listener of the camera. Selecting this option will have the audio transmitted be from the camera’s perspective.

Note: Make sure the Audio Listener component is check on to in order to allow any audio transmission.

Lastly, it is asking whether to Enable Multi Source and we will apply this option. Multisource is the feature that allows a single stream (WebRTC or RTMP) to support broadcasting multiple video and audio feeds. Once rendered these streams can be switched between, offering the viewer the ability to control how they view and listen to the content. Upon selecting this option, a new field called Source Id will appear. The sourceID represents the ID of a device that you want to use. If you use multiple screens, use this parameter to specify which screen we are viewing from. For simplicity sake, I am going to name the first camera "camOne".

Follow this procedure for the next three cameras: keep the Stream Name the same for all, change the Video Source Camera to the current camera with the component, and use the sourceId as the next incrementing label, e.g., "camTwo," "camThree," "camFour."

BONUS:

This bitsize sample already has a camera following the mainPlayer. If you wish to stream this perspective, follow the same steps for the mainCamera object. The only difference is that you do not need to mark Enable Multi-Source in this case. When no specific sourceId is labeled, and the video is going into the same stream, it will be identified as the main source by default.

Viewing the Multi-View

With the Mc Publishers finished, let us verify our work. On the engine’s centered buttons, press Start to commence the experience. Congrats, your game has started streaming! But where is it being streamed out to?

Let’s pay back a visit to the token’s API information. On the Playback tab, the hosted player path URL will be present. This URL is the link needed to view the livestream going on. In the URL, you will be asked to write in YourPublishName, which is the stream name of your token. If you decided to add the secure viewer, it would also ask for your subscribe token information.

https://viewer.millicast.com?streamId=accountID/McPublisherStreamName

Voilà, your streaming is up and running!

You might notice that it is only showing the mainCamera's view and not the other four camera set up. Go to the gear icon on the bottom right and click on Show Multi View. This will activate the layout on the web viewer. Now you can click around the screen to the different camera to change the focus on who is the first one exhibited. Equally, if all feeds are important then on the gear icon is also the option to change layout.

Final Thoughts

We have just accomplished a stream from inside an engine. What now? The idea of presenting a streaming solution for XR experience can mean a lot of different things. Not only is it an accessibility bonus for your product for which users who can't use a headset can have a chance at viewing the experience. Keyly, it makes us think of what can be done with more dimensions now added to these experience. Streaming XR experiences can allow audiences to actively participate in virtual worlds, creating a deeper level of engagement and immersion. This interactivity lets users control their actions and decisions within the XR environment, leading to a more personalized and captivating experience. The enablement of XR streaming invites real-time participation in events, performances, and social gatherings. For example, esports viewers can now be more close to the action by giving them the chance to see where they desire. This personalization allows users to shape the storyline, outcomes, and interactions, tailoring the experience to their liking. As a result, users feel more invested in the content and are more likely to return for further engagement. Not to mention, it can foster a sense of community and social interaction even when physically distant.

All I am saying is that... you should watch out for this field.

How-to Broadcast a WebRTC stream to Twitch

Braden Riggs — Tue, 01 Aug 2023 16:03:31 +0000

Recently, while exploring syndicating Dolby.io WebRTC streams, I learned that Twitch has added support for WebRTC Ingest or WHIP as it is known in the industry.

WebRTC for streaming is an exciting choice because it can decrease stream latency compared to traditional protocols such as RTMP and HLS. When ingested, Twitch will transmux the WebRTC stream into something the platform supports (HLS), so that adds latency, slowing down the feed.

With that said, WHIP support is a great step for the community and with OBS now adding support for WebRTC, I thought I'd have to try it out.

In this guide, we'll showcase how to stream WebRTC from OBS into Twitch.

Setting up OBS for WebRTC

The core OBS project is working to add WebRTC, however, at the moment it is still an experimental build. You can try out this build by downloading the version relevant to your system here.

Once downloaded, extract the project and install it.

Streaming WebRTC from OBS to Twitch

With the project installed and launched, navigate to:
Settings -> Stream

Inside of Stream select WHIP as your service:

To start a WebRTC stream to Twitch you need the Server path and your Stream key.

The Twitch WHIP server

The server is (currently) the same for everyone:
https://g.webrtc.live-video.net:4443/v2/offer

Note: This server currently only supports H264 and Opus encoded streams.

Getting Your Twitch Stream Key

Your Twitch Stream Key can be found on your dashboard once you've logged in, under:
settings -> stream

Copy both the Server URL and the Stream Key into the Server and Bearer Token inputs within OBS.

Click Apply, set up OBS as usual, and click Start Stream to begin your WebRTC broadcast to Twitch.

Learn More

Broadcasting a WebRTC stream to Twitch is an great feature for the site as it allows people to easily syndicate their WebRTC streams to a popular platform. Because Twitch transmuxes the WebRTC stream, some delay is added, so if you're looking for an end-to-end white-label real-time streaming solution, check out Dolby.io Real-time Streaming.

A special shout out to Sean DuBois for his work on both the OBS project and on Twitch's WHIP support.

What is WHEP? – Intro to WebRTC Streaming Part 2

Griffin — Mon, 01 May 2023 18:51:30 +0000

In the previous article, we discussed WebRTC and the new standard developed to help us ingest data with it, known as WHIP. However, for data that is ingested, that same data will likely need to be egressed, or distributed at some point. Bring in WebRTC-HTTP egress protocol, or WHEP. Abstractly, the ingestion is the part that covers the uploading of data to a server, and the egress handles the downloading to an end user. The benefits we gained from WHIP, such as the low latency and end-to-end encryption apply here as well: WHEP enables WebRTC communication on the other end of the content delivery pipeline; WHEP assists with serving content to the viewer.

In this post, we will take a look at WHEP, an IETF protocol developed to let us use WebRTC to egress content to other destinations as a way to modernize content delivery over the web from previous standards.

Why is WHEP useful?

As mentioned above, WHIP only solves half of the equation when working with WebRTC-based content delivery. While you could read the official IETF documentation, we will summarize it more simply here. WHEP aims to solve the distribution aspect of WebRTC-based content, See the below diagram for a visual aid of how this works together using Dolby.io Real Time Streaming APIs as an example:

The benefit of having WHEP supplement the egress of broadcast WebRTC infrastructure is similar to the benefits of WHIP, namely the standardization. The same way WHIP allows broadcasters to focus on their infrastructure and the scaling of it without needing to worry about logistics, WHEP allows the distributors to focus on end-user experience, as they know exactly how the data will be received and handled. The end goal is optimization of time and resources across all parties with standardization.

WHIP and WHEP do for real-time video what RTMP did for flash video or what SRT does for transport streams. It standardizes the way (protocol) that the media servers speak to each other, like a language, so that any WHIP encoder can talk to any WHIP server and any WHEP service can talk to any WHEP player, without any other setup. Using the WHIP/WHEP URL should simply work no matter which environment is being used.

There are many situations where a standard protocol for streaming media consumption over WebRTC would be helpful. Some options or examples include:

Interoperability between WebRTC services, media servers, publishers, and players
Playing WebRTC streams on TVs and other smart devices that do not support custom JavaScript scripts
Creating modular, reusable software for media players
Integrating with DASH, a current popular standard for adaptive bitrate streaming

Where it differs from just being “the WHIP spec but in reverse” is in the specifics of the protocol. While for the most part it does behave the same as WHIP, using HTTP requests with Bearer Tokens for authentication, it is more flexible with SDP communication. WHEP allows for an SDP offer to be delivered immediately in the same HTTP request, or to send a POST request with intent to receive an offer back. This offers more flexibility depending on use case and environment, which can be learned more about in the white paper provided above. RTSP, an older standard used in the industry, does not support this model for example.

Dolby.io + WHEP

Dolby.io is a leader in the definition and research of WHEP, which is an open standard. Like WHIP, our researchers have developed this standard, offer support for it into our Streaming Platform, and are working directly with software and hardware partners to integrate WHEP directly into their ecosystems. To learn more, see this Kranky Geek recording of Dolby.io Senior Director of Engineering Sergio Garcia Murillo, the head researcher working on developing WHIP and WHEP:

https://youtu.be/rIQVVJOjR0U

We believe WHEP is the future of WebRTC egress, and we want to support the community and projects around it. WHEP is only useful if it gains wide adoption. We encourage you to try out WHEP for your next streaming project and let us know your experience. One way to do this is with our sample app using Node, our sample using Video.js, or using another community implementation such as this one by Lorenzo Miniero. We’d love to hear your thoughts on our Twitter or LinkedIn.

What is WHIP? Intro to WebRTC Streaming Part 1

Griffin — Thu, 20 Apr 2023 18:03:23 +0000

When considering which tool to use for your real-time streaming platform, WebRTC is one of the hot concepts brought into the forefront. While WebRTC has been around since 2011 and has since been successful at being used in many scenarios, optimizing WebRTC for live generated content, such as in the broadcasting industry, as opposed to pre-existing files is where things get more complex. WHIP and WHEP are two new standards designed to assist in ingesting and egressing this media into WebRTC instead of having to rely on using older standards like RTMP to do that.

In this post, we will focus on WHIP, or WebRTC-HTTP ingestion protocol, an IETF protocol developed to let us use WebRTC to ingest content into our platforms over these old protocols.

Why WHIP?

For those of you who are overwhelmed with the official IETF document, WHIP (sometimes known as WISH) is an open standard that you can use right now for your WebRTC based ingestion. You can use it today with open source software such as GStreamer or OBS (fork) as a way to publish your content with WebRTC.

A benefit to using WebRTC based content is it’s extremely low latency and security with end-to-end encryption. However, initial versions of WebRTC based streaming were associated with poor quality and limited viewer numbers. WHIP solves this by removing the translation layers needed to use WebRTC before that cause many of the previously mentioned flaws, giving us all of the benefits of WebRTC without the downsides. WHIP provides a standard signaling protocol for WebRTC to make it easy to support and integrate into software and hardware.

WHIP provides support for important standards, such as HTTP POST based requests for SDP O/A, HTTP redirections for load balancing, and authentication and authorization done by the Auth HTTP header and Bearer Tokens.

Think of this like a train station. Without any rail signalers, the trains will behave sporadically, causing potential slowdowns if too many trains are on the same track, tracks that are unused, and possible crashes and collisions. With a signaler, the trains will be directed more orderly, optimizing the system to keep things moving quickly and efficiently. WHIP acts as this signaler, handling things like creating or deleting endpoints if needed and performing operations like Trickle ICE.

How Does Dolby.io fit in?
As mentioned before, WHIP is an open standard. Dolby.io supports WHIP not only by providing integrations, but also by leading the definition and research into the standard. Our researchers have developed this standard, and our engineers have implemented it into our Streaming Platform, as well as having worked directly with software and hardware partners to integrate this standard directly into their platforms, such as FlowCaster and Osprey for both software and hardware encoding.

We believe WHIP is the future of WebRTC ingestion, and we want to support the development and community around it. As a standard is nothing without wide adoption. We encourage you to try our WHIP today with one of the priorly mentioned integrations for your next streaming project and let us know your experience. We’d love to hear your thoughts on our Twitter or LinkedIn. Or try out our sample app using Node, and leave some feedback on GitHub.

Stay tuned for Part 2 where we will talk about the other end of the process, WHEP, or WebRTC-HTTP egress protocol, and see how WebRTC will define the future of all streaming and broadcasting communications.

A Low-Latency Live Stream React App

Braden Riggs — Mon, 03 Apr 2023 18:36:01 +0000

Original Article Published Here

When building a streaming app or platform it is important to consider how the end user experiences and engages with the content being streamed. If your users need to engage with the content creator, the delay between capture and consumption should be minimal. To achieve this, many developers rely on WebRTC, a content-over-internet transfer protocol that boasts exceptionally low delays for video and audio. By leveraging WebRTC, developers can quickly build a low-delay immersive experience, leaving plenty of time to make the UI look outstanding using front-end libraries such as ReactJS.

In this guide, we're going to showcase a WebRTC ReactJS streaming app powered by Dolby.io Streaming and NodeJS.

The WebRTC React Example Code

The WebRTC React Streaming example app can be found on the dolbyio-samples GitHub.

To set up the project you need four things:

A cloned copy of the sample app.
Node v16 or greater installed.
Yarn package manager v1.22.19 or greater installed.
A Dolby.io account.

Once you've cloned the repo and set up the Node and Yarn, navigate to the main directory via the terminal and run the following command to install all dependencies:

yarn

While your project is installing we can briefly discuss how to set up your Dolby.io account. Once you've created an account you'll be dropped off on the Dolby.io Dashboard where you can create and manage tokens required for leveraging Dolby.io Streaming servers.

Click the purple and white + Create button to create a new token. Give the token a label and your stream name a unique identifier, then switch to the Advanced tab to enable "Multisource" as shown in the image below:

Enabling Multisource allows you to leverage Dolby.io Streaming to capture and deliver multiple low-delay streams at once. With your Token created, we can now click on the newly created token and gather your stream name, stream account id, and stream publishing token as shown in the image below:

Now that we have all the credentials required to connect to the Dolby.io servers, let's update the project credentials. To do this we need to edit the .env.example, which can be found inside of apps/publisher/ and apps/viewer/, by renaming the file to .env and populating the file with the respective credentials.

Additionally inside of the apps/publisher/.env.example there is a parameter to adjust the viewer URL. For testing locally this can be set to a local host URL, however, in production, this should be a web-accessible endpoint.

VITE_RTS_VIEWER_BASE_URL=http://localhost:7070/

With all the credentials set up, we can now run the React streaming app. The app can be split into two functions, a publisher and a viewer. The publisher app, which is what a content creator would use, serves content to the end user who participates via the viewer app.

To start the publisher app experience:

yarn nx serve publisher

To start the viewer app experience:

yarn nx serve viewer

With both the viewer and the publisher running we now have a live streaming app with Node.js and React powered by Dolby.io WebRTC Streaming. This experience can be deployed on a cloud service such as Netlify to share publicly, just remember to add your branding and styling.

Building your own React WebRTC streaming app

With your Dolby.io account already created, building your own bespoke viewer and publisher experience is easy. Dolby.io Streaming has a React Native SDK allowing developers to quickly and easily build a streaming solution. If you are interested in learning more about Dolby.io Streaming check out some of our other blogs including building a Multiview web app or about our Dolby.io Streaming OBS integration.

Feedback or Questions? Reach out to the team on Twitter, LinkedIn, or via our support desk.

5 Different ways to Broadcast SRT Streams

Braden Riggs — Mon, 09 Jan 2023 19:16:36 +0000

Originally published here

SRT, or Secure Reliable Transport, is a type of streaming protocol that provides enhanced security and reliability for video streaming. SRT is becoming increasingly popular among broadcasters and streamers including industry stalwarts such as ESPN because of its ability to deliver high-quality content over challenging network conditions and for its ability to make contribution and stream ingestion easy. SRT streams provide improved security, low latency, and flexibility and is supported by a global community of developers all contributing to the open-source project. Because of the power of SRT streams, Dolby.io Real-Time Streaming has decided to launch support with an SRT open beta program.

In this guide, we'll cover a few different ways you can start broadcasting SRT streams with Dolby.io such as OBS, vMix and many more:

Streaming SRT with OBS
Streaming SRT with vMix
Streaming SRT with your iPhone
Streaming SRT with Avid Media Composer
Streaming SRT Directly from an Osprey Talon Encoder

Streaming SRT with OBS

For readers familiar with the Dolby.io platform you might know about our custom forked version of OBS designed to stream WebRTC natively. Although you can use our WebRTC-enabled OBS fork, you can actually publish SRT streams to the Dolby.io servers from the original OBS project. To do this you must have an active Dolby.io account, which you can create for free and the latest version of OBS installed on your system. To start publishing SRT streams with OBS follow the steps below:

1. Login or create a Dolby.io account and download OBS.

2. Navigate to your Dolby.io streaming dashboard and create a new token. You can leave all the token settings to default.

3. Open the API tab on your newly created token dashboard and navigate to the bottom where you'll see the SRT publish path, the SRT stream ID, and the SRT publish URL. Copy SRT publish URL.

The Dolby.io Streaming Token API tab. Highlighted box indicates the SRT publish URL used in OBS.

4. Open OBS and navigate to settings, then the Stream tab.

5. Inside of the Stream tab, set Service to Custom and Server to the SRT publish URL.

OBS stream settings page. Remember to set Service to "Custom" and Server to "Your SRT Publish URL".

6. Apply the changes and exit settings. You are now all set up to stream with OBS. When publishing, your SRT stream will be delivered to the Dolby.io Streaming Viewer, which can be found at the Hosted Player Path.

The Dolby.io Streaming Token API tab, with hosted player path highlighted. Opening this path in a browser will launch the stream.

Although the hosted player path is a great way to view the stream, you can use the Dolby.io Streaming JavaScript SDK to build a bespoke solution.

Note: If you are using the NVIDIA NVENC H.264 encoder that comes included with OBS you must set Max B-Frames to 0. This setting can be found in Output, then Advanced Output Mode, then the Streaming tab, where Encoder is set to NVIDIA NVENC H.264 and then Max B-frames is set to 0.

If you are using the NVIDIA NVENC H.264 encoder that comes included with OBS you must set Max B-Frames to 0. This setting can be found in Output, then Advanced Output Mode, then the Streaming tab, where Encoder is set to NVIDIA NVENC H.264 and then Max B-frames is set to 0.

Streaming SRT with vMix

vMix is a paid windows-only remote production tool used for vision mixing. It allows users to juggle input and outputs for live broadcasts and productions and includes support for publishing SRT streams. To publish an SRT stream with vMix follow the steps below:

1. Login or create a Dolby.io account.

2. Download and open vMix.

3. Navigate to your Dolby.io streaming dashboard and create a new token. You can leave all the token settings to default.

4. Open the API tab on your newly created token dashboard and navigate to the bottom where you'll see the SRT publish path, SRT stream ID, and the SRT publish URL. Copy the SRT publish path and the SRT stream ID.

5. Inside of vMix open settings and switch to Output / NDI / SRT.

The vMix mixing stage. Navigate to "Settings" and click on "Outputs / NDI / SRT" to open up the SRT settings menu.

6. Once you've switched to Output / NDI / SRT open the gear icon next to an output source.

Inside the SRT settings, select the gear icon highlighted in red.

7. Inside the output settings enable SRT, set the Hostname to the Dolby.io Millicast endpoint and the Port to the appropriate port (typically 10,000). Additionally, include the Stream ID and make sure the Quality settings match the limitations of Dolby.io SRT streaming.

When creating the SRT stream define Hostname, port, Stream ID, and Quality.

8. Press OK and exit settings. You are now all set up to stream with vMix. When streaming, your SRT stream will be delivered to the Dolby.io Streaming Viewer, which can be found at the Hosted Player Path.

The Dolby.io Streaming Token API tab, with hosted player path highlighted. Opening this path in a browser will launch the stream.

Although the hosted player path is a great way to view the stream, you can use the Dolby.io Streaming JavaScript SDK to build out a bespoke solution.

Streaming SRT with your iPhone

Softvelum's Larix Broadcaster is a tool available for iOS, Android, and React Native that allows you to push SRT streams directly from your mobile device. To set up a Larix SRT stream on an iOS device:

1. Login or create a Dolby.io account.

2. Download the Larix Broadcaster from the App Store.

3. Navigate to your Dolby.io streaming dashboard and create a new token. You can leave all the token settings to default.

4. Open the API tab on your newly created token dashboard and navigate to the bottom where you'll see the SRT publish path, the SRT stream ID, and the SRT publish URL. Copy the SRT publish path and the SRT stream ID.

5. Open the Larix Broadcaster and then Settings. From Settings, go to Connections and add a new connection.

Create a new connection with the plus icon in the top right corner.

6. Inside the connection, set the URL parameter to your Dolby.io Real-Time Streaming SRT publish path and set streamid to your SRT stream ID.

When adding a new connection in the Larix Broadcaster make sure to assign "streamid" and "URL".

7. From here you can exit your settings and start the stream by pressing the record button on the broadcaster.

Press the record button on the left to start an SRT stream.

8. Like the OBS and vMix examples, your SRT stream will be delivered to the Dolby.io Streaming Viewer, which can be found at the Hosted Player Path.

The Dolby.io Streaming Token API tab, with hosted player path highlighted. Opening this path in a browser will launch the stream.

Dolby.io Real-time Streaming supports a number of SDKs for creating viewer apps including a Flutter 3 SDK for creating viewer apps for Android, iOS, and Web.

Streaming SRT directly from an Osprey Talon Encoder

OBS, vMix, and Larix Broadcaster are examples of software tools that you can leverage for streaming SRT into the Dolby.io Streaming service, but what about hardware options? Depending on the scale of live production you might have access to cameras with built-in encoders that can directly egress SRT, which we can also connect to the servers. For cameras that don't have built-in encoders, you can connect the camera to an external encoder, some of which support SRT. One example of this is the Osprey Talon 4K-SC, which is not only the first WHIP encoder but can also encode SRT streams that we can connect to the Dolby.io servers.

1. Login or create a Dolby.io account.

2. Connect your Osprey Encoder to your camera and power it up.

3. Download the Osprey BOSS PRO application, which will allow you to discover the encoder on your local network. Alternatively, follow this in-depth guide by the Osprey team for setting up your encoder.

4. Click on the appropriate encoder, launch the web interface and sign in. Information regarding signing into Osprey equipment can be found here. Once signed in you will now be in the Osprey Dashboard.

5. Navigate to your Dolby.io streaming dashboard and create a new token. You can leave all the token settings to default.

6. Open the API tab on your newly created token dashboard and navigate to the bottom where you'll see the SRT publish path, the SRT stream ID, and the SRT publish URL. Copy the SRT publish path and the SRT stream ID.

The Dolby.io Streaming Token API tab. Highlighted box indicates the SRT publish URL used in OBS.

7. Inside the Osprey Dashboard, set SRT Dest Address to the SRT publish path excluding the port. Set SRT Port to the port number at the end of your SRT publish path (usually 10000) and set SRT Stream ID to your SRT Stream ID.

Set the SRT Dest Address to the SRT publish path, and SRT Port to 10000, and the SRT Stream ID to your Dolby.io Streaming Token Stream ID.

8. From here press start and the encoder will begin streaming content through the Dolby.io servers.

Limitations of Publishing SRT Streams to Dolby.io

Streaming SRT is just one part of the equation, Dolby.io Real-time Streaming also supports a number of SDKs for building streaming into your platforms and apps. If you are interested in learning more about how to use our SDKs check out our blog and let us know what you're building next.\
Feedback or Questions? Reach out to the team on Twitter, LinkedIn, or via our support desk.

Automating Your Stream Start, Intro, and Ending Processes with OBS Macros

Griffin — Wed, 16 Nov 2022 22:04:39 +0000

As you begin developing a brand and a streaming presence, it is often desirable to define and establish your branding with digital assets that are used at the beginning and ends of each of your stream. Often times we see this as an intro video that will broadcast to your audience that your stream is beginning, giving them time to settle in and get excited for the show, whether it be an auction, sports broadcast, gaming event, or something else. While entirely possible to do this manually every time, it can add to the growing complexity of tasks to do when beginning your broadcast. Sometimes you might even forget to play the video at all, human error and all. In this article, we will showcase a few different ways we can automate the media playback to occur whenever you begin your stream, taking an extra step away so you can focus on the broadcast while keeping your brand intact.

Starting Stream

Before thinking about what the intro video is going to look like, first think about what the very beginning of a stream looks like. Most viewers who show up early will see a “Broadcast is not Live” page by default, which isn’t ideal. We want to ensure that users know that you are about to go live soon to keep them on the page instead of closing the window. Though if we start too early, not enough users will be around to see the intro video in the first place, both losing brand awareness, and letting people feel like they missed out. The solution to this is to still start the stream ahead of schedule, but with a static image or video that simply lets the audience know that stream is starting soon.

We can automate the process of beginning this video with an OBS plugin called Advanced Scene Switcher. Once downloaded and installed with the appropriate installer for your system, this plugin will create a new option on the “Tools” menu of OBS with the same name.

Note: If you are experiencing issues seeing this plugin in the Tools menu, ensure you are not installing OBS from Homebrew on MacOS or similar package managers, but from the official install site. We have experienced issues with the package managed versions.

Adding Advanced Scene Switcher to OBS-WebRTC

For use with Dolby.io Streaming, we will want to add the plugin to our installation of OBS-WebRTC. Thankfully, the plugin is compatible, however the installer will only look for OBS-Studio. To add the plugin manually to OBS-WebRTC, do as follows:

MacOS:

In ~/Library/Application Support/obs-studio there will be a folder titled “plugins”

Copy this folder with the installed plugin(s) and paste it into ~/Library/Application Support/obs-webrtc. Restart OBS-WebRTC and it should appear as normal.

Windows:

Follow the above instructions, but replacing the MacOS path with the Windows path for plugins:

C:\Program Files\OBS-Studio\obs-plugins\64bit

C:\Program Files\OBS-WebRTC\obs-plugins\64bit

Using Advanced Scene Switcher

Upon opening Advanced Scene Switcher, we should see a few options. The most important of which is determining if it is on. You can customize how you want OBS to auto-start the plugin, though ensure that the status is Active before using it.

Then, switch to the “Macro” tab.

Here we can begin adding macros for our stream to automate multiple different actions. Let’s begin with the “Stream is about to begin” automation.

Starting the Stream

Inside the Macro tab, we have a few different panels to work with. To begin, lets add a new macro by clicking the “+” under the left “Macros” panel and name it what you want. In this case, I named it “Starting stream”

Now, under the “Edit macro” panel, we have two sections, the macro conditions on top and the macro actions on the bottom. First, lets click the “+” under macro conditions to create a new condition. This will then generate a conditional statement builder for us to define what will begin our macro. In this case, we want it to read “If Streaming Stream starting”. This will trigger the macro whenever we start the stream.

Next, we want to create a new macro action by clicking the “+” under the bottom panel. There are a couple of things we want to do here, the first of which being to switch to our Starting stream scene. This can be one with an action with the following information: Switch scene → Switch to scene using “Cut”, which will automatically set the stream to that scene upon starting the broadcast.

If you haven’t already yet, we suggest creating a scene with a placeholder image or looping video to direct to.

We can also add in some audio as a part of this automation. First, lets add a media source into our scene with some royalty free music we want to play as people join the stream. This could also be a looping video if you are not using a static image in the scene. Ensure that “Loop” and “Restart playback when source becomes active” are checked to ensure that the music doesn’t fully stop until you tell it to.

Then, back in Advanced Scene Switcher, we can add a new macro action to our Starting stream macro to read “Media Music Play ”. This will then ensure that the audio file starts upon starting your stream!

Now, upon starting your stream, OBS will automatically switch to your “Starting stream” scene, and play the audio/video file for a greeting page for all early viewers to be welcomed by as you start amassing viewers.

Creating a Stream Intro

Now that we have created our “Starting soon” macro, we will want to add in a macro for an intro video that will play before switching to the live video feed. This can be done very much in a similar way to what we did above, but with a different macro condition. With a new macro we will title “Intro”, we want to create a condition this time with the “Hotkey” option. Name it whatever seems best to you.

We can then modify the hotkey within the OBS Settings menu under “Hotkeys” to whichever key command seems best, which can be found under the name submitted in the previous step.

Back in Advance Scene Switcher, we can now add in the actions as we did before. Let’s add in another Switch scene:

Another Media action:

This time, we want to switch the scene one more time after the video finishes. To do this, we first need to add a “Wait” action equal to the length of the intro video. This will keep the actions from triggering before the video is finished.

Then after the wait, we can Switch scene one last time:

And now upon hitting the assigned hotkey, the Getting Started scene will swap to your intro video, play it, then switch to the live feed when complete!

Ending Stream Macro

Before ending your stream, you may want to give your viewers another “Stream is ending” screen to let them know the broadcast is completed if tuning in. This will be build very similarly to the previous macro. To begin, we start with another Hotkey condition:

Next, we switch the scene to “Stream Ending”:

Play our exit music or video

Wait for the media to finish:

Then stop the stream with a final action of “Streaming → Stop Streaming”

And that’s it! One hotkey will transition to an ending slide, play music, and end the stream for you. No more fiddling around with multiple applications and buttons to finish that task.

Wrapping Up

In this article, we outlined a few different things:

Installing Advanced Scene Switcher to OBS (and OBS-WebRTC)
Configuring macros for
- Starting a stream
- Playing an intro video
- Ending a stream
Adding custom hotkey support
Managing autoplayed media for streams

This is an extremely useful tool for turning your live streams into a more professional, broadcast quality operation, with use cases expanding to many different industries needing to live stream their content and events.

Read more about the Advanced Scene Switcher on the OBS Forum, or read this blog post on getting started with OBS-WebRTC to enable your live streams to broadcast in real time for maximum interactivity with your viewers.

Happy streaming!

Using NDI in your Real Time Live Streaming Production Workflow

Dan Zeitman — Mon, 07 Nov 2022 20:18:33 +0000

If you're a developer who's also creating live streams and content you know that it takes a lot of effort setup a solid content streaming workflow.

NDI to the rescue!

NDI® (Network Device Interface) is a free protocol for Video over IP, developed by NewTek. The innovation is in the protocol, which makes it possible to stream video and media across networks with low latency from many device sources. These NDI device sources can be physical hardware or software based. This makes it possible to connect to any device, in any location, anywhere in the world – and transmit live video to wherever you are. There are a suite of NDI tools that work directly with NDI systems and sources on your network. Combine NDI with Dolby.io Real-time Streaming to deliver real time video for remote or interactive experiences.

Dolby.io Real-time Streaming offers incredibly low latency streams typically under a second. And even better, besides having the ability to white-label your own stream with their viewer, or develop a complete streaming solution, that same stream can also be distributed through streaming services such as YouTube, Facebook and Twitch.

Devices Everywhere

There are many low-to-moderate cost prosumer video devices, PTZ cameras and security systems that offer NDI support.

If you do not have a camera that supports NDI, you can simply download one of many software-based solutions that stream video and audio over your network over NDI.

In fact, that shiny new iPhone with the amazing and gorgeous camera might actually provide the best camera solution for live streaming content over NDI.

Some of our customers have had great success with various apps that are available in the App Store.

NDI HX Camera by NewTek and Stream Camera for NDI HX by fellow iOS developer Thomas Backes.

Streaming Workflow

Everyone has their own opinion on what a good live streaming content workflow actually looks like. You decide. We've created a quick guide to make it easy for you to integrate your workflow; you have multiple options to publish NDI out with your Dolby.io account. This guide will walk you through two of these options and assumes NDI tools are already installed on your computer.

Dolby.io recently acquired Millicast; you many note some references in the documentation.

OBS WebRTC

Besides our web application, we also provide a forked version of OBS that's fine tuned for advanced 4K streaming and other features of the Dolby.io platform.

Download the OBS WebRTC publisher.

In OBS create your NDI scene and add your NDI source, which can be from a camera or a mobile app.

You are now ready to start publishing using NDI with OBS WebRTC for a real time broadcast at scale.

For the stream, OBS has the following settings:

VP9
1920x1080
Bitrate 4000Kbps
FPS 30

You can adjust the OBS WebRTC settings as needed to deliver the best quality and experience.

Building a Livestream App with Flutter 3

Braden Riggs — Mon, 31 Oct 2022 20:19:09 +0000

Originally published here.

Streaming, especially the low latency kind, has become a popular medium to engage with an audience, host live events, and connect people virtually. For developers building streaming apps, however, there is just one issue. If we are interested in connecting to a wide audience we need to develop for a wide range of platforms such as Android, iOS, Web, and even desktop native apps, which can quickly become a heavy lift for any team. This is where Flutter 3 comes in, released in May of 2022, Flutter 3 takes cross-platform to the next level allowing users to "build for any screen" from a single code base. Hence, rather than building 3 separate apps for iOS, Android, and Web, you can build just one. To further sweeten the deal, Dolby.io has recently released their WebRTC real-time streaming SDK for Flutter, allowing users to build cross-platform streaming apps that combine scalability and ultra-low delay.

In this guide, we'll be exploring how to build a cross-platform real-time streaming app that works on Android, iOS, Desktop Native, and Web using the Dolby.io Streaming SDK for Flutter.

Getting Started with the Real-Time Streaming SDK

Before we begin you need to make sure you have the latest version of Flutter installed and set up on your machine. To get started with building a streaming app we need to install the Dolby.io Streaming SDK for Flutter 3 via the terminal.

flutter pub add millicast_flutter_sdk

Then run the following command in terminal to download the dependencies:

flutter pub get

With the Flutter Streaming SDK installed, you can start by creating a vanilla Flutter app and add the most recent version of flutter_webrtc to your project's pubspec.yaml. You should also see that the Dolby.io Millicast flutter SDK has been automatically added.

flutter_webrtc: ^x.x.x
millicast_flutter_sdk: ^x.x.x

Then inside main.dart you just import flutter_webrtc alongside any other dependencies your project may have.

import 'package:flutter_webrtc/flutter_webrtc.dart';

In addition to installing the SDK, you'll also need to create a free Dolby.io Account. The free account offers 50 Gigabytes of data transfer a month, which will be plenty for building and testing out the real-time streaming app.

Interested in following along with a project that already has the SDK installed and set up? Check out this GitHub repository which contains a completed version of this app.

Building the Real-Time Streaming App with Flutter

Building a WebRTC Flutter streaming app can be complicated, so to get started we first need to divide the app into a series of features that come together to support a real-time streaming experience. In order for the app to connect to the Dolby.io servers, we must include a way for the user to input their streaming credentials and tokens in order to authenticate and use the Dolby.io servers.

Taking in the WebRTC Stream Credentials

To publish and view a WebRTC stream with the Dolby.io Flutter SDK we need three things: an account ID, a stream name, and a publishing token. These credentials can be found on your Dolby.io dashboard and need to be input by the user which we can capture with the TextFormField widget, where the widget, on change, updates a TextEditingController variable.

Container(
    width: MediaQuery.of(context).size.width,
    constraints: const BoxConstraints(
        minWidth: 100, maxWidth: 400),
    child: TextFormField(
      maxLength: 20,
      controller: accID,
      decoration: const InputDecoration(
        labelText: 'Enter Account ID',
      ),
      onChanged: (v) => accID.text = v,
    )),

Note: In production, you don't need to have users input these credentials, instead you could use a custom login and serve the users a temporary login token. For learning more about Dolby.io tokens check out this blog on creating and securing tokens.

Because we need three inputs to publish a WebRTC stream to the Dolby.io server, we can repeat this code for each input.

Container(
     width: MediaQuery.of(context).size.width,
     constraints: const BoxConstraints(
         minWidth: 100, maxWidth: 400),
     child: TextFormField(
       maxLength: 20,
       controller: accID,
       decoration: const InputDecoration(
         labelText: 'Enter Account ID',
       ),
       onChanged: (v) => accID.text = v,
     )),
Container(
     width: MediaQuery.of(context).size.width,
     constraints: const BoxConstraints(
         minWidth: 100, maxWidth: 400),
     child: TextFormField(
       maxLength: 20,
       controller: streamName,
       onChanged: (v) => streamName.text = v,
       decoration: const InputDecoration(
         labelText: 'Enter Stream Name',
       ),
     )),
 // Publishing Token Input
 Container(
     width: MediaQuery.of(context).size.width,
     constraints: const BoxConstraints(
         minWidth: 100, maxWidth: 400),
     child: TextFormField(
       controller: pubTok,
       maxLength: 100,
       onChanged: (v) => pubTok.text = v,
       decoration: const InputDecoration(
         labelText: 'Enter Publishing Token',
       ),
     )),

Additionally, we can add an ElevatedButton for the user to press once they have added their credentials.

ElevatedButton(
  style: ElevatedButton.styleFrom(
    primary: Colors.deepPurple,
  ),
  onPressed: publishExample,
  child: const Text('Start Stream'),
),

Authentication and Publishing Streams from Flutter

You'll notice that the Elevated button triggers a function via its onPressed parameter. This function, called publishExample, checks if the credentials are valid and authenticates the stream. First, the function checks that a user has input a value for each input.

void publishExample() async {
    if (pubTok.text.isEmpty || streamName.text.isEmpty || accID.text.isEmpty) {
      ScaffoldMessenger.of(context).showSnackBar(const SnackBar(
        backgroundColor: Colors.grey,
        content: Text(
            'Make sure Account ID, Stream Name, and Publishing Token all include values.'),
      ));
    }

Then the function calls publishConnect, an asynchronous function that takes in streamName, pubTok, and a third object called localRenderer. localRendered is a RTCVideoRenderer object included with the flutter.webrtc package.

final RTCVideoRenderer localRenderer = RTCVideoRenderer();
publish = await publishConnect(localRenderer, streamName.text, pubTok.text);

Using these three parameters we have everything we need to authenticate and begin publishing a stream. Inside of the publishConnect function, we need to generate a temporary publishing token using the streamName and pubTok:

Future publishConnect(RTCVideoRenderer localRenderer, String streamName, String pubTok) async {
  // Setting subscriber options
  DirectorPublisherOptions directorPublisherOptions =
      DirectorPublisherOptions(token: pubTok, streamName: streamName);

  /// Define callback for generate new token
  tokenGenerator() => Director.getPublisher(directorPublisherOptions);

...
}

With the temporary publishing token created, we then can use it to create a publish object. Using this publish object we could start the stream, however, we wouldn't be able to see or hear anything, this is because we haven't specified what kind of stream we are creating or which devices we will connect to. To do this we need to specify if the stream will include audio, video, or audio and video, then we need to pass these constraints into the getUserMedia function which will map the constraints to the default audio capture device and the default video capture device.

{
...
Publish publish =
      Publish(streamName: 'your-streamname', tokenGenerator: tokenGenerator);

  final Map<String, dynamic> constraints = <String, bool>{
    'audio': true,
    'video': true
  };

  MediaStream stream = await navigator.mediaDevices.getUserMedia(constraints);

...
}

Using this stream object, we can also provide a feed to the user in the form of a viewer. To do this we need to assign our input devices to localRender as sources.

{
...

localRenderer.srcObject = stream;

...
}

Finally, we can map the stream object and pass it as an option to the connect function, which is inherited from publish.

{
...
//Publishing Options
  Map<String, dynamic> broadcastOptions = {'mediaStream': stream};

  /// Start connection to publisher
  await publish.connect(options: broadcastOptions);
  return publish;
}

With our stream connected, we can now look at setting up the viewer using localRender.

In-App WebRTC Stream Viewer

Now that our stream is authenticated and publishing we need to add a viewer object so the streamer can see themselves streaming. This can be done with a RTCVideoView object which takes in our localRender object and is constrained by a container.

Container(
  margin: const EdgeInsets.all(30),
  constraints: const BoxConstraints(
      minWidth: 100, maxWidth: 1000, maxHeight: 500),
  width: MediaQuery.of(context).size.width,
  height: MediaQuery.of(context).size.height / 1.7,
  decoration:
      const BoxDecoration(color: Colors.black54),
  child: RTCVideoView(localRenderer, mirror: true),
)

Sharing the Real-time Stream

With the stream authenticated and live, we want to share our content with the world. We can do this via a URL formatted with our streamName and our accountID which we collected as inputs. Using the example app as a template we can create a function called shareStream which formats the URL to share and copies it to the clipboard.

void shareStream() {
    Clipboard.setData(ClipboardData(
        text:
            "https://viewer.millicast.com/?streamId=${accID.text}/${streamName.text}"));
    ScaffoldMessenger.of(context).showSnackBar(const SnackBar(
      backgroundColor: Colors.grey,
      content: Text('Stream link copied to clipboard.'),
    ));
  }

Unpublishing a WebRTC Stream

To unpublish the stream we can call the publish object returned from our asynchronous publishConnect function to stop, killing the connection with the Dolby.io server.

publish.stop();

Flutter 3 is Truly Cross Platform

The power of Flutter is taking one code base and having it work across multiple platforms. Here we can see examples of the app working for Android, Windows, and Web:

Building in this cross-platform framework saves both time and resources, allowing you to get started building real-time streaming apps without having to worry about which platform works for your users. These apps are perfect for streaming live events and virtual events to the widest range of audiences allowing for high-quality interactive experiences. If you are interested in learning more about our Flutter streaming SDK check out our documentation and play around with the full project on this GitHub repository.

Feedback or Questions? Reach out to the team on Twitter, LinkedIn, or via our support desk.

Dolby.io Real-time Streaming Wins Best in Media APIs Award

Jayson DeLancey — Sat, 01 Oct 2022 01:33:19 +0000

We're excited to share that Dolby.io's Real-time Streaming has won the Best in Media APIs category at the 2023 API Awards. With Dolby.io, we provide a WebRTC-based real-time streaming service to enable sub-second latency, broadcast-quality color and sound, global scale, and end-to-end encryption — all with native support for web browsers and Internet-enabled devices.

Real-time Streaming with Sub-second Latency

Latency is the time it takes for a live stream to get from the point of capture such as live feed from a video camera to the device where the stream is being viewed. Latency is important whenever this glass-to-glass video feed is time-sensitive and viewers must receive the content in a short and predictable amount of time. This is often the case when trying to closely coordinate audio/video with an underlying data messaging service.

Real-time video streaming is especially important for live events, sports, sports betting, gaming, online auctions, AR/VR virtual worlds, remote production, live-streaming and other scenarios where time-to-delivery is mission critical in creating live human interaction. These experiences must be less than 1 second from the source to the viewer to be effective. For creating 2-way interactivity the target is even faster at 100-500 milliseconds to support a full round-trip.

With Real-time Streaming you are in control of the experience for your audience. You can broadcast to massive audiences with immersive and interactive applications that rival the real world. The Streaming APIs have integrations for OBS, Unreal Engine, and Client SDKs to support whatever platforms you want to build.

Most folks will broadcast from Open Broadcast Software (OBS) Studio and drop an embedded hosted player in their web application like this:

<iframe
    src="https://viewer.millicast.com?streamId=accountId/streamName"
    allowfullscreen
    width="640"
    height="480">
</iframe>

Dolby.io Best in Media APIs Award

The 2023 API Awards celebrate the technical innovations, adoption, and reception by leading APIs & Microservices used by the global developer community. The Awards Ceremony will be presented during API World 2023, the world's largest API & Microservices conference with over 4,000 attendees.

Dolby.io's Real-time Streaming win here at the 2023 API Awards is evidence of their leading role in the growth of the global API ecosystem,” said Jonathan Pasky, Executive Producer & Co-Founder of DevNetwork, producer of API World & the 2023 API Awards.

The 2023 API Awards received hundreds of nominations, and the Advisory Board to the API Awards have selected Dolby.io based on three criteria:
(1) attracting notable attention and awareness in the API industry;
(2) general regard and use by the developer & engineering community; and
(3) being a technical leader in its sector for innovation.

Celebrate with Dolby.io at API World

Our team will be attending API World 2023 in-person October 24-26 in San Jose to accept the award and we'd love for you and our community to join us to celebrate.

Register now for API World 2023 and claim one of the Free OPEN Passes we can offer for a limited time. Additionally, let me know you'll be there in the comments below then come find me at the event for some exclusive SWAG.

If you haven't used Dolby.io Real-time streaming yet, sign up for an account. Take a look at some of our tutorials and how-to articles for getting started. We'd love to hear more about your experience with an invitation-only private event (space limited to availability).

Learn Babylon.js to Create Your Own 3D Metaverse Environments

Dan Zeitman — Wed, 28 Sep 2022 04:06:48 +0000

Dolby.io recently sponsored a workshop at CascadiaJS, the Northwest’s premier JavaScript developer conference. That workshop, Learn BabylonJS to Create Your Own 3D Metaverse Environments was quite a popular workshop at the conference. The workshop sold-out early, and was standing room only. And for good reasons. there is a lot of interest in developing for the Metaverse.

What was all the excitement about BabylonJS and the Metaverse?

There's been a lot of buzz about building Metaverse experiences in Unreal Engine and Unity, and yes Dolby.io has you covered with plugins for both platforms. The new excitement for developers is the possibility of building Metaverse experiences using JavaScript. Our workshop focus at CascadiaJS 2022 was to help developers get started with a fully-featured JavaScript game engine called Babylon.js, then level up the experience with Real-Time Streaming and Spatial Audio.

Here's what developers had to say about the content we presented and their experience at the Dolby.io BabylonJS Metaverse workshop.

No More Fear of Missing Out!

No worries if you could not attend in-person.
You can now learn how to get started with BabylonJS with our self paced workshop available at DolbyIO Samples on our GitHub.
You'll learn the basics of 3D development, plus learn how to bring real-time streaming into your own Metaverse experiences. We've developed a full repo of code samples and tutorials to help you get started with BabylonJS and Dolby.io technologies.

Stay connected to to this project!

Don’t forget to star and bookmark this repo as we are going to be producing and releasing a companion video series to showcase the possibilities of creating amazing experiences for the Metaverse. Make sure you take a moment to subscribe our new YouTube channel for video tutorials on the Metaverse, real-time streaming, spatial audio and a lot more.

Metaverse Workshop Repo:
https://github.com/dolbyio-samples/workshop-babylonjs-metaverse

Unreal Plugins for Live Streaming:
Streaming Player – Play a live steam within Unreal Engine.
https://docs.dolby.io/streaming-apis/docs/player-plugin

Stream Broadcaster – broadcast a virtual camera with Dolby.io
https://docs.dolby.io/streaming-apis/docs/publisher-plugin

Unity Plugin for real-time communications:
https://github.com/DolbyIO/comms-sdk-dotnet

Unity Plugin Docs:
https://dolbyio.github.io/comms-sdk-dotnet/documentation/unity.html

Subscribe to our YouTube Channel:
https://www.youtube.com/c/DolbyIO