A Bug I Gave Up On​

About two years ago, I ported State Threads (ST), the coroutine library under SRS, to Windows with Cygwin. Coroutine switching worked, but SRS crashed as soon as SRT was enabled. After two weeks I found the cause: SRT uses C++ exceptions, and on Windows C++ exceptions are built on SEH, which depends on registers that a coroutine switch must save and restore. I could not find enough documentation about those registers, so I gave up.

Recently I asked AI about the same problem. In 6 minutes it wrote a test program and said it was fixed. Then I let it run on its own with a new skill, srs-autopilot. Nine hours later it had ported ST to native Windows, without Cygwin, and the C++ exception test passed.

This is the first time AI solved a problem that I could not. But speed is not the interesting part.

The Real Question Is Trust​

Running AI without supervision is easy. Claude has --dangerously-skip-permissions and Codex has --yolo. You can ask AI to rewrite SRS in Go or Rust, and it might even run. But is it really the same SRS? Can you maintain it? Would you put it in production?

Code written by people is usually safe to ship when the change is small, it is tested, and someone reviews it. AI changes are never small, and nobody can review that much code line by line. The only real guarantee left is very complete tests.

Most of What AI Writes Is Tests​

Take a recent AI feature, RFC 4588 RTX for WebRTC, in commit 3fc1810a4 (#4746). It adds 8,928 lines:

Tests and test tools are 8,310 lines, 93.1% of the change, to prove that 451 lines of feature code are correct: about 18 lines of tests for every line of feature. No human maintainer works like that. People write the feature and add a few tests if there is time. AI writes the tests first and covers everything, because writing tests costs it almost nothing.

The same happened to ST: AI raised its test coverage from 45% to 96%, and added integration tests for its key features.

These are not weak tests. When a person adds tests to existing code, the tests often repeat the code's mistakes: the code is wrong and the test agrees with it. AI can check the code against the documentation, the RFCs, and other implementations, so its tests actually find bugs. Many bugs in SRS were found this way. Even a bug fix starts with a test that proves the bug exists; otherwise you might fix a problem that is not there.

Tests Must Be Local and Fast​

The tests that keep AI correct must run locally. A change tested by GitHub Actions takes at least 20 minutes per round. Locally, the whole suite takes about 1 minute, and AI sees every result, so it finds and fixes its own mistakes quickly.

Unit tests are not enough, because features and APIs need real integration tests. SRS has regression, black-box, and script tests that start a real SRS and drive it with tools like FFmpeg and SRS Bench. A full run used to take 20 minutes; after we changed how ports are allocated, many SRS instances can run in parallel and the full run takes 1 minute. When a tool is missing, AI writes it. The WHIP and WHEP test tools in the RTX commit were written by AI.

With these tests, I can merge large AI changes with confidence. Without them, you can only hope the model never makes a mistake.

Testable Code Is Maintainable Code​

To test everything, code must be mockable: depend on interfaces, not implementations. Every class in SRS now implements an interface and depends only on other interfaces, so a test can replace any dependency with a mock and fully control it.

This refactoring touched a huge amount of code. It is so boring that no person would volunteer for it. AI did it. The result is a codebase that is easier to understand, test, and change, for AI and for people.

Skills Turn the Process into Rules​

Tests alone are not enough. AI also needs a defined workflow, and in SRS that workflow is written as skills in the skills directory:

• srs-develop is an index of the code and documents, so AI finds the right files without searching the whole project and filling its context with unrelated text. It also requires test-driven development: write the test first, then the code.
• srs-autopilot runs a large task from a plan file. The main agent discusses the background and goals with me, writes the plan, and then starts one subagent per task. Each subagent implements, tests, and commits one task. The main agent stays small and only checks progress, so the loop can run for hours.

A skill is just a document. You could say all of it to AI every time, but a skill means you only say it once.

What the Maintainer Still Does​

If AI can do the work correctly by itself, what is left for me?

• Read the plan. The plan explains the background and the steps, without much code. Reading the RTX plan taught me what RTX is and how it works, and showed me whether AI understood the problem. If something is missing or unclear, that is where bugs come from.
• Make the choices. In theory RTX also works for audio, and the first plan included it. But Chrome only uses RTX for video, so I chose video only. These choices come from experience, and they are why the same model gives different results for different people.
• Review asynchronously. I don't review most test code, because AI follows the test rules. I always review core changes. AI commits each finished task and updates the plan; another agent helps me review those commits on a separate review branch while the loop keeps running. I never block the AI, and it never waits for me.

Conclusion​

AI is like an excavator. Once you have one, you no longer dig with a hoe. Before, I could only maintain the Linux version of SRS. Now, in the same time, I can maintain a cross-platform server and its clients, and the code is better tested than it ever was when I wrote it by hand.

SRS is a simple, high efficiency and realtime video server, supports RTMP/WebRTC/HLS/HTTP-FLV/SRT.

Information for Students​

Getting Started​

1. Get to know SRS. If you are a student interested in contributing to SRS, it is recommended to start by join to the SRS Discord and exploring both the codebase and the development workflow. Feel free to contact us if you have any questions. Also do not hesitate to answer questions from other students on our Discord channel if you know the answer to something.
2. Find a project. Listed on this page are mentored and un-mentored projects. Mentored projects are well-defined and mentor(s) have already volunteered. Un-mentored projects are additional ideas you may want to consider, but you will have to contact us to find a mentor. You can also propose your own project, if you can think of one that better fits your interest and skill level. If a project description is unclear or you have any questions, please get in touch with its mentor and/or join our Discord channel at #general.
3. Contact us. If you decide on a project, get in touch with the community and let us know. If you want to work on a qualification task, let the respective mentor know so we can avoid duplicated efforts.
4. Apply. Students should apply definitely before deadline on April 8th. The "work" period begins on June 2th and ends in September. Take a look at GSoC timeline for additional information. Note, make sure you apply to Google before April 19th, even if you have not yet finished your qualification task. Please apply as soon as possible: Applications can be improved until the 19th but not afterwards!

Note: A friendly reminder that while the application to GSoC is important for you and GSoC, SRS mentors will not base their decision solely on the GSoC application. We will judge applicants based on their qualification tasks to understand their abilities in coding, learning the tools, communication skills etc. So please do not worry about your application being perfect for us. Although it is very important to follow GSoC's application rules so they can pay you.

Qualification Tasks​

In order to get accepted you have to complete a small qualification task which in all cases include sending a patch to the development mailing list. SRS development can be quite challenging and the qualification task helps us figure out whether you are motivated enough and have the potential to deliver successfully.

The qualification tasks are usually shown in the project description. Contact the respective mentor(s) for assistance on getting a related qualification task or if you want to propose your own. You can also browse the SRS Bug Issue for qualification task ideas. In general qualification tasks should include submitting a patch to the SRS Bug Issue which passes review and is accepted into the SRS codebase. It will be common for such patches to need multiple iterations of submissions and reviews, so don't wait too long with the first submission! Note, please avoid picking a qualification task which another student is already working on, each student should work on a different qualification task.

Development​

If you are selected for a particular project then you are not only expected to present a working implementation but you should also submit your work for inclusion for the SRS codebase. This should be done at least 2-3 weeks before the end of the second work period by sending patches to the SRS Bug Issue&Discord where the SRS community and your mentor will review your work. You will likely be asked to make some changes and resend improved versions. If you feel that no consensus is reached about how something should be done then follow the advice of your mentor.

In order to create good quality patches make sure to read the Developer Documentation.

Contacting SRS​

If you have questions or comments feel free to contact us via our mail, Discord one of the SRS GSoC admins:

• Discord: #general
• SRS GSoC Admins: Winlin (winlin in #general on Discord, winlinvip at gmail dot com ), Devin (Devin in #general on Discord, devin at ossrs dot io), LiuQi (Steven in #general on Discord, lq at chinaffmpeg dot org) You may also contact a mentor directly if you have questions specifically related to one of the projects listed on this page.

Mentored Project Ideas​

This section lists well-defined projects that have one or more available mentors. If you are new to SRS, and have relatively little experience with multimedia, you should favor one of these ideas rather than propose your own. Contact the respective mentor(s) to get more information about the project and the requested qualification task.

1. YAML Configuration File Support​

2. HLS LLHLS mode​

3. Coroutine-based DNS Resolution in SRS Network Library ST (State-Thread)​

4. HLS Support for CMAF​

5. Enhanced RTMP (V2)​

Introduction​

Each stream on the SRS server has a Source object that manages the stream's lifecycle. To keep the logic and code simple, SRS did not release the Source object; with a large number of streams, such as constantly changing streaming addresses, this led to continuous memory growth and leaks.

Previously, the workaround was to restart the service late at night. SRS supports Gracefully Quit, which restarts the service when there are no connections, but this did not completely solve the problem.

To address this issue, we introduced Smart Pointers to manage the lifecycle of Source objects. We did not use C++ 11 because SRS needs to compile in various environments. Instead, we implemented a simplified version of Smart Pointers, supporting only some features.

Design​

Before any work addressing this issue, we need refine the shared ptr of SRS, which is used in RTMP shared message, GB sessions, and in future source objects.

Refer to Using C++11’s Smart Pointers, there are three varieties of smart pointers:

• Shared ptr: Akin to SrsSharedPtrMessage used for RTMP message, and SrsLazyObjectWrapper for GB28181.
• Weak ptr: No such ptr in SRS before 5.0 version. We can avoid this by removing any circle reference of pointer.
• Unique ptr: The corresponding ptr is SrsAutoFree that free the ptr in the local scope.

If we carefully design and limit the usage of smart ptr, such as no cycle link that means we do not need weak ptr, we can archive a simple and easy to maintain smart ptr for SRS. We also consider bellow features:

• Inheritance: Do not use inheritance with smart pointer, although we can write correct code, but it's complex to discuss.
• Comparing: Do not support comparing smart pointers, because we only need to manage the memory automatically.
• make_shared: Do not support this helper function, because we do not consider performance issue by new operator.
• shared_from_this: Do not support this helper template, because we do not need this feature.
• make_unique: Do not support this, because we allow naked new operator, and carefully code review is required.

Again, we don't want to switch to C++11 because I think the modern C++ 11/14/17/20 is really a horrible thing that does not fix anything, but introduces a lot of bad grammar sugar. We do not want any grammar sugar, which is very harmful for communication. We have experienced a lot of disaster of smart pointers and sugars, so we want to keep the usage very simple:

1. No grammar sugar: No weak ptr, no make shared, no make unique, no inheritance, no comparing, no circle reference, no C++11/14/17/20/22 etc.
2. Follow the C++ standard API if any API is really required, do not invent new wheels, no new functions and names.
3. Carefully code review, programmer should take responsibility for code and memory issues.

In the other hand, we should not reinvent wheels especially for smart ptr, so we must use almost the same API of C++ standard library. That is why we should learn from C++11 and refactor the similar smart ptrs in SRS.

Smart pointers might seem simple when they’re just about memory management, but when you delve into inheritance, copying, comparison, performance, circular references, pointer conversion, creation, and the purism of "no naked new", their capabilities become significantly richer. In reality, the main issues with C++ programs stem from programmers messing around, and this purism along with various syntactic sugar makes it hard to notice when they are.

Most problems can be addressed with something as straightforward as an AK47, yet there's an obsession with acquiring more advanced weaponry, which leads to a situation where, on the battlefield, you can’t even fire a shot due to jams and blowbacks. This is because it’s very hard to spot when programmers are messing about in companies, with large amounts of code being submitted, the usage of various new features, and tight deadlines.

The true gates of hell in C++ are not the limited old features of C, but its plethora of new features.

Shared Ptr​

We implemented a simple Shared Ptr that supports reference counting and automatic release, based on #6834ec2.

template<class T>
class SrsSharedPtr
{
private:
    // Pointer to the object.
    T* ptr_;
    // Reference count of the object.
    uint32_t* ref_count_;

Usage is similar to std::shared_ptr, but it supports fewer interfaces:

SrsSharedPtr<MyClass> ptr(new MyClass());
ptr->do_something();

SrsSharedPtr<MyClass> cp = ptr;
cp->do_something();

It also involves copy constructor, assignment, and move constructor, as well as some operator overloading. For details, refer to the code and the unit test examples. Overall, this part is relatively simple to implement.

Shared Resource​

In addition to the Shared Ptr smart pointer, we also support Shared Resource, which mainly implements the ISrsResource interface and can be released by the ResourceManager. Refer to #6834ec2.

template<typename T>
class SrsSharedResource : public ISrsResource
{
private:
    SrsSharedPtr<T> ptr_;

In fact, Shared Resource and Shared Ptr have exactly the same interface, but we did not use inheritance; instead, we used composition. Using it is the same as using Shared Ptr, but it can be managed by a Manager:

SrsSharedResource<MyClass>* ptr = new SrsSharedResource<MyClass>(new MyClass());
(*ptr)->do_something();

ISrsResourceManager* manager = ...;
manager->remove(ptr);

In practical application scenarios, resources are often managed by a coroutine. For example, a GB SIP connection will start a separate coroutine to serve this connection. Similarly, there are GB Media connections, GB Session sessions, RTC TCP connections, etc. We created an Executor to implement this common logic:

SrsExecutorCoroutine::SrsExecutorCoroutine(ISrsResourceManager* m, ISrsResource* r)
{
    resource_ = r;
    manager_ = m;
    trd_ = new SrsSTCoroutine("ar", this, resource_->get_id());
}

SrsExecutorCoroutine::~SrsExecutorCoroutine()
{
    manager_->remove(resource_);
    srs_freep(trd_);
}

srs_error_t SrsExecutorCoroutine::cycle()
{
    srs_error_t err = handler_->cycle();
    manager_->remove(this);
    return err;
}

Therefore, we can easily use the Executor to manage this type of Resource:

SrsGbSipTcpConn* raw_conn = new SrsGbSipTcpConn();
SrsSharedResource<SrsGbSipTcpConn>* conn = new SrsSharedResource<SrsGbSipTcpConn>(raw_conn);
SrsExecutorCoroutine* executor = new SrsExecutorCoroutine(_srs_gb_manager, conn, raw_conn, raw_conn);
if ((err = executor->start()) != srs_success) {
    srs_freep(executor);
    return srs_error_wrap(err, "gb sip");
}

It is worth emphasizing that the Executor and Smart Ptr are not inherently related; they are designed as a mechanism to solve a common scenario. Otherwise, multiple places would need to implement repetitive logic, making it more complex. Additionally, since the Executor references ISrsResource, we use the Resource Ptr pointer object instead of directly using the Shared Ptr pointer.

GB28181​

GB28181's SIP and Media are two separate protocols and transmission channels. This involves independent lifecycles and management of objects. Refer to #4080 for details, as illustrated in the diagram below:

SIPTcpConn is the SIP object for GB, usually listening on TCP port 5060, responsible for device registration and information collection. MediaTcpConn is the media transmission object for GB, transmitting PS streams. The GB Session is created and managed by SIPTcpConn or MediaTcpConn objects.

In practice, Session, SIPTcpConn, and MediaTcpConn are managed as Shared Resource objects. The Session uses Shared Resource to reference SIPTcpConn and MediaTcpConn. However, SIPTcpConn and MediaTcpConn reference the Session using raw pointers, not Shared Resource, because we have not implemented Weak Ptr and do not support circular references.

WebRTC over TCP​

WebRTC over UDP is the default transport method. Since UDP is connectionless, SRS only needs an RTC Connection object to manage the RTC session. For WebRTC over TCP, an additional TCP connection is added, managed by SrsRtcTcpConn. Refer to #4083.

SrsRtcConnection uses a Shared Resource to reference the SrsRtcTcpConn object, while SrsRtcTcpConn directly references the raw pointer of SrsRtcConnection because the lifecycle of SrsRtcConnection is longer.

class SrsRtcTcpConn
{
private:
    // Since the session references this object, we should directly use the session pointer.
    SrsRtcConnection* session_;
};

class SrsRtcTcpNetwork: public ISrsRtcNetwork
{
private:
    SrsSharedResource<SrsRtcTcpConn> owner_;
};

Since we have not implemented shared_from_this, we need to pass the Shared Resource to SrsRtcTcpConn, which is ultimately managed by the Executor and SrsRtcConnection. As SrsRtcTcpConn starts a coroutine to serve this object, we use the Executor to manage it:

resource = new SrsRtcTcpConn(new SrsTcpConnection(stfd2), ip, port);

SrsRtcTcpConn* raw_conn = dynamic_cast<SrsRtcTcpConn*>(resource);
SrsSharedResource<SrsRtcTcpConn>* conn = new SrsSharedResource<SrsRtcTcpConn>(raw_conn);
SrsExecutorCoroutine* executor = new SrsExecutorCoroutine(_srs_rtc_manager, conn, raw_conn, raw_conn);
if ((err = executor->start()) != srs_success) {
    srs_freep(executor);
    return srs_error_wrap(err, "start executor");
}

Before using Smart Ptr, we needed to release the references between SrsRtcConnection and SrsRtcTcpConn when either object was destroyed. With Smart Ptr, this logic is no longer needed; simply releasing SrsRtcTcpConn will automatically handle the cleanup.

SRT Source​

The SRT Source also involves cleanup, but it is relatively simple; just switch to using Shared Ptr. For details, refer to #4084.

class SrsSrtSourceManager
{
public:
    virtual srs_error_t fetch_or_create(SrsRequest* r, SrsSharedPtr<SrsSrtSource>& pps);
    virtual void eliminate(SrsRequest* r);
};

SrsSharedPtr<SrsSrtSource> srt;
if ((err = _srs_srt_sources->fetch_or_create(r, srt)) != srs_success) {
    return srs_error_wrap(err, "create source");
}

It is important to note that the Source actually manages the Consumer, so in the Consumer, we use the raw pointer of the Source:

class SrsSrtConsumer
{
private:
    // Because source references to this object, so we should directly use the source ptr.
    SrsSrtSource* source_;
};

Release the Source object when there is no streaming or playback:

void SrsSrtSource::on_consumer_destroy(SrsSrtConsumer* consumer)
{
    // Destroy and cleanup source when no publishers and consumers.
    if (can_publish_ && consumers.empty()) {
        _srs_srt_sources->eliminate(req);
    }
}

void SrsSrtSource::on_unpublish()
{
    // Destroy and cleanup source when no publishers and consumers.
    if (can_publish_ && consumers.empty()) {
        _srs_srt_sources->eliminate(req);
    }
}

The logic for releasing the Live Source is slightly different (it will be the same in the future), but the use of smart pointers is consistent.

WebRTC Source​

Similar to SRT, the WebRTC Source is also relatively simple and only needs to be modified to use a shared pointer. For more details, refer to #4085.

class SrsRtcSourceManager
{
public:
    virtual srs_error_t fetch_or_create(SrsRequest* r, SrsSharedPtr<SrsRtcSource>& pps);
    virtual SrsSharedPtr<SrsRtcSource> fetch(SrsRequest* r);
    virtual void eliminate(SrsRequest* r);
};

It is important to note that the Source actually manages the Consumer, so in the Consumer, we use the raw pointer of the Source:

class SrsRtcConsumer
{
private:
    // Because source references to this object, so we should directly use the source ptr.
    SrsRtcSource* source_;
};

The WebRTC Source Manager supports a fetch API, which might return a null pointer, for example:

SrsSharedPtr<SrsRtcSource> source = _srs_rtc_sources->fetch(ruc->req_);
is_rtc_stream_active = (source.get() && !source->can_publish());

When there is no publishing or playing, release the Source object:

void SrsRtcSource::on_consumer_destroy(SrsRtcConsumer* consumer)
{
    // Destroy and cleanup source when no publishers and consumers.
    if (!is_created_ && consumers.empty()) {
        _srs_rtc_sources->eliminate(req);
    }
}

void SrsRtcSource::on_unpublish()
{
    // Destroy and cleanup source when no publishers and consumers.
    if (!is_created_ && consumers.empty()) {
        _srs_rtc_sources->eliminate(req);
    }
}

The logic for releasing the Live Source is slightly different (it will be made the same in the future), but the use of smart pointers is consistent.

Live Source​

Live Source is the most complex improvement, primarily because HTTP Streaming also uses Source. For more details, refer to #4089.

Therefore, we need to remove some unnecessary references to Source and instead get it from the manager:

srs_error_t SrsLiveStream::do_serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r)
{
    SrsSharedPtr<SrsLiveSource> live_source = _srs_sources->fetch(req);
    if (!live_source.get()) {
        return srs_error_new(ERROR_NO_SOURCE, "no source for %s", req->get_stream_url().c_str());
    }
};

The manager is defined as follows. Note that it uses a Timer to check and release Source, which is different from the logic in SRT/RTC. This will be unified in the future:

class SrsLiveSourceManager : public ISrsHourGlass
{
public:
    virtual srs_error_t fetch_or_create(SrsRequest* r, ISrsLiveSourceHandler* h, SrsSharedPtr<SrsLiveSource>& pps);
    virtual SrsSharedPtr<SrsLiveSource> fetch(SrsRequest* r);
};

It is important to note that Source actually manages objects like Consumer/OriginHub/Edge, so we use raw pointers to Source in these objects:

class SrsEdgeIngester : public ISrsCoroutineHandler
{
private:
    // Because source references this object, we should directly use the source ptr.
    SrsLiveSource* source_;
};

class SrsEdgeForwarder : public ISrsCoroutineHandler
{
private:
    // Because source references this object, we should directly use the source ptr.
    SrsLiveSource* source_;
};

class SrsLiveConsumer : public ISrsWakable
{
private:
    // Because source references this object, we should directly use the source ptr.
    SrsLiveSource* source_;
};

class SrsOriginHub : public ISrsReloadHandler
{
private:
    // Because source references this object, we should directly use the source ptr.
    SrsLiveSource* source_;
};

The manager uses a timer to check and release Source:

srs_error_t SrsLiveSourceManager::notify(int event, srs_utime_t interval, srs_utime_t tick)
{
    srs_error_t err = srs_success;

    std::map< std::string, SrsSharedPtr<SrsLiveSource> >::iterator it;
    for (it = pool.begin(); it != pool.end();) {
        SrsSharedPtr<SrsLiveSource>& source = it->second;

        if (source->stream_is_dead()) {
            const SrsContextId& cid = source->source_id();
            srs_trace("cleanup dead source, id=[%s], total=%d", cid.c_str(), (int)pool.size());
            pool.erase(it++);
        } else {
            ++it;
        }
    }

    return err;
}

This release logic is different from SRT/RTC, but it will be unified in the future. However, the use of smart pointers is consistent.

Conclusion​

To simplify the process, SRS initially did not release the Source object. By introducing Smart Pointers, this issue was finally resolved. By applying business constraints and combining raw pointers with Smart Pointers, we avoided the complexity of multiple Smart Pointer functionalities. Overall, the complexity introduced by this change is manageable, and future maintainability is also good.

Contact​

Welcome for more discussion at discord.

In today's digital world, videos are everywhere. From social media clips to live broadcasts, we consume a vast amount of video content daily. But have you ever wondered how we can make sense of all the information in these videos? This is where AI comes in. With the help of artificial intelligence, we can now recognize text, identify objects, and even describe scenes in video streams.

One powerful tool that makes this process easy is Oryx. In this blog, we'll explore how Oryx can help you perform OCR (Optical Character Recognition) on video streams, allowing you to extract valuable information in real-time.

Step 1: Create Oryx by One Click​

Creating an Oryx is simple and can be done with just one click if you use Digital Ocean droplet. Please see How to Setup a Video Streaming Service by 1-Click for detail.

You can also use Docker to create an Oryx with a single command line:

docker run --restart always -d -it --name oryx -v $HOME/data:/data \
  -p 80:2022 -p 443:2443 -p 1935:1935 -p 8000:8000/udp -p 10080:10080/udp \
  ossrs/oryx:5

After creating the Oryx, you can access it through http://your-server-ip/mgmt via a browser.

Step 2: Publish a Live Stream to Oryx​

You can use OBS or FFmpeg to publish a live stream to Oryx. You can also set up HTTPS and publish via WebRTC.

Once the stream is published, you can preview it using an H5 player or VLC. Please see How to Setup a Video Streaming Service by 1-Click for detail.

Step 3: Setup OpenAI Secret Key for OCR​

To use OCR, you must obtain a secret key from OpenAI. Please open the API keys page in your browser and click the Create new secret key button. Once the key is created, copy it and set it in Oryx. Then, click the Test OpenAI Service button, as shown in the picture below.

If the test is successful, you can click the Start OCR button to start the OCR process.

Step 4: Setup AI Instructions for OCR​

Once you've configured your GPT AI assistant, you can update the bellow prompt at the setting webpage Service Settings > AI Instructions > Instructions.

To recognize text in video streams, you can use the following instructions:

Recognize the text in the image. Output the identified text directly.

Please remember to restart the OCR after updating the AI settings.

Step 5: View OCR Results by Callback​

Once the OCR process is complete, you can view the results by setting up a callback URL in Oryx.

You can also view the last OCR result in the dashboard.

Cloud Service​

At SRS, our goal is to establish a non-profit, open-source community dedicated to creating an all-in-one, out-of-the-box, open-source video solution for live streaming and WebRTC online services.

Additionally, we offer a Cloud service for those who prefer to use cloud service instead of building from scratch. Our cloud service features global network acceleration, enhanced congestion control algorithms, client SDKs for all platforms, and some free quota.

To learn more about our cloud service, click here.

Conclusion​

In conclusion, using AI to recognize text and objects in video streams is a game-changer. It helps us quickly and accurately extract valuable information from videos. Tools like Oryx make this process simple and efficient, allowing you to publish live streams and get real-time OCR results with ease. Whether you're looking to identify people, read text, or describe scenes, AI-powered OCR can transform how you interact with video content. By leveraging these technologies, you can unlock new possibilities and insights from the videos you encounter every day.

Contact​

Welcome for more discussion at discord.

In today's globalized world, content creation is no longer limited by geographical boundaries. As a result, engaging a diverse, international audience has become increasingly important for video creators. Whether you're a YouTuber, filmmaker, or e-learning content provider, being able to make your content accessible in multiple languages can greatly enhance its impact. That's where Oryx comes in – with its advanced multilingual dubbing and translation services powered by OpenAI, breaking language barriers is now simpler and more cost-effective than ever.

In this blog, we will discuss how Oryx supports dubbing and translating video files from one language to another, such as converting a video with English speech to Chinese subtitles and speech. We will explore how this technology can help you appeal to a broader audience and unlock the full potential of your content, all while being incredibly easy to use and wallet-friendly. So, buckle up as we dive into the world of multilingual video content with Oryx!

Step 1: Create Oryx by One Click​

Creating an Oryx is simple and can be done with just one click if you use Digital Ocean droplet. Please see How to Setup a Video Streaming Service by 1-Click for detail.

You can also use Docker to create an Oryx with a single command line:

docker run --restart always -d -it --name oryx -v $HOME/data:/data \
  -p 80:2022 -p 443:2443 -p 1935:1935 -p 8000:8000/udp -p 10080:10080/udp \
  ossrs/oryx:5

After creating the Oryx, you can access it through http://your-server-ip/mgmt via a browser.

Step 2: Upload Video Source File​

First, please upload the video source file, click the Dubbing > Video Source > Upload local file > Upload File to upload.

Note: You can also use other tools to upload the file under the /data directory, and use the Use server file to directly use it.

Step 3: Setup OpenAI Secret Key for Dubbing​

To use AI services, you must obtain a secret key from OpenAI. Please open the API keys page in your browser and click the Create new secret key button. Once the key is created, copy it and set it in Oryx.

Next, configure the OpenAI secret key in Dubbing Settings > ASR Settings. Afterward, click on the Test OpenAI Service button, and if no errors are detected during testing, click on Update button.

Step 4: Setup the Language to Translate​

Setup the video source language from Dubbing Settings > ASR Settings > Language, and set the target language to translate in Dubbing Settings > Multilingual Translation > Instructions by setting the prompts, click on Update button.

Step 5: Start Dubbing and Download Translated Video​

Click the Start Dubbing button, as bellow described.

If translated audio segment is longer than the original audio, you can click the Rephrase or Merge next to make it shorter, as bellow described.

After all segments are ready, no red color background segments, you will be able to download the translated video, click the Download Dubbing Video button.

Cloud Service​

At SRS, our goal is to establish a non-profit, open-source community dedicated to creating an all-in-one, out-of-the-box, open-source video solution for live streaming and WebRTC online services.

Additionally, we offer a Cloud service for those who prefer to use cloud service instead of building from scratch. Our cloud service features global network acceleration, enhanced congestion control algorithms, client SDKs for all platforms, and some free quota.

To learn more about our cloud service, click here.

Conclusion​

In conclusion, Oryx's support for dubbing and translating video files to multiple languages, including the conversion of English speech to Chinese subtitles and speech, is a game-changing solution for content creators looking to engage a wider audience. By leveraging the advanced capabilities of OpenAI services, Oryx ensures an efficient, cost-effective, and user-friendly approach to video localization. This remarkable technology not only breaks language barriers but also fosters cultural exchange and global communication, propelling your content into new horizons and opening doors to endless possibilities.

Contact​

Welcome for more discussion at discord.

Introducing a cutting-edge to technology: our easy to build, browser-based, voice-driven GPT AI assistant, a transformative tool in interaction. Built with the user-friendly Oryx, which effortlessly enables HTTPS with a single click, this AI assistant is accessible on any device equipped with a browser, including PCs and mobile phones. Its convenience allows you to communicate with your private GPT AI assistant effortlessly, anytime and anywhere, making it the perfect solution for hands-free use and quick input. Ideal for improving your spoken English, acting as a real-time translator, or simply serving as a smart companion, this voice-driven AI assistant works well through conversation.

Step 1: Create Oryx by One Click​

Creating an Oryx is simple and can be done with just one click if you use Digital Ocean droplet. Please see How to Setup a Video Streaming Service by 1-Click for detail.

You can also use Docker to create an Oryx with a single command line:

docker run --restart always -d -it --name oryx -v $HOME/data:/data \
  -p 80:2022 -p 443:2443 -p 1935:1935 -p 8000:8000/udp -p 10080:10080/udp \
  ossrs/oryx:5

After creating the Oryx, you can access it through http://your-server-ip/mgmt via a browser.

Step 2: Setup HTTPS for Voice-Driven GPT​

When integrating voice functionality into your browser-based GPT AI assistant, security becomes paramount. Browsers require the use of HTTPS when accessing the microphone to capture voice inputs as part of their security strategies. This might sound complex, but with Oryx, enabling HTTPS on your site is straightforward and hassle-free. Here's how to secure your voice-driven AI assistant with HTTPS:

1. DNS Configuration: Begin by adding a DNS A record for your domain. This step directs your domain name to your Oryx server. To verify that the DNS setup is correct, try accessing your Oryx with your domain name via http, like http://your_domain_name. If the setup is correct, this should work without any issues.

2. Enable HTTPS: Navigate to the System > HTTPS > Let's Encrypt section in your Oryx dashboard. Here, you'll simply input your domain name and hit the Submit button. This process initiates the automatic generation and installation of a Let's Encrypt SSL certificate for your domain, making the setup of HTTPS as easy as a single click.

3. Verification: With HTTPS enabled, you can now access your Oryx site securely by using https://your_domain_name. This secure connection ensures the security of your interactions with the GPT AI assistant.

For more details, please see Setup HTTPS for Oryx. By following these steps, you'll ensure that your voice-driven GPT AI assistant is not only innovative and useful but also secure and compliant with browser security standards.

Step 3: Setup OpenAI Secret Key in Live Room​

To use AI services, you must obtain a secret key from OpenAI. Please open the API keys page in your browser and click the Create new secret key button. Once the key is created, copy it and set it in Oryx.

Next, as illustrated in the image below, navigate to Scenarios > LiveRoom > Create Live Room and press the Create button to create a live room for conversing with the GPT AI assistant. Alternatively, select the link to join an existing live room.

Next, configure the OpenAI secret key in LiveRoom > AI Assistant > AI Provider. Afterward, click on the Test OpenAI Service button, and if no errors are detected during testing, click on Update AI Assistant.

All you need to set up! It's quite user-friendly.

Step 4: Open GPT AI Assistant in Browser​

Now, click the Assistant Link button to create a link. You can either click the link to open the browser-based, voice-driven GPT AI assistant. You can also right-click the link to copy and share the URL with other devices or friends. You can use this on your mobile device as well.

Upon opening the AI assistant webpage, press the Allow button to grant microphone access to the AI assistant.

Press the Start Chatting button to interact with it.

Your AI assistant is now prepared; let's explore how to communicate with her.

Step 5: How to Interact with GPT AI Assistant​

When using a browser-based voice-driven GPT AI assistant on a computer, such as an Apple Mac or a Windows PC, click on the microphone icon on the webpage. Press and hold either the SPACE or R key to begin speaking, and release the key to stop speaking.

When utilizing the AI assistant on a mobile device browser, like iPhone or Android, press and hold the microphone for speaking, and release to finish speaking.

Once you've submitted your message to the AI assistant, please wait briefly. The AI assistant will respond to you using text and voice as well.

Note: Moreover, a text input feature permits you to enter text by typing or pasting from the clipboard. Upon using voice input, the input text field auto-fills, enabling you to edit and resend it to the AI assistant.

That's it! Now, let me present some intriguing and practical real-world examples and how to do it via your browser-based voice-driven GTP AI assistant.

How to Create an English Speaking Coach with a Voice-Driven GPT AI Assistant​

Once you've configured your voice-driven GPT AI assistant, you can update the bellow prompt at the setting webpage AI Assistant > AI Instructions > Instructions. You can get an excellent language coach who is tireless, humble, doesn't lose temper, and patiently accompanies you in your spoken language practice. After using it for a month, I progressed from speaking word by word to speaking sentence by sentence.

I want you to act as a spoken English teacher and improver. 
I will speak to you in English and you will reply to me in English to practice my spoken English. 
I want you to strictly correct my grammar mistakes, typos, and factual errors. 
I want you to ask me a question in your reply. 
Now let's start practicing, you could ask me a question first. 
Remember, I want you to strictly correct my grammar mistakes, typos, and factual errors.

Note: Discover additional prompts at awesome-chatgpt-prompts.

How to Create a Simultaneous Translator for Multilingual Users​

By sharing your voice-activated GPT AI assistant to more than one user, allowing them to converse with the same AI assistant, then you get a simultaneous translator. You need to prompt the AI assistant to convert text into various languages.

Please change the languages in the prompt to yours, updat the prompt at AI Assistant > AI Instructions > Instructions:

I want you to act as a language translator.
I want you to translate my text in conversational tone.
I want you to strictly translate to English and Chinese.
Keep in mind that you must translate to English and Chinese.
Remember, never answer questions but only translate.

Note: Discover additional prompts at awesome-chatgpt-prompts.

Cloud Service​

At SRS, our goal is to establish a non-profit, open-source community dedicated to creating an all-in-one, out-of-the-box, open-source video solution for live streaming and WebRTC online services.

Additionally, we offer a Cloud service for those who prefer to use cloud service instead of building from scratch. Our cloud service features global network acceleration, enhanced congestion control algorithms, client SDKs for all platforms, and some free quota.

To learn more about our cloud service, click here.

Conclusion​

In wrapping up, the journey to creating a personal, browser-based, voice-driven GPT AI assistant with the SRS Stack is remarkably straightforward. From setting up HTTPS for secure communication to integrating OpenAI's powerful GPT capabilities, each step is designed to be user-friendly and accessible. Whether aiming to improve language abilities, enable multi-language discussions, or simply enjoy the convenience of a voice-driven GPT AI assistant, it offers numerous possibilities for living room and streaming hosts with AI assistance. In the future, support for connecting live audience chats to the AI assistant will also be available. You can discover more beneficial use cases for this GPT AI assistant in real-world.

Contact​

Welcome for more discussion at discord.

In the dynamic world of live streaming, latency is a critical factor that can make or break the viewer experience. Traditionally, achieving low latency has been a challenge, especially when striving for broad compatibility across devices and platforms. This is where HLS comes into play, a widely adopted format known for its reliability and compatibility. However, HLS is often associated with higher latency about 30 seconds, which can be a drawback for real-time interactions.

Enter the realm of low-latency HLS streaming, a game-changer for live broadcasts. In this blog, we'll explore how you can drastically reduce HLS stream latency to as low as 5 seconds. The best part? This can be achieved using common, highly compatible technologies, without the need for specialized equipment. We'll delve into the use of the Oryx, a powerful yet straightforward tool that simplifies the process, making ultra-low latency HLS streaming accessible with just a click.

If you need even lower latencies and can compromise on compatibility, there are options. For latencies between 1 to 3 seconds, HTTP-FLV is a great choice. For ultra-low latencies of about 0.5 to 1 second, WebRTC is ideal. Each technology is suitable for different requirements and content types.

In this blog, we aim to provide you with a comprehensive guide on choosing the right streaming technology for your business, focusing on HLS for achieving the optimal balance between low latency and high compatibility. Whether you're streaming a live sports event, an interactive webinar, or a real-time gaming session, understanding these technologies will empower you to deliver the best possible live streaming experience to your audience.

Key Points​

To achieve the widest compatibility, we use the most common HLS protocol, not HTTP-FLV, WebRTC, or even the LLHLS protocol, but the most standard HLS protocol.

However, we need to change some settings at critical points, such as:

• For OBS encoder, select the x264 encoder and in the advanced settings, set the GOP (Keyframe interval) to 1 s. Choose Preset as fast, Profile as baseline, and Tune as zerolatency. These settings allow OBS to generate shorter segments while maintaining compatibility.
• For Oryx, enable the HLS low latency mode. This will generate HLS segments as short as possible, around 2 seconds each. The minimum delay for HLS is about two segments, allowing for an approximate 5-second delay.
• For HLS player, such as hls.js, set it to start playing from the last segment and configure the maximum buffer time. When the accumulated delay reaches a certain threshold, enable accelerated playback to maintain a stable low latency.

The entire workflow, from streaming to the server to the player, needs optimization to achieve a 5-second low latency. Common mistakes in this process include:

• Inability to set the encoder, like OBS, with a large GOP, such as 10 seconds, or having an excessively large encoder buffer, leading to significant overall delay.
• The Oryx is not set to low latency mode. In normal mode, the generated segment durations are longer, or some servers may not produce segments of accurate duration, preferring larger segments instead.
• Using an incorrect player, such as VLC, which has significant delay regardless of the protocol used. Not all players are suitable; we have tested that both hls.js and mpegts.js players have low latency. In the future, we will test and ensure compatibility with more players.

Let's begin achieving a 5-second HLS latency with a few simple setup steps and clicks.

Step 1: Create Oryx by One Click​

Creating an Oryx is simple and can be done with just one click if you use Digital Ocean droplet. Please see How to Setup a Video Streaming Service by 1-Click for detail.

You can also use Docker to create an Oryx with a single command line:

docker run --restart always -d -it --name oryx -v $HOME/data:/data \
  -p 80:2022 -p 443:2443 -p 1935:1935 -p 8000:8000/udp -p 10080:10080/udp \
  ossrs/oryx:5

After creating the Oryx, you can access it through http://your-server-ip/mgmt via a browser.

Step 2: Setup OBS for HLS Low Latency​

I suggest using OBS to publish the stream. It's a popular and powerful streaming tool that's easy to set up. You should configure OBS as follows:

Click the Settings button, then go to the Output tab and apply the following settings:

• Set the Output Mode to Advanced. The Simple mode does not work for low latency HLS.
• Set the Video Encoder to x264. Note that the hardware encoder may have a larger delay.
• Set the Keyframe interval to 1 s. Please note that this is the most critical setting for achieving low latency.
• Set the CPU Usage Preset to fast. This setting is helpful for reducing the delay.
• Set the Profile to baseline. This setting is helpful for reducing the delay.
• Set the Tune to zerolatency. This setting is helpful for reducing the delay.

Next, open the Stream tab and follow the instructions provided by the Oryx to set the server and stream key for publishing the stream.

Step 3: Setup Oryx in HLS Low Latency Mode​

Open the Oryx and navigate to System > HLS Low Latency. Enable the HLS low latency mode and click the Submit button.

After that, you can obtain the publish server and stream key for OBS to stream to the Oryx.

Please configure OBS and begin publishing the RTMP stream to the Oryx.

Step 4: Setup the HLS Player​

Open the Oryx Simple Player in the browser, and you can see the HLS stream with a 5-second delay.

The Oryx has configured the HLS player using hls.js for low latency mode. We have applied the following settings. If you need to use your own HLS player, please configure it similarly:

• Enable enableWorker by setting it to true. This improves performance and helps avoid lag or frame drops.
• Activate lowLatencyMode by setting it to true. This enables Low-Latency HLS part playlist and segment loading.
• Set liveSyncDurationCount to 0 to start playback from the last segment.
• Set maxBufferLength to 5 to set the maximum buffer length in seconds.
• Set maxLiveSyncPlaybackRate to 2 to catch up if the latency is large.

For detailed information, please refer to this commit.

Cloud Service​

At SRS, our goal is to establish a non-profit, open-source community dedicated to creating an all-in-one, out-of-the-box, open-source video solution for live streaming and WebRTC online services.

Additionally, we offer a Cloud service for those who prefer to use cloud service instead of building from scratch. Our cloud service features global network acceleration, enhanced congestion control algorithms, client SDKs for all platforms, and some free quota.

To learn more about our cloud service, click here.

Conclusion​

Harnessing the Oryx, OBS, and hls.js, we've made 5-second latency HLS streaming a reality, breaking barriers in live broadcast low latency and compatibility. This advancement marks a new era for interactive and engaging live events, available to all without specialized equipment, setting a new experience in the streaming world.

Contact​

Join us for further conversation on Discord. If you'd like to help, please feel free to support us through donations on OpenCollective.

SRS Server​

SRS 5.0 will be officially released as a stable version in the next two weeks. After a year of feature freeze and six months of stability improvement, 5.0 is now ready for production use.

5.0 started development in March 2021, with key changes as follows:

• ST (State-Threads): Supports Windows/RISCV/LOONGARCH/MIPS/AppleM1 chips and multi-threading capabilities.
• SRT: Rewritten based on ST, aligning APIs and callbacks, supporting direct IP streaming, upgrading libsrt, improving latency, and completing configuration options.
• WebRTC: Supports WHIP and WHEP protocols, TCP transmission, Unity, improved error reporting, MP3 to OPUS conversion, and native OPUS support in FFmpeg.
• WHIP: Supports WHIP protocol, adapts to Larix and OBS WHIP, improves security, and supports resource deletion.
• GB28181: Supports 2016/TCP protocol, stress testing tools, and regression testing.
• Live: Fixes RBSP parsing issues, compatibility with FFmpeg timecode, ignores empty NALUs, supports HLS pseudo-streams, HLS client kicking, and resolves DASH crash issues.

There are also some bug fixes. For a detailed list of changes, please refer to the official website's Changelog.

Looking back, it seems not much has been done in two years.

Oryx​

Oryx is an integrated video cloud that includes multiple audio and video projects, centered around audio and video application scenarios, and offers out-of-the-box solutions.

This year, Oryx was revamped, with major changes as follows:

• Transitioned from microservices architecture to monolithic application, reducing image size by 90%, increasing development speed by 10 times, and making microservices architecture the most misleading.
• Supports Docker and script installations, DigitalOcean and Lighthouse images, BT and aaPanel plugin installations, and HELM installations.
• Tests cover all installation methods, features, and APIs.
• Supports new scenarios such as virtual live streaming, AI-generated subtitles, transcoding, callbacks, HLS clusters, and stream pulling and pushing.

If SRS is simple and easy to use, Oryx truly simplifies building audio and video businesses.

Community​

SRS started as an open-source project in 2013, officially began building an open-source community in 2020, and expanded to a global community in 2022. This year, the community has grown rapidly and is now self-sustaining.

The number of monthly paying users worldwide and OpenCollective subscribers has increased from around 5 to 41. It is expected that in three to five years, dedicated time can be invested in supporting community development.

This year, we also began offering paid support to the community, with overseas users paying $5 per month, which has been well received by users.

We maintain open-source projects while also benefiting from other audio and video open-source projects. Therefore, we will donate half of our revenue to other audio and video open-source projects we depend on, such as FFmpeg and OBS.

Additionally, we will continue to enhance the community's AI capabilities. For example, we use GPT to automatically translate community Issues and Pull Requests, reducing communication barriers. We also deployed AI Talk on the official website, making it easy for everyone to experience the new capabilities of audio, video, and AI integration.

We are grateful for the global developer support and recognition of SRS, and our development will continue to improve.

Cloud Service​

At SRS, our goal is to establish a non-profit, open-source community dedicated to creating an all-in-one, out-of-the-box, open-source video solution for live streaming and WebRTC online services.

Additionally, we offer a Cloud service for those who prefer to use cloud service instead of building from scratch. Our cloud service features global network acceleration, enhanced congestion control algorithms, client SDKs for all platforms, and some free quota.

To learn more about our cloud service, click here.

Conclusion​

No matter how the open-source wind blows, understanding the value of what we do will ensure longevity.

Numerous open-source projects provide a never-ending foundation for the global software ecosystem. Being a contributor to this system is a programmer's pride.

Providing paid support to users is valuable. While some regions may not appreciate it as much, we can offer more services where it is more recognized, such as overseas.

As for professional open-source and custom development, some community developers are already doing this on Upwork, and flexible employment is a good option.

Lastly, regarding commercialization, at least SRS won't pursue it. SRS aims to become a widely used audio and video open-source project globally, and commercialization would hinder this goal.

In the open-source community, there is no winter in sight.

Are you tired of struggling with complicated setups and technical jargon when trying to create a public internet WHIP service for OBS? Look no further! In this comprehensive guide, we will walk you through the process of effortlessly building your own WHIP service using the Oryx, all with just a single click. Say goodbye to the complexities of security, authentication, and WebRTC, and embrace the future of sub-second live streaming and seamless OBS-RTC room connections.

Join us as we break down the barriers of online streaming and help you unlock the full potential of OBS's WHIP support. Our easy-to-understand, step-by-step tutorial will empower you to create a secure and efficient WHIP service, revolutionizing your online meeting and live streaming experience. Don't let technical challenges hold you back any longer - dive into our guide and start streaming like a pro today!

Step 1: Create Oryx by One Click​

Creating an Oryx is simple and can be done with just one click if you use Digital Ocean droplet. Please see How to Setup a Video Streaming Service by 1-Click for detail.

You can also use Docker to create an Oryx with a single command line:

docker run --restart always -d -it --name oryx -v $HOME/data:/data \
  -p 80:2022 -p 443:2443 -p 1935:1935 -p 8000:8000/udp -p 10080:10080/udp \
  ossrs/oryx:5

After creating the Oryx, you can access it through http://your-server-ip/mgmt via a browser.

Step 2: Get the WHIP URL from Oryx​

Please download OBS version 30 or higher from this link and proceed with the installation.

Open the Oryx, select Scenarios > Streaming > WebRTC: WHIP OBS, and follow the instructions to get a WHIP URL for OBS.

Please copy the WHIP URL as we will use it in OBS. Be aware that the WHIP stream can be played using the WHEP player or embedded into your WordPress website.

Step 3: Publish WHIP via OBS to Oryx​

Next, launch OBS and select Settings > Stream. Choose WHIP from the Service drop-down menu, and set the WHIP URL into the Server field.

Note: If the latency is large, setup the OBS Output by: For OBS encoder, select the x264 encoder and in the advanced settings, set the GOP (Keyframe interval) to 1 s. Choose Preset as fast, Profile as baseline, and Tune as zerolatency.

Now you can click the Start Streaming button to publish the WHIP stream to the Oryx.

Step 4: Use WHEP to View the Stream​

After publishing the stream, you can view it with a WebRTC HTML5 player. Access the WHEP player from the Oryx dashboard.

Additionally, integrate the WHEP player within your WordPress website. Kindly adhere to the guidelines provided on the Oryx dashboard.

Cloud Service​

At SRS, our goal is to establish a non-profit, open-source community dedicated to creating an all-in-one, out-of-the-box, open-source video solution for live streaming and WebRTC online services.

Additionally, we offer a Cloud service for those who prefer to use cloud service instead of building from scratch. Our cloud service features global network acceleration, enhanced congestion control algorithms, client SDKs for all platforms, and some free quota.

To learn more about our cloud service, click here.

Conclusion​

In conclusion, our comprehensive guide has provided you with a simple and efficient method to create a public internet WHIP service for OBS using the Oryx. By following our easy-to-understand, step-by-step tutorial, you can now effortlessly build your own WHIP service with just a single click, eliminating the need to grapple with complex security, authentication, and WebRTC issues. With this newfound knowledge, you can revolutionize your online meeting and live streaming experience, fully harnessing the power of OBS's WHIP support for sub-second streaming and seamless OBS-RTC room connections.

Contact​

Welcome for more discussion at discord.

In this blog, we're diving into an exciting advancement in live streaming: using Automatic Speech Recognition (ASR) to create real-time subtitles. Have you ever wondered how live streams can be more inclusive, especially for people with hearing disabilities or those who are non-native speakers? The answer lies in an innovative technology that’s reshaping how we experience live content.

We'll focus on a game-changing tool in ASR – OpenAI's Whisper. This isn't just any technology; it's a powerful AI service that understands almost every language in the world and transcripts speech with remarkable accuracy. Forget the old days of needing expensive professionals for live translation and transcription. With OpenAI's Whisper, this process becomes automated, efficient, and cost-effective.

Designed for beginners, our guide will take you through integrating Whisper AI into your live streams to recognize and transcribe speech. Then, we'll show you how to use FFmpeg, to overlay these subtitles onto your stream. All of this is made simple using the Oryx, which seamlessly connects these technologies with just one click.

Join us as we step into the AI-powered future of live streaming, where accessibility and inclusivity are key, making your content enjoyable and accessible to a much wider audience.

Step 1: Create Oryx by One Click​

Creating an Oryx is simple and can be done with just one click if you use Digital Ocean droplet. Please see How to Setup a Video Streaming Service by 1-Click for detail.

You can also use Docker to create an Oryx with a single command line:

docker run --restart always -d -it --name oryx -v $HOME/data:/data \
  -p 80:2022 -p 443:2443 -p 1935:1935 -p 8000:8000/udp -p 10080:10080/udp \
  ossrs/oryx:5

After creating the Oryx, you can access it through http://your-server-ip/mgmt via a browser.

Step 2: Publish a Live Stream to Oryx​

You can use OBS or FFmpeg to publish a live stream to Oryx. You can also set up HTTPS and publish via WebRTC.

Once the stream is published, you can preview it using an H5 player or VLC. Please see How to Setup a Video Streaming Service by 1-Click for detail.

Step 3: Setup OpenAI Secret Key for Whisper ASR​

To use Whisper ASR, you must obtain a secret key from OpenAI. Please open the API keys page in your browser and click the Create new secret key button. Once the key is created, copy it and set it in Oryx. Then, click the Test OpenAI Service button, as shown in the picture below.

If the test is successful, you can click the Start Transcription button to start the transcription process.

Step 4: View Live Stream with Subtitles​

When HLS segments are generated, Oryx uses FFmpeg to transcode the TS segment into an audio MP4 file. It then utilizes OpenAI's Whisper service to convert this into an SRT subtitle. Following this, the subtitle is overlaid onto the original TS file, resulting in the creation of a new live stream.

A link is available to play the newly generated live stream with subtitles. You can open this link directly in your browser, as shown in the picture below.

Open the HLS stream link in the browser to view the live stream with subtitles.

You can also use the HTTP API to obtain ASR results for each HLS segment and perform actions like translation or integration with your AI systems.

HLS with WebVTT​

You can enable Web Video Text Tracks (WebVTT) for HLS. First, enable WebVTT in Transcript > Service Settings > WebVTT Subtitle, click the checkbox Enable WebVTT Subtitle.

Then, open the Stream Operations tab, you will get a HLS stream with WebVTT subtitles.

Cloud Service​

At SRS, our goal is to establish a non-profit, open-source community dedicated to creating an all-in-one, out-of-the-box, open-source video solution for live streaming and WebRTC online services.

Additionally, we offer a Cloud service for those who prefer to use cloud service instead of building from scratch. Our cloud service features global network acceleration, enhanced congestion control algorithms, client SDKs for all platforms, and some free quota.

To learn more about our cloud service, click here.

Conclusion​

Oryx is now integrated with OpenAI's Whisper and FFmpeg to transcript live streaming, enhancing the audience experience by providing AI-driven subtitles. This shift from manual to automated transcription is cost-effective and broadens global accessibility, overcoming language and hearing barriers. We're entering a future where AI enhances digital inclusivity, enriching how we share and consume content online.

Contact​

Welcome for more discussion at discord.

HEVC, or H.265, can reduce bandwidth usage by about 50% compared to the widely used H.264 codec, which has the best compatibility. Over the past 10 years, HEVC has grown slowly because a new codec needs an ecosystem to support it, including decoders and device hardware. Now, both RTMP and FLV support HEVC in OBS and FFmpeg, which are the standard tools in the live streaming industry.

In live streaming, all the necessary tools are ready for HEVC. For encoding, FFmpeg and OBS are the most commonly used streaming tools. OBS 29+ supports RTMP with HEVC, while FFmpeg 6 supports RTMP with HEVC. For HTML5 players, mpegts.js 1.7.3 already supports HEVC via HTTP-FLV or HTTP-TS. VLC and ffplay also support HEVC via HTTP-TS, SRT, and HLS. For media servers, SRS 6 supports HEVC via RTMP, FLV, TS, HLS, SRT, WebRTC, and more.

In this tutorial, we introduce FFmpeg 6, which added HEVC support just a few months ago. This is a significant development, as many tools that use FFmpeg can now utilize HEVC via RTMP without any patches.

Note: If you are interested in learning about OBS support for HEVC via RTMP, please read How to Push HEVC via RTMP by OBS.

Note: Please note that SRS 6.0 had already HEVC(H.265) support for RTMP, HTTP-FLV, SRT, HTTP-TS, HLS, MPEG-DASH and WebRTC(Safari), please refer to H.265 Live Streaming Saving 50% Cost.

Step 1: Run SRS Media Server​

YouTube supports HEVC through RTMP, allowing you to directly publish HEVC via RTMP streams to YouTube using OBS or FFmpeg. If you need to create your own live streaming platform, you can use the SRS media server, which also supports HEVC via RTMP.

To run SRS, you can use Docker with the following command:

docker run --rm -it -p 1935:1935 -p 8080:8080 ossrs/srs:6 \
  ./objs/srs -c conf/docker.conf

To check if it started successfully, open your browser and visit http://localhost:8080.

Step 2: Publish by FFmpeg 6​

If you have compiled FFmpeg 6 from source code using the instructions from this post, you can now utilize FFmpeg to publish RTMP HEVC streams:

ffmpeg -stream_loop -1 -re -i doc/source.flv -acodec copy \
  -vcodec libx265 -f flv rtmp://localhost/live/livestream

Keep in mind that FFmpeg 6.0 does not support HEVC over RTMP until the following commit 637c761b:

commit 637c761be1bf9c3e1f0f347c5c3a390d7c32b282
Author: Steven Liu <liuqi05@kuaishou.com>
Date:   Mon Aug 28 09:59:24 2023 +0800

    avformat/rtmpproto: support enhanced rtmp
    
    add option named rtmp_enhanced_codec,
    it would support hvc1,av01,vp09 now,
    the fourcc is using Array of strings.
    
    Signed-off-by: Steven Liu <lq@chinaffmpeg.org>

SRS offers Docker support for FFmpeg versions 4 and 5, which enable HEVC streaming through RTMP. You can conveniently use Docker to directly publish your live stream.

# For macOS
docker run --rm -it ossrs/srs:encoder \
  ffmpeg -stream_loop -1 -re -i doc/source.flv -acodec copy \
    -vcodec libx265 -f flv rtmp://host.docker.internal/live/livestream

# For Linux
docker run --net=host --rm -it ossrs/srs:encoder \
  ffmpeg -stream_loop -1 -re -i doc/source.flv -acodec copy \
    -vcodec libx265 -f flv rtmp://127.0.0.1/live/livestream

Note: If want to use OBS, please download OBS 29+ from here, select the HEVC codec, please see How to Push HEVC via RTMP by OBS for detail.

Step 3: Play by HTML5 Player​

To play HEVC streams in your web browser, you can utilize mpegts.js version 1.7.3+ for playing HTTP-FLV or HTTP-TS.

The SRS player has mpegts.js integrated, so all you need to do is open the URL to play the HEVC stream:

• HTTP-FLV(by H5): http://localhost:8080/live/livestream.flv

When it comes to HLS streaming, hls.js doesn't support HEVC via TS. As a result, you should use VLC or ffplay to play the HLS stream instead:

• HLS(by VLC or fflay): http://localhost:8080/live/livestream.m3u8

Cloud Service​

At SRS, our goal is to establish a non-profit, open-source community dedicated to creating an all-in-one, out-of-the-box, open-source video solution for live streaming and WebRTC online services.

Additionally, we offer a Cloud service for those who prefer to use cloud service instead of building from scratch. Our cloud service features global network acceleration, enhanced congestion control algorithms, client SDKs for all platforms, and some free quota.

To learn more about our cloud service, click here.

Conclusion​

In summary, using HEVC for live streaming has become more accessible thanks to essential tools like OBS, FFmpeg, and SRS media server, making it simpler for users to benefit from the bandwidth savings provided by this codec. By following the steps in this guide, you can create your own live streaming platform with HEVC and RTMP, and play the streams using HTML5 players like mpegts.js, or VLC and ffplay for HLS streaming.

Contact​

Welcome for more discussion at discord.

In today's digital world, live streaming has become an essential tool for businesses, content creators, and individuals alike. With the increasing number of viewers tuning in to watch live streams, it's crucial to optimize the streaming experience and cost for everyone, regardless of their internet speed or device capabilities. One effective way to achieve this is through live streaming transcoding, a process that can help reduce bandwidth and save costs without compromising on video quality. In this blog, we'll explore the benefits of using Oryx for efficient live streaming transcoding and how it can lead to significant cost savings.

Live streaming transcoding involves converting a live stream from Oryx using FFmpeg into various bitrates and resolutions, before pushing it back to Oryx. This process allows for a reduction in bandwidth while maintaining the same quality, simply by lowering the bitrate of the stream. As a result, the overall viewing bandwidth is decreased, leading to cost savings for both the streamer and the viewer.

For instance, consider a live streaming scenario with 10,000 viewers all watching the same 2Mbps bitrate stream. By transcoding the stream to 1Mbps, the required bandwidth is reduced to 10Gbps, resulting in a 50% cost saving. This not only benefits the content provider but also ensures a smoother streaming experience for viewers with varying internet speeds and devices.

Stay tuned as we delve deeper into the world of live streaming transcoding, and learn how to harness the power of Oryx to optimize your streaming experience and save costs.

Step 1: Create Oryx by One Click​

Creating an Oryx is simple and can be done with just one click if you use Digital Ocean droplet. Please see How to Setup a Video Streaming Service by 1-Click for detail.

You can also use Docker to create an Oryx with a single command line:

docker run --restart always -d -it --name oryx -v $HOME/data:/data \
  -p 80:2022 -p 443:2443 -p 1935:1935 -p 8000:8000/udp -p 10080:10080/udp \
  ossrs/oryx:5

After creating the Oryx, you can access it through http://your-server-ip/mgmt via a browser.

Step 2: Publish a Live Stream to Oryx​

You can use OBS or FFmpeg to publish a live stream to Oryx. You can also set up HTTPS and publish via WebRTC.

Once the stream is published, you can preview it using an H5 player or VLC. Please see How to Setup a Video Streaming Service by 1-Click for detail.

Step 3: Transcode the Live Stream to Lower Bitrate​

Suppose you've sent an 8Mbps stream to Oryx using OBS, and you can't adjust the bitrate in OBS. This could be because the stream is published by a vendor you can't control, or you need to record the original high-resolution stream, or some devices like 4K/8K TVs require the high-resolution stream.

However, most of your viewers watch the live stream on mobile devices, and they don't need an 8Mbps stream. A 2Mbps stream is sufficient for mobile devices, and their bandwidth may only support a 2Mbps bitrate. In this case, you can use transcoding to convert the 8Mbps stream into a 2Mbps live stream.

After transcoding the stream, you can preview the 2Mbps version or forward it to another live streaming platform. See Easily Stream Your RTSP IP Camera to YouTube, Twitch, or Facebook for more information. You can also pull the RTMP stream from Oryx and forward it elsewhere.

Check Transcoding Status​

You can check the transcoding status in the Oryx dashboard.

You can click the preview link to check the transcoded stream, or forward it to another live streaming platform. See Easily Stream Your RTSP IP Camera to YouTube, Twitch, or Facebook for more information.

Cloud Service​

At SRS, our goal is to establish a non-profit, open-source community dedicated to creating an all-in-one, out-of-the-box, open-source video solution for live streaming and WebRTC online services.

Additionally, we offer a Cloud service for those who prefer to use cloud service instead of building from scratch. Our cloud service features global network acceleration, enhanced congestion control algorithms, client SDKs for all platforms, and some free quota.

To learn more about our cloud service, click here.

Conclusion​

In summary, we discussed the benefits of live streaming transcoding using Oryx and FFmpeg. Transcoding optimizes streaming for viewers with different internet speeds and devices, reduces bandwidth usage, and saves costs. We covered setting up Oryx and FFmpeg, creating a configuration file, and pushing transcoded streams back to Oryx. Monitoring and adjusting settings is crucial for optimal viewer experience, and transcoding can also convert high-resolution streams to lower resolutions for mobile devices.

Contact​

Welcome for more discussion at discord.

Do you have an IP camera that supports only the RTSP protocol and want to stream it to YouTube, Twitch, or Facebook? The simplest solution is to use Oryx. With just one click, you can stream your IP camera to these platforms for continuous 24/7 streaming.

How to change IP Camera's RTSP stream to RTMP/RTMPS for live streaming platforms? You can use OBS or Oryx. OBS requires a device, while Oryx works on a cloud server and in the backend. See the workflow below.

IP Camera ---RTSP---> OBS or Oryx ---RTMP/RTMPS---> YouTube, Twitch, or Facebook

Oryx helps you connect multiple IP cameras and stream live to various platforms, making your live streaming experience stronger.

Step 1: Create Oryx by One Click​

Creating an Oryx is simple and can be done with just one click if you use Digital Ocean droplet. Please see How to Setup a Video Streaming Service by 1-Click for detail.

You can also use Docker to create an Oryx with a single command line:

docker run --rm -it -p 80:2022 -p 443:2443 -p 1935:1935 \
  -p 8080:8080 -p 8000:8000/udp -p 10080:10080/udp --name oryx \
  -v $HOME/data:/data ossrs/oryx:5

After creating the Oryx, you can access it through http://your-server-ip/mgmt via a browser.

Step 2: Pull RTSP Stream from IP Camera​

Once you've created your Oryx, open the dashboard and navigate to Scenarios > Camera > YouTube. Click on Live Stream Source, input the RTSP url, and then click Submit.

Step 2.1: (Optional) Enable Extra Silent Audio Track​

If your camera only provides a video stream, you should enable an additional silent audio track, otherwise, publishing to live platforms like YouTube will fail. Oryx can automatically generate a silent audio track for you. Please choose the Silent Audio Stream option.

Oryx will automatically generate a silent audio track, when forwarding the RTSP stream.

Step 3: Stream IP Camera to YouTube​

To stream your file to YouTube, copy the Stream URL and Stream key from your YouTube Go live page.

Open the Oryx dashboard and click on Scenarios > Camera > YouTube. And click Start Camera Live in Oryx.

Your stream will now be published on YouTube.

Step 4: Check Camera Live Status​

To monitor the status of your camera live event, simply check the dashboard. You'll be able to see the status of all your camera live events, ensuring that everything is running smoothly.

Step 5: Stream IP Camera to Twitch​

After setup RTSP stream, you can stream your IP Camera to Twitch, copy the Stream key from your Twitch Dashboard under Settings > Stream.

Open the Oryx dashboard and click on Scenarios > Camera > Twitch. Click Start Camera Live in Oryx.

And your stream will be published on Twitch in the Stream Manager.

Step 5: Stream IP Camera to Facebook​

After setup RTSP stream, you can stream your IP Camera to Facebook, copy the Stream key from your Facebook Live Producer page, then click Go live, and select Streaming software.

Open the Oryx dashboard and click on Scenarios > Camera > Facebook. Click Start Camera Live in Oryx, and your stream will be published on Facebook.

Cloud Service​

At SRS, our goal is to establish a non-profit, open-source community dedicated to creating an all-in-one, out-of-the-box, open-source video solution for live streaming and WebRTC online services.

Additionally, we offer a Cloud service for those who prefer to use cloud service instead of building from scratch. Our cloud service features global network acceleration, enhanced congestion control algorithms, client SDKs for all platforms, and some free quota.

To learn more about our cloud service, click here.

Conclusion​

In conclusion, streaming your RTSP IP camera to popular platforms like YouTube, Twitch, or Facebook has never been easier, thanks to Oryx. With just a few simple steps, you can set up your IP camera for continuous 24/7 streaming on these platforms. By utilizing Oryx, you can also connect multiple IP cameras and stream live to various platforms, enhancing your live streaming experience. So, go ahead and give Oryx a try, and enjoy the convenience and flexibility it offers for your IP camera streaming needs.

Contact​

Welcome for more discussion at discord.

Virtual live events refers to converting recorded video files, devices, or network streams into live broadcasts and pushing them to live streaming platforms. For example, in e-commerce live streaming, you can pre-record product explanations and demonstrations. In educational live streaming, you can pre-record lessons and play them in the live classroom. For online speeches and sharing, you can play pre-recorded content in the live room.

Virtual live events allows streamers to have plenty of preparation time, making the content more polished. It helps reduce anxiety for inexperienced streamers, prevents network issues, enables 24/7 live streaming, reaches a wider audience, and offers more possibilities for live broadcasts.

Oryx enables you to create virtual live events with just one click, broadcasting them to multiple platforms like YouTube, Twitch, and Facebook. In this blog post, we'll walk you through the steps to create a virtual live event using Oryx.

In today's fast-paced world, virtual live events are becoming increasingly popular due to the convenience they offer. Whether it's a concert, a soccer game, or an online course, you can now create a virtual live event with your video files, making them more interactive and accessible to a wider audience.

Step 1: Create Oryx by One Click​

Creating an Oryx is simple and can be done with just one click if you use Digital Ocean droplet. Please see How to Setup a Video Streaming Service by 1-Click for detail.

You can also use Docker to create an Oryx with a single command line:

docker run --rm -it -p 80:2022 -p 443:2443 -p 1935:1935 \
  -p 8080:8080 -p 8000:8000/udp -p 10080:10080/udp --name oryx \
  -v $HOME/data:/data ossrs/oryx:5

After creating the Oryx, you can access it through http://your-server-ip/mgmt via a browser.

Step 2: Upload your video file​

Once you've created your Oryx, open the dashboard and navigate to Scenarios > VirtualLive > YouTube. Click on Choose File, select your video file, and then click Upload File.

Step 3: Stream file to YouTube​

To stream your file to YouTube, copy the Stream URL and Stream key from your YouTube Go live page.

Open the Oryx dashboard and click on Scenarios > VirtualLive > YouTube. And click Start Virtual Live in Oryx.

Your stream will now be published on YouTube.

Step 4: Check virtual live status​

To monitor the status of your virtual live event, simply check the dashboard. You'll be able to see the status of all your virtual live events, ensuring that everything is running smoothly.

Step 5: Stream file to Twitch​

After uploading file, you can stream your file to Twitch, copy the Stream key from your Twitch Dashboard under Settings > Stream.

Open the Oryx dashboard and click on Scenarios > VirtualLive > Twitch. Click Start Virtual Live in Oryx.

And your stream will be published on Twitch in the Stream Manager.

Step 5: Stream file to Facebook​

After uploading file, you can stream your file to Facebook, copy the Stream key from your Facebook Live Producer page, then click Go live, and select Streaming software.

Open the Oryx dashboard and click on Scenarios > VirtualLive > Facebook. Click Start Virtual Live in Oryx, and your stream will be published on Facebook.

(Optional) Upload Video File by Other Tools​

You can also upload the video file to the /data/upload folder using tools like FTP or SCP. After that, choose Use server file, enter the video file's path, and utilize it as a virtual live source.

This method enables you to upload very large files, particularly when webpage-based uploads fail. By using professional upload tools, you can resume uploads or accelerate the process with multi-threading and other features.

Cloud Service​

At SRS, our goal is to establish a non-profit, open-source community dedicated to creating an all-in-one, out-of-the-box, open-source video solution for live streaming and WebRTC online services.

Additionally, we offer a Cloud service for those who prefer to use cloud service instead of building from scratch. Our cloud service features global network acceleration, enhanced congestion control algorithms, client SDKs for all platforms, and some free quota.

To learn more about our cloud service, click here.

Conclusion​

In conclusion, virtual live events provide a convenient and efficient way to broadcast pre-recorded content on various platforms, making it more polished and accessible to a wider audience. By reducing anxiety for inexperienced streamers and enabling 24/7 streaming, virtual live events offer numerous possibilities for various industries. Oryx simplifies the process of creating and broadcasting these events, catering to the increasing demand for such interactive experiences in today's fast-paced world.

Contact​

Welcome for more discussion at discord.

With Oryx, you can easily record your live streaming and publish it on a web page for your audience to access. In this blog, we will guide you through the process of recording live streaming to an MP4 file using Oryx.

Live streaming has become increasingly popular, and many content creators want to record their live streams for later use or to provide their audience with video-on-demand (VoD) content. While there are various methods to record live streams, such as using OBS, some embedded devices may not support recording or may be difficult to control. In such cases, server-side recording can be a more efficient solution.

Step 1: Create Oryx by One Click​

Creating an Oryx is simple and can be done with just one click if you use Digital Ocean droplet. Please see How to Setup a Video Streaming Service by 1-Click for detail.

You can also use Docker to create an Oryx with a single command line:

docker run --rm -it -p 80:2022 -p 443:2443 -p 1935:1935 \
  -p 8080:8080 -p 8000:8000/udp -p 10080:10080/udp --name oryx \
  -v $HOME/data:/data ossrs/oryx:5

After creating the Oryx, you can access it through http://your-server-ip/mgmt via a browser.

Step 2: Publish a live stream to Oryx​

You can use OBS or FFmpeg to publish a live stream to Oryx. You can also set up HTTPS and publish via WebRTC.

Once the stream is published, you can preview it using an H5 player or VLC. Please see How to Setup a Video Streaming Service by 1-Click for detail.

Step 3: Record the Live Stream by Oryx​

Once your live stream is published, you can start recording it using Oryx. To do this, open the Scenarios > Record > Setup Record Rules section and click the Start Record button.

The recording process will begin, and you can monitor the progress of your recording tasks.

Step 4: Stop and Download MP4 File​

When you want to stop recording, click the Stop Record button in the Setup Record Rules section. Wait for a few seconds for the recording to stop. If the live stream is no longer being published, Oryx will automatically stop the recording task after a few minutes (e.g., 5 minutes).

After the recording has stopped, Oryx will transmux the recorded file to MP4 format. You can then preview and download the MP4 file for further use or distribution.

How to Record Specific Streams?​

See How to Record a Specific Stream

How to Record to S3 Cloud Storage?​

See How to Record to S3 Cloud Storage

How to Merge to One Mp4 File?​

See Recording Doesn't Stop When the Stream is Stopped and How to Quickly Generate a Recorded File

Cloud Service​

At SRS, our goal is to establish a non-profit, open-source community dedicated to creating an all-in-one, out-of-the-box, open-source video solution for live streaming and WebRTC online services.

Additionally, we offer a Cloud service for those who prefer to use cloud service instead of building from scratch. Our cloud service features global network acceleration, enhanced congestion control algorithms, client SDKs for all platforms, and some free quota.

To learn more about our cloud service, click here.

Conclusion​

Recording live streaming to an MP4 file is a valuable feature for content creators who want to provide their audience with video-on-demand content. With Oryx, the process of recording, stopping, and downloading your live streams is simplified, making it easy for you to manage and distribute your recorded content. By following the steps outlined in this blog, you can quickly and efficiently record your live streams and make them available for your audience to access whenever they want.

Contact​

Welcome for more discussion at discord.

Oryx is a powerful and easy-to-use solution that allows you to live stream to multiple platforms with just a few clicks. It also enables you to stream to your own platform or even set up an intranet live stream within your company. Let's dive into the steps to set up live streaming on multiple platforms using Oryx.

Step 1: Create Oryx by One Click​

Creating an Oryx is simple and can be done with just one click if you use Digital Ocean droplet. Please see How to Setup a Video Streaming Service by 1-Click for detail.

You can also use Docker to create an Oryx with a single command line:

docker run --rm -it -p 80:2022 -p 443:2443 -p 1935:1935 \
  -p 8080:8080 -p 8000:8000/udp -p 10080:10080/udp --name oryx \
  -v $HOME/data:/data ossrs/oryx:5

After creating the Oryx, you can access it through http://your-server-ip/mgmt via a browser.

Step 2: Publish a live stream to Oryx​

You can use OBS or FFmpeg to publish a live stream to Oryx. You can also set up HTTPS and publish via WebRTC.

Once the stream is published, you can preview it using an H5 player or VLC. Please see How to Setup a Video Streaming Service by 1-Click for detail.

Step 3: Forward to YouTube​

To forward your stream to YouTube, copy the Stream URL and Stream key from your YouTube Go live page.

Open the Oryx dashboard and click on Scenarios > Forward > YouTube. And click Start Forward in Oryx.

Your stream will now be published on YouTube.

Step 4: Forward to Twitch​

To forward your stream to Twitch, copy the Stream key from your Twitch Dashboard under Settings > Stream.

Open the Oryx dashboard and click on Scenarios > Forward > Twitch. Click Start Forward in Oryx.

And your stream will be published on Twitch in the Stream Manager.

Step 5: Forward to Facebook​

To forward your stream to Facebook, copy the Stream key from your Facebook Live Producer page, then click Go live, and select Streaming software.

Open the Oryx dashboard and click on Scenarios > Forward > Facebook. Click Start Forward in Oryx, and your stream will be published on Facebook.

Step 6: Check Multiple Streaming Status​

After publishing your stream on all platforms, you can check the multiple streaming status in the Oryx dashboard.

Cloud Service​

At SRS, our goal is to establish a non-profit, open-source community dedicated to creating an all-in-one, out-of-the-box, open-source video solution for live streaming and WebRTC online services.

Additionally, we offer a Cloud service for those who prefer to use cloud service instead of building from scratch. Our cloud service features global network acceleration, enhanced congestion control algorithms, client SDKs for all platforms, and some free quota.

To learn more about our cloud service, click here.

Conclusion​

Live streaming to multiple platforms is an effective way to reach a broader audience and increase engagement. Oryx makes this process simple and efficient, allowing you to focus on creating quality content while it takes care of the technical aspects. By following the steps outlined in this blog, you can easily set up live streaming on multiple platforms like YouTube, Twitch, and Facebook, and take your content to the next level.

Contact​

Welcome for more discussion at discord.

The Importance of Authentication in Live Streaming​

When publishing a live stream on platforms like YouTube or Twitch, users need to obtain a stream key and use broadcasting software like OBS to publish the live stream to the platform. Maintaining the confidentiality of your stream key is essential, as anyone who obtains it can stream on your behalf, potentially publishing prohibited content and resulting in your account being blocked by the platform.

For those looking to build their own live streaming service, ensuring security and authentication becomes even more critical. This is where the Oryx comes in, offering a solution for secure publishing through the use of a publish secret.

However, an overly complex security design can also lead to confusion and difficulty for users, making the streaming platform challenging to use. Therefore, it is crucial to implement a secure yet straightforward solution for authenticating live streaming publishing.

The Oryx Solution for Secure Publishing​

The Oryx is a powerful tool that helps users build their own live streaming service with enhanced security and authentication features. By utilizing a publish secret, the Oryx ensures that only authorized users can publish streams, preventing unauthorized access and protecting your content.

To set up the Oryx for secure publishing, follow these steps:

1. Create an Oryx with just one click. For detailed instructions, visit How to Setup a Video Streaming Service by 1-Click

2. Upon creation, the Oryx will automatically generate a publish secret, such as 5181a08ee6eab86597e913e1f9e4c294. You can set it from System / Authentication / Update Stream Secret.

3. Copy the OBS settings from Scenarios / Streaming, including the Server and StreamKey. For example, the Server might be rtmp://135.98.31.15/live/, and the StreamKey could be livestream?secret=5181a08ee6eab86597e913e1f9e4c294.

4. Open the HLS player to play the stream, such as http://135.98.31.15/live/livestream.m3u8.

For example, you will get the following URLs:

• Publish URL: rtmp://135.98.31.15/live/livestream?secret=5181a08ee6eab86597e913e1f9e4c294
• Play URL: http://135.98.31.15/live/livestream.m3u8

Note that the secret is not included in the play stream URL, preventing viewers from knowing the publish secret and ensuring they can only watch the stream, not publish it.

Supporting Multiple Streams​

The Oryx allows users to support multiple streams by simply changing the resource name (stream name) as needed. For example, change stream name from livestream to movie:

• Publish URL: rtmp://135.98.31.15/live/movie?secret=5181a08ee6eab86597e913e1f9e4c294
• Play URL: http://135.98.31.15/live/movie.m3u8

Or you can change livestream to sport:

• Publish URL: rtmp://135.98.31.15/live/sport?secret=5181a08ee6eab86597e913e1f9e4c294
• Play URL: http://135.98.31.15/live/sport.m3u8

You can use any name you prefer, for example, the-10-years-anually-for-you:

• Publish URL: rtmp://135.98.31.15/live/the-10-years-anually-for-you?secret=5181a08ee6eab86597e913e1f9e4c294
• Play URL: http://135.98.31.15/live/the-10-years-anually-for-you.m3u8

Note: Please note that all streams share the same publish secret.

The Oryx allows for an unlimited number of simultaneous streams, with the only constraint being your server's bandwidth capacity. Additionally, you have the freedom to choose any desired stream name.

Limitations of the Oryx​

Nevertheless, the Oryx has a few limitations.

As of now, it only supports authentication for publishing streams using a global secret applicable to all streams. It does not provide individual secrets for each stream in an effort to maintain simplicity.

Additionally, unlike YouTube and Twitch, the Oryx does not support changing stream names, which use different names for publishing and playing. This can be confusing and complex, as it requires an additional system to manage the mapping of filenames.

Finally, the Oryx does not have authentication support for playing streams at the moment, making the stream view public and accessible to anyone. If you would like to limit the playback of the stream, please let us know. This feature is included in the milestone, but there is no specific timeline for its implementation.

Cloud Service​

At SRS, our goal is to establish a non-profit, open-source community dedicated to creating an all-in-one, out-of-the-box, open-source video solution for live streaming and WebRTC online services.

Additionally, we offer a Cloud service for those who prefer to use cloud service instead of building from scratch. Our cloud service features global network acceleration, enhanced congestion control algorithms, client SDKs for all platforms, and some free quota.

To learn more about our cloud service, click here.

Conclusion​

In summary, security and authentication are vital aspects of live streaming, and the Oryx provides a straightforward solution for those building their own streaming services. By following the steps outlined in this guide, you can ensure that your live streaming service remains secure and accessible only to authorized users.

Contact​

Welcome for more discussion at discord.

Without OBS WHIP, you can employ RTMP+WebRTC for live streaming, which results in a latency of approximately 500ms. However, by using OBS WHIP, you can achieve low-latency live streaming with a latency of around 200ms.

Furthermore, even in situations with poor network connections or when streaming over the internet, OBS WHIP maintains a consistently low and stable latency.

In this tutorial, I will demonstrate how to effortlessly utilize OBS WHIP with SRS in just three simple steps.

The Oryx also supports OBS WHIP, enabling you to establish a WHIP service with just one click. Refer to Effortlessly Create a Public Internet WHIP Service for OBS.

You can also watch the video on YouTube: Ultra Low Latency Streaming with OBS WHIP

Prerequisites​

Please install the following software before proceeding:

• OBS Studio

Note: OBS WHIP has been merged into the master branch and will be released in OBS 30. You can download it from here.

Step 1: Run SRS​

Run the following command to start SRS:

CANDIDATE="192.168.1.10"
docker run --rm -it -p 1935:1935 -p 1985:1985 -p 8080:8080 \
    --env CANDIDATE=$CANDIDATE -p 8000:8000/udp \
    ossrs/srs:5 ./objs/srs -c conf/rtmp2rtc.conf

Note: Please set the CANDIDATE to your own IP. About CANDIDATE, please read CANDIDATE

For configuration details, refer to this post.

Step 2: Run OBS​

Open OBS and click Settings to configure the following:

1. Open OBS and click Settings.
2. Click Stream on the left sidebar.
3. Select WHIP for Service.
4. Set the Server to http://localhost:1985/rtc/v1/whip/?app=live&stream=livestream.
5. Click OK to save the settings.
6. Click Start Streaming to start streaming.
7. If the latency is large, setup the OBS Output by: For OBS encoder, select the x264 encoder and in the advanced settings, set the GOP (Keyframe interval) to 1 s. Choose Preset as fast, Profile as baseline, and Tune as zerolatency.

Step 3: Play the Stream​

Open the following URL in your browser to play the stream:

http://localhost:8080/players/whep.html

Cloud Service and Support​

I tested the TRTC cloud service and it works great with OBS WHIP. If you're looking for a WHIP cloud service that has 24/7 support, I definitely suggest trying TRTC. To see a demo, click here.

Cloud Service​

At SRS, our goal is to establish a non-profit, open-source community dedicated to creating an all-in-one, out-of-the-box, open-source video solution for live streaming and WebRTC online services.

Additionally, we offer a Cloud service for those who prefer to use cloud service instead of building from scratch. Our cloud service features global network acceleration, enhanced congestion control algorithms, client SDKs for all platforms, and some free quota.

To learn more about our cloud service, click here.

Conclusion​

In this tutorial, we explored the ultra-low latency live streaming capabilities of OBS WHIP and demonstrated how to set it up with SRS in just three simple steps. OBS WHIP significantly reduces latency, making it an excellent option for low-latency live streaming.

Contact​

If you're interested in discussing SRS, feel free to join us on Discord.

You can also watch the video on YouTube: Unlock the Power of SRS: Real-World Use Cases and Boosting Your Business with Simple Realtime Server.

Introduction​

Hello, I'm Winlin!

I founded SRS, which stands for Simple Realtime Server, or "SARS" for short.

SRS is an easy-to-use, efficient, real-time video server that supports various protocols like RTMP, WebRTC, HLS, HTTP-FLV, SRT, and MPEG-DASH.

In this video, I'll talk about some common ways people use SRS.

Project Compare, an open-source media gateway server.​

There are several well-known open-source media servers out there, like NginxRTMP for live streaming, Janus and Mediasoup for WebRTC, and of course, SRS for everything.

We started the SRS project back in 2013, initially supporting RTMP and HLS with latencies of 1-3 seconds and 5-10 seconds, respectively. SRS also worked with HTTP-FLV and HTTP-TS, which are similar to RTMP.

In 2020, we expanded our community and added support for WebRTC and SRT, allowing for sub-second latency. SRT latency is around 300-500 ms, while WebRTC latency is between 80-200 ms.

SRS acts as a media gateway, converting between RTMP, SRT, and WebRTC, so you don't need three separate servers.

We've also updated our documentation and website, which you can check out at ossrs.io. SRS has come a long way, but there's still more to do. We're building a global community on Discord, helping many developers and earning their gratitude.

Now, let me introduce you to some of the ways people use SRS.

Live Origin Cluter, converting streams is essential.​

The first use case is the origin cluster, which is a group of origin servers.

An origin server is a fundamental and essential server that works as an SRS gateway, receiving and converting streams from publishers.

Unlike Edge or Proxy servers that scale out the origin server, the origin server is critical. By default, an SRS server acts as an origin server, serving as a streaming hub that collects streams from various publishers.

You can send live streams via RTMP, SRT, or WebRTC to the origin server, which then converts them to HLS, HTTP-FLV, RTMP, SRT, and WebRTC.

You can also pull streams from the origin server, transcode, DVR, or forward them to other servers, and even deliver them to a CDN or create a CDN using SRS.

In short, this is a key feature of SRS.

Vrtual Live Streaming, boosting business with virtual live streaming.​

Are you a video blogger with lots of high-quality videos? Have you thought about setting up a live room to grow your business?

With Oryx, you can easily turn your video files into live streams and engage your audience without having to live-stream yourself.

Oryx lets you create virtual live-streaming 24/7 in just three steps: upload your videos, set up a live room (like a YouTube live room), and copy-paste the stream key to start live streaming.

It's easy, doesn't require any media streaming expertise, and Oryx can even restream your live streams to other platforms for free since it's open source.

Video Blogger, empower video bloggers with live streaming.​

If you own a WordPress site, you may have considered adding live streaming, which was previously not possible due to WordPress's limitations.

But now, with the SRS Player WordPress plugin, you can incorporate live streaming using HTTP-FLV, HLS, and WebRTC, as well as video-on-demand streaming via HTTP-MP4.

Simply embed the live-streaming player with a WordPress shortcode, which you can find in the Oryx console.

This powerful plugin makes live streaming accessible to everyone, even in WooCommerce, a widely-used e-commerce plugin for WordPress, showcasing the impact of open source technology.

Unity WebRTC Streaming, make Unity work with WebRTC SFU.​

SRS Unity shows how Unity developers can integrate live streaming with a WebRTC SDK that's compatible with SRS.

You can send the Unity Camera feed to SRS and play the stream in a browser, retrieve the stream from SRS and display it in a Unity game, or enable multiple Unity games to interact using WebRTC.

In this scenario, SRS serves as a WebRTC SFU server, which is essential for WebRTC Unity clients in a production setting.

WebRTC P2P isn't reliable in real-world situations, but an SFU server provides improved network quality, scalability, and support for WebRTC-RTMP conversion.

Plus, you can record WebRTC streams as video-on-demand files, and SRS works with the Unity WebRTC SDK, Unity AR, and VR.

Remote Broadcasting & Content Creator, enables remote content creation in broadcasting.​

SRS can be employed in the broadcast industry to develop a remote content creation system.

The original camera feed is sent to SRS and accessed remotely by an editor, who adds watermarks and logos to the edited stream.

With SRT, latency is around 300-500 ms, enabling real-time editing and switching between camera feeds.

Low latency ensures all streams are synchronized, making it a powerful tool for remote content creation.

You can edit from a distance without being on location and produce multiple streams at once, even generating HDR content using HEVC or AV1.

Video & Audio AI Process, real-time AI processing makes more possibilities.​

SRS is also useful in the AI field for video and audio processing. Receive streams from SRS and process them with AI models, like using deepfake for face swapping.

SRS is compatible with AI models for audio processing, as shown by the srs-k2 project, which demonstrates how to use SRS with k2-fsa for ASR (Kaldi 2.0, a popular open-source ASR toolkit).

The end-to-end latency of srs-k2 is around 400-800 ms, and it can be used in WebRTC for multi-language real-time communication systems. This allows for conversations with people in various languages and integration with the AIGC system.

HEVC/AV1 for AV/AR/8K, reduce the cost significantly.​

To cut your live-streaming expenses by half, think about using HEVC or AV1.

AV1 is a new, open-source, royalty-free video codec, but its hardware decoder isn't as common as HEVC. However, it's quickly gaining traction and looks promising for the future.

HEVC is a widely adopted codec in the industry, supported by OBS through RTMP and SRT. Send the HEVC stream to SRS using OBS, and play the stream with H5 player, mpegjs.js, VLC, or ffplay.

HEVC or AV1 is essential for 8K live-streaming and is becoming popular in the VR/AR field.

Restream to Multiple Platforms, restream to multiple platforms without extra cost.​

Do you want to broadcast your live streams on multiple platforms like YouTube, Facebook, Twitch, and TikTok?

The Oryx simplifies this task and doesn't use up your bandwidth since it takes care of the restreaming for you.

SRS Prometheus Exporter, make SRS an operatable online product.​

Prometheus, a well-known open-source monitoring system, is natively supported by SRS through its exporter, letting you keep an eye on the SRS server.

Visualize metrics with Grafana, and look forward to Prometheus and Grafana being integrated into the Oryx in the future.

To back the project, think about donating via OpenCollective.

Cloud Service​

At SRS, our goal is to establish a non-profit, open-source community dedicated to creating an all-in-one, out-of-the-box, open-source video solution for live streaming and WebRTC online services.

Additionally, we offer a Cloud service for those who prefer to use cloud service instead of building from scratch. Our cloud service features global network acceleration, enhanced congestion control algorithms, client SDKs for all platforms, and some free quota.

To learn more about our cloud service, click here.

Support, contributions and donations are welcome.​

Thanks for watching this video on SRS (Simple Realtime Server). If you found it helpful, please give it a thumbs up and subscribe to our channel for more short videos like this. See you in the next one!

Contact​

Welcome for more discussion at discord.

Written by Winlin and GPT4

While Open Broadcaster Software (OBS) is a widely used solution for live-streaming to YouTube via RTMP or RTMPS, there is an alternative approach that leverages a web browser.

This method involves streaming your camera using WebRTC within a webpage, then employing Simple Realtime Server (SRS) to convert WebRTC to RTMP, and using FFmpeg to publish the RTMP stream to YouTube. For those who prefer RTMPS, FFmpeg can be utilized to extract the stream from SRS via RTMP, transcode it to RTMPS, and subsequently publish it to YouTube.

Step 1: Setting Up SRS​

First, obtain SRS by cloning it from the GitHub repository:

git clone https://github.com/ossrs/srs.git

Then, compile SRS by executing:

./configure && make

Lastly, launch SRS with the command:

./objs/srs -c conf/rtc2rtmp.conf

To confirm the successful installation, access http://localhost:8080 in your web browser.

Step 2: Streaming WebRTC to SRS​

Open the webpage http://localhost:8080/players/whip.html to transmit your camera stream to SRS via WebRTC.

To preview the RTMP stream, utilize VLC to play rtmp://localhost/live/livestream.

Step 3: Routing RTMP to YouTube​

Access the YouTube live-streaming dashboard at https://youtube.com/livestreaming/dashboard.

Acquire the stream server (e.g., rtmp://a.rtmp.youtube.com/live2) and stream key (e.g., 9xxx-8yyy-3zzz-3iii-7jjj).

Use FFmpeg to extract the RTMP stream from SRS and forward it to YouTube with this command:

ffmpeg -i rtmp://localhost/live/livestream -c copy \
  -f flv rtmp://a.rtmp.youtube.com/live2/9xxx-8yyy-3zzz-3iii-7jjj

Step 4: Routing RTMPS to YouTube​

To transmit the stream via RTMPS, modify the RTMP URL from rtmp://a.rtmp.youtube.com/live2/9xxx-8yyy-3zzz-3iii-7jjj to the RTMPS URL, such as rtmps://a.rtmp.youtube.com:443/live2/9xxx-8yyy-3zzz-3iii-7jjj.

ffmpeg -i rtmp://localhost/live/livestream -c copy \
  -f flv rtmps://a.rtmp.youtube.com:443/live2/9xxx-8yyy-3zzz-3iii-7jjj

Cloud Service​

At SRS, our goal is to establish a non-profit, open-source community dedicated to creating an all-in-one, out-of-the-box, open-source video solution for live streaming and WebRTC online services.

Additionally, we offer a Cloud service for those who prefer to use cloud service instead of building from scratch. Our cloud service features global network acceleration, enhanced congestion control algorithms, client SDKs for all platforms, and some free quota.

To learn more about our cloud service, click here.

Conclusion​

By adhering to these instructions, you can effectively live stream to YouTube via RTMP or RTMPS using a web browser. This technique offers a practical alternative to OBS, enabling you to harness the power of WebRTC, SRS, and FFmpeg for a smooth and efficient streaming experience.

Contact​

Welcome for more discussion at discord.