1 /*
2 * This file is part of FFmpeg.
3 *
4 * FFmpeg is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * FFmpeg is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with FFmpeg; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17 */
18
19 /**
20 * @file
21 * Reliable Internet Streaming Transport protocol
22 */
23
24 #include "libavutil/avassert.h"
25 #include "libavutil/avstring.h"
26 #include "libavutil/opt.h"
27 #include "libavutil/parseutils.h"
28 #include "libavutil/time.h"
29
30 #include "avformat.h"
31 #include "internal.h"
32 #include "network.h"
33 #include "os_support.h"
34 #include "url.h"
35
36 #include <librist/librist.h>
37 #include <librist/version.h>
38
39 // RIST_MAX_PACKET_SIZE - 28 minimum protocol overhead
40 #define MAX_PAYLOAD_SIZE (10000-28)
41 #define FIFO_SIZE_DEFAULT 8192
42
43 typedef struct RISTContext {
44 const AVClass *class;
45
46 int profile;
47 int buffer_size;
48 int packet_size;
49 int log_level;
50 int encryption;
51 int fifo_size;
52 int overrun_nonfatal;
53 char *secret;
54
55 struct rist_logging_settings logging_settings;
56 struct rist_peer_config peer_config;
57
58 struct rist_peer *peer;
59 struct rist_ctx *ctx;
60 } RISTContext;
61
62 #define D AV_OPT_FLAG_DECODING_PARAM
63 #define E AV_OPT_FLAG_ENCODING_PARAM
64 #define OFFSET(x) offsetof(RISTContext, x)
65 static const AVOption librist_options[] = {
66 { "rist_profile","set profile", OFFSET(profile), AV_OPT_TYPE_INT, {.i64=RIST_PROFILE_MAIN}, 0, 2, .flags = D|E, "profile" },
67 { "simple", NULL, 0, AV_OPT_TYPE_CONST, {.i64=RIST_PROFILE_SIMPLE}, 0, 0, .flags = D|E, "profile" },
68 { "main", NULL, 0, AV_OPT_TYPE_CONST, {.i64=RIST_PROFILE_MAIN}, 0, 0, .flags = D|E, "profile" },
69 { "advanced", NULL, 0, AV_OPT_TYPE_CONST, {.i64=RIST_PROFILE_ADVANCED}, 0, 0, .flags = D|E, "profile" },
70 { "buffer_size", "set buffer_size in ms", OFFSET(buffer_size), AV_OPT_TYPE_INT, {.i64=0}, 0, 30000, .flags = D|E },
71 { "fifo_size", "set fifo buffer size, must be a power of 2", OFFSET(fifo_size), AV_OPT_TYPE_INT, {.i64=FIFO_SIZE_DEFAULT}, 32, 262144, .flags = D|E },
72 { "overrun_nonfatal", "survive in case of receiving fifo buffer overrun", OFFSET(overrun_nonfatal), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, D },
73 { "pkt_size", "set packet size", OFFSET(packet_size), AV_OPT_TYPE_INT, {.i64=1316}, 1, MAX_PAYLOAD_SIZE, .flags = D|E },
74 { "log_level", "set loglevel", OFFSET(log_level), AV_OPT_TYPE_INT, {.i64=RIST_LOG_INFO}, -1, INT_MAX, .flags = D|E },
75 { "secret", "set encryption secret",OFFSET(secret), AV_OPT_TYPE_STRING,{.str=NULL}, 0, 0, .flags = D|E },
76 { "encryption","set encryption type",OFFSET(encryption), AV_OPT_TYPE_INT ,{.i64=0}, 0, INT_MAX, .flags = D|E },
77 { NULL }
78 };
79
risterr2ret(int err)80 static int risterr2ret(int err)
81 {
82 switch (err) {
83 case RIST_ERR_MALLOC:
84 return AVERROR(ENOMEM);
85 default:
86 return AVERROR_EXTERNAL;
87 }
88 }
89
log_cb(void *arg, enum rist_log_level log_level, const char *msg)90 static int log_cb(void *arg, enum rist_log_level log_level, const char *msg)
91 {
92 int level;
93
94 switch (log_level) {
95 case RIST_LOG_ERROR: level = AV_LOG_ERROR; break;
96 case RIST_LOG_WARN: level = AV_LOG_WARNING; break;
97 case RIST_LOG_NOTICE: level = AV_LOG_INFO; break;
98 case RIST_LOG_INFO: level = AV_LOG_VERBOSE; break;
99 case RIST_LOG_DEBUG: level = AV_LOG_DEBUG; break;
100 case RIST_LOG_DISABLE: level = AV_LOG_QUIET; break;
101 default: level = AV_LOG_WARNING;
102 }
103
104 av_log(arg, level, "%s", msg);
105
106 return 0;
107 }
108
librist_close(URLContext *h)109 static int librist_close(URLContext *h)
110 {
111 RISTContext *s = h->priv_data;
112 int ret = 0;
113
114 s->peer = NULL;
115
116 if (s->ctx)
117 ret = rist_destroy(s->ctx);
118 s->ctx = NULL;
119
120 return risterr2ret(ret);
121 }
122
librist_open(URLContext *h, const char *uri, int flags)123 static int librist_open(URLContext *h, const char *uri, int flags)
124 {
125 RISTContext *s = h->priv_data;
126 struct rist_logging_settings *logging_settings = &s->logging_settings;
127 struct rist_peer_config *peer_config = &s->peer_config;
128 int ret;
129
130 if ((flags & AVIO_FLAG_READ_WRITE) == AVIO_FLAG_READ_WRITE)
131 return AVERROR(EINVAL);
132
133 s->logging_settings = (struct rist_logging_settings)LOGGING_SETTINGS_INITIALIZER;
134 ret = rist_logging_set(&logging_settings, s->log_level, log_cb, h, NULL, NULL);
135 if (ret < 0)
136 return risterr2ret(ret);
137
138 if (flags & AVIO_FLAG_WRITE) {
139 h->max_packet_size = s->packet_size;
140 ret = rist_sender_create(&s->ctx, s->profile, 0, logging_settings);
141 }
142 if (ret < 0)
143 goto err;
144
145 if (flags & AVIO_FLAG_READ) {
146 h->max_packet_size = MAX_PAYLOAD_SIZE;
147 ret = rist_receiver_create(&s->ctx, s->profile, logging_settings);
148 }
149 if (ret < 0)
150 goto err;
151
152 ret = rist_peer_config_defaults_set(peer_config);
153 if (ret < 0)
154 goto err;
155
156 ret = rist_parse_address2(uri, &peer_config);
157 if (ret < 0)
158 goto err;
159
160 if (flags & AVIO_FLAG_READ) {
161 ret = rist_receiver_set_output_fifo_size(s->ctx, s->fifo_size);
162 if (ret != 0)
163 goto err;
164 }
165
166 if (((s->encryption == 128 || s->encryption == 256) && !s->secret) ||
167 ((peer_config->key_size == 128 || peer_config->key_size == 256) && !peer_config->secret[0])) {
168 av_log(h, AV_LOG_ERROR, "secret is mandatory if encryption is enabled\n");
169 librist_close(h);
170 return AVERROR(EINVAL);
171 }
172
173 if (s->secret && peer_config->secret[0] == 0)
174 av_strlcpy(peer_config->secret, s->secret, RIST_MAX_STRING_SHORT);
175
176 if (s->secret && (s->encryption == 128 || s->encryption == 256))
177 peer_config->key_size = s->encryption;
178
179 if (s->buffer_size) {
180 peer_config->recovery_length_min = s->buffer_size;
181 peer_config->recovery_length_max = s->buffer_size;
182 }
183
184 ret = rist_peer_create(s->ctx, &s->peer, &s->peer_config);
185 if (ret < 0)
186 goto err;
187
188 ret = rist_start(s->ctx);
189 if (ret < 0)
190 goto err;
191
192 return 0;
193
194 err:
195 librist_close(h);
196
197 return risterr2ret(ret);
198 }
199
librist_read(URLContext *h, uint8_t *buf, int size)200 static int librist_read(URLContext *h, uint8_t *buf, int size)
201 {
202 RISTContext *s = h->priv_data;
203 int ret;
204
205 struct rist_data_block *data_block;
206 ret = rist_receiver_data_read2(s->ctx, &data_block, POLLING_TIME);
207
208 if (ret < 0)
209 return risterr2ret(ret);
210
211 if (ret == 0)
212 return AVERROR(EAGAIN);
213
214 if (data_block->payload_len > MAX_PAYLOAD_SIZE) {
215 rist_receiver_data_block_free2(&data_block);
216 return AVERROR_EXTERNAL;
217 }
218
219 if (data_block->flags & RIST_DATA_FLAGS_OVERFLOW) {
220 if (!s->overrun_nonfatal) {
221 av_log(h, AV_LOG_ERROR, "Fifo buffer overrun. "
222 "To avoid, increase fifo_size option. "
223 "To survive in such case, use overrun_nonfatal option\n");
224 size = AVERROR(EIO);
225 goto out_free;
226 }
227 }
228
229 size = data_block->payload_len;
230 memcpy(buf, data_block->payload, size);
231 out_free:
232 rist_receiver_data_block_free2(&data_block);
233 return size;
234 }
235
librist_write(URLContext *h, const uint8_t *buf, int size)236 static int librist_write(URLContext *h, const uint8_t *buf, int size)
237 {
238 RISTContext *s = h->priv_data;
239 struct rist_data_block data_block = { 0 };
240 int ret;
241
242 data_block.ts_ntp = 0;
243 data_block.payload = buf;
244 data_block.payload_len = size;
245
246 ret = rist_sender_data_write(s->ctx, &data_block);
247 if (ret < 0)
248 return risterr2ret(ret);
249
250 return ret;
251 }
252
253 static const AVClass librist_class = {
254 .class_name = "librist",
255 .item_name = av_default_item_name,
256 .option = librist_options,
257 .version = LIBAVUTIL_VERSION_INT,
258 };
259
260 const URLProtocol ff_librist_protocol = {
261 .name = "rist",
262 .url_open = librist_open,
263 .url_read = librist_read,
264 .url_write = librist_write,
265 .url_close = librist_close,
266 .priv_data_size = sizeof(RISTContext),
267 .flags = URL_PROTOCOL_FLAG_NETWORK,
268 .priv_data_class = &librist_class,
269 };
270