#include "rtsp_server.h"
|
|
#include <iostream>
|
#include <memory>
|
#include <string>
|
|
#include "assert.h"
|
#include "signal.h"
|
#include "stdint.h"
|
#include "stdio.h"
|
#include "unistd.h"
|
|
static std::shared_ptr<easymedia::Flow> video_cap_flow = nullptr;
|
std::shared_ptr<easymedia::Flow> g_video_enc_flow = nullptr;
|
std::shared_ptr<easymedia::Flow> g_video_rtsp_flow = nullptr;
|
std::shared_ptr<easymedia::Flow> video_dump_flow = nullptr;
|
|
std::shared_ptr<easymedia::Flow> create_flow(const std::string& flow_name, const std::string& flow_param,
|
const std::string& elem_param)
|
{
|
auto&& param = easymedia::JoinFlowParam(flow_param, 1, elem_param);
|
// printf("create_flow :\n");
|
// printf("flow_name : %s\n", flow_name.c_str());
|
// printf("param : \n%s\n", param.c_str());
|
auto ret = easymedia::REFLECTOR(Flow)::Create<easymedia::Flow>(flow_name.c_str(), param.c_str());
|
printf(" ####### create_flow flow use_count %d\n", ret.use_count());
|
if (!ret) {
|
fprintf(stderr, "Create flow %s failed\n", flow_name.c_str());
|
}
|
return ret;
|
}
|
|
std::string get_video_cap_flow_param(std::string input_path, std::string pixel_format, int video_width,
|
int video_height)
|
{
|
std::string flow_param;
|
// Reading yuv from camera
|
flow_param = "";
|
PARAM_STRING_APPEND(flow_param, KEY_NAME, "v4l2_capture_stream");
|
// PARAM_STRING_APPEND_TO(flow_param, KEY_FPS, video_fps);
|
PARAM_STRING_APPEND(flow_param, KEK_THREAD_SYNC_MODEL, KEY_SYNC);
|
PARAM_STRING_APPEND(flow_param, KEK_INPUT_MODEL, KEY_DROPFRONT);
|
PARAM_STRING_APPEND_TO(flow_param, KEY_INPUT_CACHE_NUM, 5);
|
return flow_param;
|
}
|
|
std::string get_video_cap_stream_param(std::string input_path, std::string pixel_format, int video_width,
|
int video_height)
|
{
|
std::string stream_param;
|
stream_param = "";
|
PARAM_STRING_APPEND_TO(stream_param, KEY_USE_LIBV4L2, 1);
|
PARAM_STRING_APPEND(stream_param, KEY_DEVICE, input_path);
|
// PARAM_STRING_APPEND(param, KEY_SUB_DEVICE, sub_input_path);
|
PARAM_STRING_APPEND(stream_param, KEY_V4L2_CAP_TYPE, KEY_V4L2_C_TYPE(VIDEO_CAPTURE));
|
PARAM_STRING_APPEND(stream_param, KEY_V4L2_MEM_TYPE, KEY_V4L2_M_TYPE(MEMORY_MMAP));
|
PARAM_STRING_APPEND_TO(stream_param, KEY_FRAMES, 4);
|
PARAM_STRING_APPEND(stream_param, KEY_OUTPUTDATATYPE, pixel_format);
|
PARAM_STRING_APPEND_TO(stream_param, KEY_BUFFER_WIDTH, video_width);
|
PARAM_STRING_APPEND_TO(stream_param, KEY_BUFFER_HEIGHT, video_height);
|
return stream_param;
|
}
|
|
std::shared_ptr<easymedia::Flow> create_video_capture_flow(std::string input_path, std::string pixel_format,
|
int video_width, int video_height)
|
{
|
std::string flow_name;
|
std::string flow_param;
|
std::string stream_param;
|
std::shared_ptr<easymedia::Flow> video_read_flow;
|
|
flow_name = "source_flow";
|
flow_param = get_video_cap_flow_param(input_path, pixel_format, video_width, video_height);
|
stream_param = get_video_cap_stream_param(input_path, pixel_format, video_width, video_height);
|
video_read_flow = create_flow(flow_name, flow_param, stream_param);
|
if (!video_read_flow) {
|
fprintf(stderr, "Create flow %s failed\n", flow_name.c_str());
|
exit(EXIT_FAILURE);
|
}
|
return video_read_flow;
|
}
|
|
std::string get_video_enc_flow_param(std::string pixel_format, std::string video_enc_type, int video_width,
|
int video_height, int video_fps)
|
{
|
std::string flow_param;
|
flow_param = "";
|
PARAM_STRING_APPEND(flow_param, KEY_NAME, "rkmpp");
|
PARAM_STRING_APPEND(flow_param, KEY_INPUTDATATYPE, pixel_format);
|
PARAM_STRING_APPEND(flow_param, KEY_OUTPUTDATATYPE, video_enc_type);
|
return flow_param;
|
}
|
|
std::string get_video_enc_stream_param(std::string pixel_format, std::string video_enc_type, int video_width,
|
int video_height, int video_fps)
|
{
|
std::string stream_param;
|
|
int bps = video_width * video_height * video_fps / 14;
|
stream_param = "";
|
PARAM_STRING_APPEND_TO(stream_param, KEY_BUFFER_WIDTH, video_width);
|
PARAM_STRING_APPEND_TO(stream_param, KEY_BUFFER_HEIGHT, video_height);
|
PARAM_STRING_APPEND_TO(stream_param, KEY_BUFFER_VIR_WIDTH, video_width);
|
PARAM_STRING_APPEND_TO(stream_param, KEY_BUFFER_VIR_HEIGHT, video_height);
|
PARAM_STRING_APPEND_TO(stream_param, KEY_COMPRESS_BITRATE, bps);
|
PARAM_STRING_APPEND_TO(stream_param, KEY_COMPRESS_BITRATE_MAX, bps * 17 / 16);
|
PARAM_STRING_APPEND_TO(stream_param, KEY_COMPRESS_BITRATE_MIN, bps / 16);
|
PARAM_STRING_APPEND(stream_param, KEY_FPS, "30/0");
|
PARAM_STRING_APPEND(stream_param, KEY_FPS_IN, "30/0");
|
PARAM_STRING_APPEND_TO(stream_param, KEY_FULL_RANGE, 1);
|
return stream_param;
|
}
|
|
std::shared_ptr<easymedia::Flow> create_video_enc_flow(std::string pixel_format, std::string video_enc_type,
|
int video_width, int video_height, int video_fps)
|
{
|
std::shared_ptr<easymedia::Flow> video_encoder_flow;
|
|
std::string flow_name;
|
std::string flow_param;
|
std::string stream_param;
|
|
flow_name = "video_enc";
|
flow_param = get_video_enc_flow_param(pixel_format, video_enc_type, video_width, video_height, video_fps);
|
stream_param = get_video_enc_stream_param(pixel_format, video_enc_type, video_width, video_height, video_fps);
|
video_encoder_flow = create_flow(flow_name, flow_param, stream_param);
|
if (!video_encoder_flow) {
|
fprintf(stderr, "Create flow %s failed\n", flow_name.c_str());
|
exit(EXIT_FAILURE);
|
}
|
return video_encoder_flow;
|
}
|
|
std::string get_rtsp_server_flow_param(std::string channel_name, std::string media_type)
|
{
|
std::string flow_param;
|
flow_param = "";
|
PARAM_STRING_APPEND(flow_param, KEY_INPUTDATATYPE, media_type);
|
PARAM_STRING_APPEND(flow_param, KEY_CHANNEL_NAME, channel_name);
|
PARAM_STRING_APPEND_TO(flow_param, KEY_PORT_NUM, 554);
|
return flow_param;
|
}
|
|
std::string get_rtsp_server_stream_param(std::string channel_name, std::string media_type)
|
{
|
std::string stream_param;
|
stream_param = "";
|
return stream_param;
|
}
|
|
std::shared_ptr<easymedia::Flow> create_rtsp_server_flow(std::string channel_name, std::string media_type)
|
{
|
std::shared_ptr<easymedia::Flow> rtsp_flow;
|
|
std::string flow_name;
|
std::string flow_param;
|
std::string stream_param;
|
|
flow_name = "live555_rtsp_server";
|
flow_param = get_rtsp_server_flow_param(channel_name, media_type);
|
stream_param = get_rtsp_server_stream_param(channel_name, media_type);
|
|
rtsp_flow = create_flow(flow_name, flow_param, stream_param);
|
if (!rtsp_flow) {
|
fprintf(stderr, "Create flow %s failed\n", flow_name.c_str());
|
exit(EXIT_FAILURE);
|
}
|
return rtsp_flow;
|
}
|
|
std::string get_rtmp_server_flow_param(std::string stream_addr, std::string output_type)
|
{
|
std::string flow_param;
|
flow_param = "";
|
PARAM_STRING_APPEND(flow_param, KEY_NAME, "muxer_flow");
|
PARAM_STRING_APPEND(flow_param, KEY_PATH, stream_addr);
|
PARAM_STRING_APPEND(flow_param, KEY_OUTPUTDATATYPE, output_type);
|
return flow_param;
|
}
|
|
std::string get_rtmp_server_stream_param(std::string channel_name, std::string media_type)
|
{
|
std::string stream_param;
|
stream_param = "";
|
|
return stream_param;
|
}
|
|
std::shared_ptr<easymedia::Flow> create_rtmp_server_flow(std::string stream_addr, std::string output_type,
|
std::string video_param, std::string audio_param)
|
{
|
std::shared_ptr<easymedia::Flow> rtmp_flow;
|
std::string flow_name;
|
std::string flow_param;
|
std::string muxer_param;
|
|
flow_name = "muxer_flow";
|
flow_param = get_rtmp_server_flow_param(stream_addr, output_type);
|
muxer_param = easymedia::JoinFlowParam(flow_param, 2, video_param, audio_param);
|
|
rtmp_flow = create_flow(flow_name, flow_param, muxer_param);
|
if (!rtmp_flow) {
|
fprintf(stderr, "Create flow %s failed\n", flow_name.c_str());
|
exit(EXIT_FAILURE);
|
}
|
|
return rtmp_flow;
|
}
|
|
std::string get_dump_flow_param(std::string input_type)
|
{
|
std::string flow_param;
|
flow_param = "";
|
PARAM_STRING_APPEND(flow_param, KEY_INPUTDATATYPE, input_type);
|
return flow_param;
|
}
|
|
std::shared_ptr<easymedia::Flow> create_dump_server_flow(std::string input_type)
|
{
|
std::shared_ptr<easymedia::Flow> dump_flow;
|
std::string flow_name;
|
std::string flow_param;
|
|
flow_name = "link_flow";
|
flow_param = get_dump_flow_param(input_type);
|
dump_flow = create_flow(flow_name, flow_param, "");
|
if (!dump_flow) {
|
fprintf(stderr, "Create flow %s failed\n", flow_name.c_str());
|
exit(EXIT_FAILURE);
|
}
|
|
return dump_flow;
|
}
|
|
void deinit_rtsp()
|
{
|
if (video_cap_flow && video_dump_flow) {
|
video_cap_flow->RemoveDownFlow(video_dump_flow);
|
}
|
if (video_cap_flow && g_video_enc_flow) {
|
video_cap_flow->RemoveDownFlow(g_video_enc_flow);
|
}
|
if (g_video_rtsp_flow && g_video_enc_flow) {
|
g_video_enc_flow->RemoveDownFlow(g_video_rtsp_flow);
|
}
|
if (g_video_rtsp_flow) {
|
g_video_rtsp_flow.reset();
|
}
|
if (g_video_enc_flow) {
|
g_video_enc_flow.reset();
|
}
|
if (video_cap_flow) {
|
video_cap_flow.reset();
|
}
|
g_video_rtsp_flow = nullptr;
|
g_video_enc_flow = nullptr;
|
video_cap_flow = nullptr;
|
}
|
|
int init_rtsp(const char* video_dev, int width, int height, std::string enc_type)
|
{
|
deinit_rtsp();
|
|
int fps = 30;
|
std::string yuv_format = IMAGE_NV12;
|
printf("init_rtsp video_dev %s\n", video_dev);
|
|
easymedia::REFLECTOR(Flow)::DumpFactories();
|
easymedia::REFLECTOR(Stream)::DumpFactories();
|
|
video_cap_flow = create_video_capture_flow(video_dev, yuv_format, width, height);
|
g_video_enc_flow = create_video_enc_flow(yuv_format, enc_type, width, height, fps);
|
g_video_rtsp_flow = create_rtsp_server_flow("main_stream", enc_type);
|
video_dump_flow = create_dump_server_flow(yuv_format);
|
|
g_video_enc_flow->AddDownFlow(g_video_rtsp_flow, 0, 0);
|
video_cap_flow->AddDownFlow(g_video_enc_flow, 0, 0);
|
video_cap_flow->AddDownFlow(video_dump_flow, 0, 0);
|
|
if (!video_cap_flow || !video_dump_flow) {
|
return -1;
|
}
|
return 0;
|
}
|
