// Copyright 2019 Fuzhou Rockchip Electronics Co., Ltd. All rights reserved.
|
// Use of this source code is governed by a BSD-style license that can be
|
// found in the LICENSE file.
|
|
#include "flow.h"
|
|
#include <time.h>
|
|
#include <mutex>
|
|
#include <BasicUsageEnvironment/BasicUsageEnvironment.hh>
|
#ifndef _RTSP_SERVER_HH
|
#include <liveMedia/RTSPServer.hh>
|
#endif
|
|
#if !defined(LIVE555_SERVER_H264) && !defined(LIVE555_SERVER_H265)
|
#error "This RTSP !VIDEO! implementation currently only support at least one of h264 and h265!!!"
|
#endif
|
|
#ifdef LIVE555_SERVER_H264
|
#include "h264_server_media_subsession.hh"
|
#endif
|
#ifdef LIVE555_SERVER_H265
|
#include "h265_server_media_subsession.hh"
|
#endif
|
#include "aac_server_media_subsession.hh"
|
#include "live555_media_input.hh"
|
#include "live555_server.hh"
|
#include "mjpeg_server_media_subsession.hh"
|
#include "mp2_server_media_subsession.hh"
|
#include "simple_server_media_subsession.hh"
|
|
#include "buffer.h"
|
#include "codec.h"
|
#include "media_config.h"
|
#include "media_reflector.h"
|
#include "media_type.h"
|
|
namespace easymedia
|
{
|
static bool SendMediaToServer(Flow* f, MediaBufferVector& input_vector);
|
class RtspServerFlow : public Flow
|
{
|
public:
|
RtspServerFlow(const char* param);
|
virtual ~RtspServerFlow();
|
static const char* GetFlowName()
|
{
|
return "live555_rtsp_server";
|
}
|
|
private:
|
Live555MediaInput* server_input;
|
std::shared_ptr<RtspConnection> rtspConnection;
|
|
std::string channel_name;
|
std::string video_type;
|
std::string audio_type;
|
friend bool SendMediaToServer(Flow* f, MediaBufferVector& input_vector);
|
void CallPlayVideoHandler();
|
void CallPlayAudioHandler();
|
};
|
|
bool SendMediaToServer(Flow* f, MediaBufferVector& input_vector)
|
{
|
RtspServerFlow* rtsp_flow = (RtspServerFlow*)f;
|
|
for (auto& buffer : input_vector) {
|
if (!buffer) {
|
continue;
|
}
|
if (buffer && buffer->IsHwBuffer()) {
|
// hardware buffer is limited, copy it
|
auto new_buffer = MediaBuffer::Clone(*buffer.get());
|
new_buffer->SetType(buffer->GetType());
|
buffer = new_buffer;
|
}
|
|
if ((buffer->GetUserFlag() & MediaBuffer::kIntra)) {
|
std::list<std::shared_ptr<easymedia::MediaBuffer>> spspps;
|
if (rtsp_flow->video_type == VIDEO_H264) {
|
spspps = split_h264_separate((const uint8_t*)buffer->GetPtr(), buffer->GetValidSize(),
|
buffer->GetUSTimeStamp());
|
} else if (rtsp_flow->video_type == VIDEO_H265) {
|
spspps = split_h265_separate((const uint8_t*)buffer->GetPtr(), buffer->GetValidSize(),
|
buffer->GetUSTimeStamp());
|
}
|
// Independently send vps, sps, pps packets to live555.
|
for (auto& buf : spspps) {
|
rtsp_flow->server_input->PushNewVideo(buf);
|
}
|
// The original Intr frame information is sent to live555.
|
// At this time it still contains extra information.
|
rtsp_flow->server_input->PushNewVideo(buffer);
|
} else if (buffer->GetType() == Type::Audio) {
|
rtsp_flow->server_input->PushNewAudio(buffer);
|
} else if (buffer->GetType() == Type::Video) {
|
rtsp_flow->server_input->PushNewVideo(buffer);
|
} else {
|
// muxer buffer
|
rtsp_flow->server_input->PushNewMuxer(buffer);
|
}
|
}
|
|
return true;
|
}
|
|
RtspServerFlow::RtspServerFlow(const char* param)
|
{
|
std::list<std::string> input_data_types;
|
std::map<std::string, std::string> params;
|
if (!parse_media_param_map(param, params)) {
|
SetError(-EINVAL);
|
return;
|
}
|
std::string value;
|
CHECK_EMPTY_SETERRNO(value, params, KEY_INPUTDATATYPE, EINVAL)
|
parse_media_param_list(value.c_str(), input_data_types, ',');
|
CHECK_EMPTY_SETERRNO(channel_name, params, KEY_CHANNEL_NAME, EINVAL)
|
|
value = params[KEY_PORT_NUM];
|
int port = std::stoi(value);
|
std::string& username = params[KEY_USERNAME];
|
std::string& userpwd = params[KEY_USERPASSWORD];
|
rtspConnection = RtspConnection::getInstance(port, username, userpwd);
|
int sample_rate = 0, channels = 0, profiles = 0;
|
unsigned bitrate = 0;
|
value = params[KEY_SAMPLE_RATE];
|
if (!value.empty()) {
|
sample_rate = std::stoi(value);
|
}
|
|
value = params[KEY_CHANNELS];
|
if (!value.empty()) {
|
channels = std::stoi(value);
|
}
|
|
value = params[KEY_PROFILE];
|
if (!value.empty()) {
|
profiles = std::stoi(value);
|
}
|
|
value = params[KEY_SAMPLE_FMT];
|
if (!value.empty()) {
|
bitrate = std::stoi(value);
|
}
|
|
if (rtspConnection) {
|
int in_idx = 0;
|
std::string markname;
|
SlotMap sm;
|
|
for (auto& type : input_data_types) {
|
if (type == VIDEO_H264 || type == VIDEO_H265 || type == IMAGE_JPEG) {
|
video_type = type;
|
} else if (type == AUDIO_AAC || type == AUDIO_G711A || type == AUDIO_G711U || type == AUDIO_G726 ||
|
type == AUDIO_MP2 || type == MUXER_MPEG_TS || type == MUXER_MPEG_PS) {
|
audio_type = type;
|
}
|
sm.input_slots.push_back(in_idx);
|
in_idx++;
|
}
|
server_input = rtspConnection->createNewChannel(channel_name, video_type, audio_type, channels, sample_rate,
|
bitrate, profiles);
|
server_input->SetStartVideoStreamCallback(std::bind(&RtspServerFlow::CallPlayVideoHandler, this));
|
server_input->SetStartAudioStreamCallback(std::bind(&RtspServerFlow::CallPlayAudioHandler, this));
|
sm.process = SendMediaToServer;
|
sm.thread_model = Model::ASYNCCOMMON;
|
sm.mode_when_full = InputMode::BLOCKING;
|
sm.input_maxcachenum.push_back(0); // no limit
|
if (sm.input_slots.size() > 1) {
|
sm.input_maxcachenum.push_back(0);
|
}
|
markname = "rtsp " + channel_name + std::to_string(in_idx);
|
if (!InstallSlotMap(sm, markname, 0)) {
|
LOG("Fail to InstallSlotMap, %s\n", markname.c_str());
|
goto err;
|
}
|
} else {
|
goto err;
|
}
|
return;
|
err:
|
SetError(-EINVAL);
|
}
|
|
void RtspServerFlow::CallPlayVideoHandler()
|
{
|
auto handler = GetPlayVideoHandler();
|
if (handler != nullptr) {
|
handler(this);
|
}
|
}
|
|
void RtspServerFlow::CallPlayAudioHandler()
|
{
|
auto handler = GetPlayAudioHandler();
|
if (handler) {
|
handler(this);
|
}
|
}
|
|
RtspServerFlow::~RtspServerFlow()
|
{
|
AutoPrintLine apl(__func__);
|
StopAllThread();
|
SetDisable();
|
if (rtspConnection) {
|
rtspConnection->removeChannel(channel_name);
|
}
|
server_input = nullptr;
|
}
|
|
DEFINE_FLOW_FACTORY(RtspServerFlow, Flow)
|
const char* FACTORY(RtspServerFlow)::ExpectedInputDataType()
|
{
|
return "";
|
}
|
const char* FACTORY(RtspServerFlow)::OutPutDataType()
|
{
|
return "";
|
}
|
|
} // namespace easymedia
|
