1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
|
// The contents of this file are in the public domain. See LICENSE_FOR_EXAMPLE_PROGRAMS.txt
/*
This is an example illustrating the use of the ffmpeg wrappers.
It decodes a video, pushes frames over an RTSP client connection and receives on another RTSP server connection.
Please see all the other ffmpeg examples:
- ffmpeg_info_ex.cpp
- ffmpeg_video_decoding_ex.cpp
- ffmpeg_video_decoding2_ex.cpp
- ffmpeg_video_demuxing_ex.cpp
- ffmpeg_video_demuxing2_ex.cpp
- ffmpeg_video_encoding_ex.cpp
- ffmpeg_video_muxing_ex.cpp
*/
#include <cstdio>
#include <dlib/media.h>
#include <dlib/cmd_line_parser.h>
#include <dlib/gui_widgets.h>
using namespace std;
using namespace std::chrono;
using namespace std::chrono_literals;
using namespace dlib;
using namespace dlib::ffmpeg;
int main(const int argc, const char** argv)
try
{
command_line_parser parser;
parser.add_option("i", "input video", 1);
parser.add_option("codec", "video codec name. e.g. `h264`. Defaults to `mpeg4`", 1);
parser.add_option("height", "height of encoded stream. Defaults to whatever is in the video file", 1);
parser.add_option("width", "width of encoded stream. Defaults to whatever is in the video file", 1);
parser.set_group_name("Help Options");
parser.add_option("h", "alias of --help");
parser.add_option("help", "display this message and exit");
parser.parse(argc, argv);
const char* one_time_opts[] = {"i", "codec", "height", "width"};
parser.check_one_time_options(one_time_opts);
if (parser.option("h") || parser.option("help"))
{
parser.print_options();
return 0;
}
const std::string input_filepath = parser.option("i").argument();
// First, we open a video which we use to transmit and receive images over RTSP.
demuxer cap({input_filepath, video_enabled, audio_disabled});
if (!cap.is_open())
{
cout << "Failed to open " << input_filepath << endl;
return EXIT_FAILURE;
}
if (!cap.video_enabled())
{
cout << "This video does not contain images." << endl;
return EXIT_FAILURE;
}
const std::string url = "rtsp://0.0.0.0:8000/stream";
// We start 2 threads:
// - 1 for an RTSP server that listens for an incoming RTSP client and decodes the frames
// - 1 for an RTSP client that connects and pushes/muxes image frames.
std::thread rx{[&]
{
// This is an example that show-cases the usage of demuxer::args::format_options.
// This is used for AVFormatContext and demuxer-private options specific to the container.
// {"rtsp_flags", "listen"} tells the RTSP demuxer that it is a server
// {"rtsp_transport", "tcp"} configures RTSP over TCP transport. This way we don't loose any packets.
// We set a listening timeout of 5s.
demuxer cap([&] {
demuxer::args args;
args.filepath = url;
args.format_options["rtsp_flags"] = "listen";
args.format_options["rtsp_transport"] = "tcp";
args.connect_timeout = 5s;
return args;
}());
if (!cap.is_open())
{
cout << "Failed to receive connection from RTSP client" << endl;
return;
}
image_window win;
array2d<rgb_pixel> img;
while (cap.read(img))
win.set_image(img);
}};
std::this_thread::sleep_for(1s);
std::thread tx{[&]
{
// The muxer acts as an RTSP client, so we don't use {"rtsp_flags", "listen"}
// When using RTSP, it is usually a good idea to specify muxer::args::output_format = "rtsp"
// even though the URL has rtsp:// in its address. Whether or not you need to specify args.output_format = "rtsp"
// depends on your version of ffmpeg.
muxer writer([&] {
muxer::args args;
args.filepath = url;
args.output_format = "rtsp";
args.enable_image = true;
args.enable_audio = false;
args.format_options["rtsp_transport"] = "tcp";
args.args_image.codec_name = get_option(parser, "codec", "mpeg4");
args.args_image.h = get_option(parser, "height", cap.height());
args.args_image.w = get_option(parser, "width", cap.width());
args.args_image.fmt = cap.pixel_fmt();
args.args_image.framerate = cap.fps();
return args;
}());
if (!writer.is_open())
{
cout << "Failed to open rtsp server" << endl;
return;
}
frame f;
while (cap.read(f))
writer.push(std::move(f));
}};
tx.join();
rx.join();
return EXIT_SUCCESS;
}
catch (const std::exception& e)
{
printf("%s\n", e.what());
return EXIT_FAILURE;
}
|
