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/opt.h"
26 #include "libavutil/parseutils.h"
27 #include "libavutil/time.h"
28
29 #include "avformat.h"
30 #include "internal.h"
31 #include "network.h"
32 #include "os_support.h"
33 #include "url.h"
34
35 #include <librist/librist.h>
36
37 // RIST_MAX_PACKET_SIZE - 28 minimum protocol overhead
38 #define MAX_PAYLOAD_SIZE (10000-28)
39
40 typedef struct RISTContext {
41 const AVClass *class;
42
43 int profile;
44 int buffer_size;
45 int packet_size;
46 int log_level;
47 int encryption;
48 char *secret;
49
50 struct rist_logging_settings logging_settings;
51 struct rist_peer_config peer_config;
52
53 struct rist_peer *peer;
54 struct rist_ctx *ctx;
55 } RISTContext;
56
57 #define D AV_OPT_FLAG_DECODING_PARAM
58 #define E AV_OPT_FLAG_ENCODING_PARAM
59 #define OFFSET(x) offsetof(RISTContext, x)
60 static const AVOption librist_options[] = {
61 { "rist_profile","set profile", OFFSET(profile), AV_OPT_TYPE_INT, {.i64=RIST_PROFILE_MAIN}, 0, 2, .flags = D|E, "profile" },
62 { "simple", NULL, 0, AV_OPT_TYPE_CONST, {.i64=RIST_PROFILE_SIMPLE}, 0, 0, .flags = D|E, "profile" },
63 { "main", NULL, 0, AV_OPT_TYPE_CONST, {.i64=RIST_PROFILE_MAIN}, 0, 0, .flags = D|E, "profile" },
64 { "advanced", NULL, 0, AV_OPT_TYPE_CONST, {.i64=RIST_PROFILE_ADVANCED}, 0, 0, .flags = D|E, "profile" },
65 { "buffer_size", "set buffer_size in ms", OFFSET(buffer_size), AV_OPT_TYPE_INT, {.i64=0}, 0, 30000, .flags = D|E },
66 { "pkt_size", "set packet size", OFFSET(packet_size), AV_OPT_TYPE_INT, {.i64=1316}, 1, MAX_PAYLOAD_SIZE, .flags = D|E },
67 { "log_level", "set loglevel", OFFSET(log_level), AV_OPT_TYPE_INT, {.i64=RIST_LOG_INFO}, -1, INT_MAX, .flags = D|E },
68 { "secret", "set encryption secret",OFFSET(secret), AV_OPT_TYPE_STRING,{.str=NULL}, 0, 0, .flags = D|E },
69 { "encryption","set encryption type",OFFSET(encryption), AV_OPT_TYPE_INT ,{.i64=0}, 0, INT_MAX, .flags = D|E },
70 { NULL }
71 };
72
risterr2ret(int err)73 static int risterr2ret(int err)
74 {
75 switch (err) {
76 case RIST_ERR_MALLOC:
77 return AVERROR(ENOMEM);
78 default:
79 return AVERROR_EXTERNAL;
80 }
81 }
82
log_cb(void * arg,enum rist_log_level log_level,const char * msg)83 static int log_cb(void *arg, enum rist_log_level log_level, const char *msg)
84 {
85 int level;
86
87 switch (log_level) {
88 case RIST_LOG_ERROR: level = AV_LOG_ERROR; break;
89 case RIST_LOG_WARN: level = AV_LOG_WARNING; break;
90 case RIST_LOG_NOTICE: level = AV_LOG_INFO; break;
91 case RIST_LOG_INFO: level = AV_LOG_VERBOSE; break;
92 case RIST_LOG_DEBUG: level = AV_LOG_DEBUG; break;
93 case RIST_LOG_DISABLE: level = AV_LOG_QUIET; break;
94 default: level = AV_LOG_WARNING;
95 }
96
97 av_log(arg, level, "%s", msg);
98
99 return 0;
100 }
101
librist_close(URLContext * h)102 static int librist_close(URLContext *h)
103 {
104 RISTContext *s = h->priv_data;
105 int ret = 0;
106
107 s->peer = NULL;
108
109 if (s->ctx)
110 ret = rist_destroy(s->ctx);
111 s->ctx = NULL;
112
113 return risterr2ret(ret);
114 }
115
librist_open(URLContext * h,const char * uri,int flags)116 static int librist_open(URLContext *h, const char *uri, int flags)
117 {
118 RISTContext *s = h->priv_data;
119 struct rist_logging_settings *logging_settings = &s->logging_settings;
120 struct rist_peer_config *peer_config = &s->peer_config;
121 int ret;
122
123 if ((flags & AVIO_FLAG_READ_WRITE) == AVIO_FLAG_READ_WRITE)
124 return AVERROR(EINVAL);
125
126 ret = rist_logging_set(&logging_settings, s->log_level, log_cb, h, NULL, NULL);
127 if (ret < 0)
128 return risterr2ret(ret);
129
130 if (flags & AVIO_FLAG_WRITE) {
131 h->max_packet_size = s->packet_size;
132 ret = rist_sender_create(&s->ctx, s->profile, 0, logging_settings);
133 }
134 if (ret < 0)
135 goto err;
136
137 if (flags & AVIO_FLAG_READ) {
138 h->max_packet_size = MAX_PAYLOAD_SIZE;
139 ret = rist_receiver_create(&s->ctx, s->profile, logging_settings);
140 }
141 if (ret < 0)
142 goto err;
143
144 ret = rist_peer_config_defaults_set(peer_config);
145 if (ret < 0)
146 goto err;
147
148 ret = rist_parse_address(uri, (const struct rist_peer_config **)&peer_config);
149 if (ret < 0)
150 goto err;
151
152 if (((s->encryption == 128 || s->encryption == 256) && !s->secret) ||
153 ((peer_config->key_size == 128 || peer_config->key_size == 256) && !peer_config->secret[0])) {
154 av_log(h, AV_LOG_ERROR, "secret is mandatory if encryption is enabled\n");
155 librist_close(h);
156 return AVERROR(EINVAL);
157 }
158
159 if (s->secret && peer_config->secret[0] == 0)
160 av_strlcpy(peer_config->secret, s->secret, RIST_MAX_STRING_SHORT);
161
162 if (s->secret && (s->encryption == 128 || s->encryption == 256))
163 peer_config->key_size = s->encryption;
164
165 if (s->buffer_size) {
166 peer_config->recovery_length_min = s->buffer_size;
167 peer_config->recovery_length_max = s->buffer_size;
168 }
169
170 ret = rist_peer_create(s->ctx, &s->peer, &s->peer_config);
171 if (ret < 0)
172 goto err;
173
174 ret = rist_start(s->ctx);
175 if (ret < 0)
176 goto err;
177
178 return 0;
179
180 err:
181 librist_close(h);
182
183 return risterr2ret(ret);
184 }
185
librist_read(URLContext * h,uint8_t * buf,int size)186 static int librist_read(URLContext *h, uint8_t *buf, int size)
187 {
188 RISTContext *s = h->priv_data;
189 const struct rist_data_block *data_block;
190 int ret;
191
192 ret = rist_receiver_data_read(s->ctx, &data_block, POLLING_TIME);
193 if (ret < 0)
194 return risterr2ret(ret);
195
196 if (ret == 0)
197 return AVERROR(EAGAIN);
198
199 if (data_block->payload_len > MAX_PAYLOAD_SIZE) {
200 rist_receiver_data_block_free((struct rist_data_block**)&data_block);
201 return AVERROR_EXTERNAL;
202 }
203
204 size = data_block->payload_len;
205 memcpy(buf, data_block->payload, size);
206 rist_receiver_data_block_free((struct rist_data_block**)&data_block);
207
208 return size;
209 }
210
librist_write(URLContext * h,const uint8_t * buf,int size)211 static int librist_write(URLContext *h, const uint8_t *buf, int size)
212 {
213 RISTContext *s = h->priv_data;
214 struct rist_data_block data_block = { 0 };
215 int ret;
216
217 data_block.ts_ntp = 0;
218 data_block.payload = buf;
219 data_block.payload_len = size;
220
221 ret = rist_sender_data_write(s->ctx, &data_block);
222 if (ret < 0)
223 return risterr2ret(ret);
224
225 return ret;
226 }
227
228 static const AVClass librist_class = {
229 .class_name = "librist",
230 .item_name = av_default_item_name,
231 .option = librist_options,
232 .version = LIBAVUTIL_VERSION_INT,
233 };
234
235 const URLProtocol ff_librist_protocol = {
236 .name = "rist",
237 .url_open = librist_open,
238 .url_read = librist_read,
239 .url_write = librist_write,
240 .url_close = librist_close,
241 .priv_data_size = sizeof(RISTContext),
242 .flags = URL_PROTOCOL_FLAG_NETWORK,
243 .priv_data_class = &librist_class,
244 };
245