peerstreamer-src / src / janus_instance.c @ 58fb2cdc
History | View | Annotate | Download (17.3 KB)
1 | c81c126e | Luca Baldesi | /*******************************************************************
|
---|---|---|---|
2 | * PeerStreamer-ng is a P2P video streaming application exposing a ReST
|
||
3 | * interface.
|
||
4 | * Copyright (C) 2017 Luca Baldesi <luca.baldesi@unitn.it>
|
||
5 | *
|
||
6 | * This program is free software: you can redistribute it and/or modify
|
||
7 | * it under the terms of the GNU Affero General Public License as published by
|
||
8 | * the Free Software Foundation, either version 3 of the License, or
|
||
9 | * (at your option) any later version.
|
||
10 | *
|
||
11 | * This program is distributed in the hope that it will be useful,
|
||
12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
14 | * GNU Affero General Public License for more details.
|
||
15 | *
|
||
16 | * You should have received a copy of the GNU Affero General Public License
|
||
17 | * along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||
18 | *******************************************************************/
|
||
19 | |||
20 | #include<janus_instance.h> |
||
21 | #include<signal.h> |
||
22 | #include<string.h> |
||
23 | #include<debug.h> |
||
24 | #include<unistd.h> |
||
25 | #include<tokens.h> |
||
26 | #include<grapes_config.h> |
||
27 | 3af4c8d7 | Luca Baldesi | #include <sys/prctl.h> // for process sync |
28 | c81c126e | Luca Baldesi | |
29 | #define INVALID_PID -1 |
||
30 | |||
31 | #define JANUS_MSG_SESSION_CREATE "{\"transaction\": \"random\", \"janus\": \"create\"}" |
||
32 | #define JANUS_MSG_SESSION_KEEPALIVE "{\"transaction\": \"ciao\", \"janus\": \"keepalive\"}" |
||
33 | 3af4c8d7 | Luca Baldesi | #define JANUS_MSG_STREAMING_PLUGIN_CREATE "{\"transaction\": \"ciao\", \"janus\": \"attach\", \"plugin\":\"janus.plugin.streaming\"}" |
34 | #define JANUS_MSG_VIDEOROOM_PLUGIN_CREATE "{\"transaction\": \"ciao\", \"janus\": \"attach\", \"plugin\":\"janus.plugin.videoroom\"}" |
||
35 | c81c126e | Luca Baldesi | |
36 | |||
37 | struct janus_instance {
|
||
38 | pid_t janus_pid; |
||
39 | char* endpoint;
|
||
40 | char * executable;
|
||
41 | char * conf_param;
|
||
42 | char * logfile;
|
||
43 | struct mg_mgr *mongoose_srv;
|
||
44 | struct periodic_task * heartbeat;
|
||
45 | uint64_t management_session; |
||
46 | 3af4c8d7 | Luca Baldesi | uint64_t streaming_plugin_handle; |
47 | uint64_t videoroom_plugin_handle; |
||
48 | c81c126e | Luca Baldesi | struct task_manager * tm;
|
49 | }; |
||
50 | |||
51 | uint64_t janus_instance_msg_get_id(char *msg)
|
||
52 | { |
||
53 | char ** records;
|
||
54 | uint32_t ntoks, i; |
||
55 | uint64_t res = 0;
|
||
56 | |||
57 | records = tokens_create(msg, ' ', &ntoks);
|
||
58 | if ((i = tokens_check(records, ntoks, "\"id\":")) > 0) |
||
59 | { |
||
60 | if (records[i+1][strlen(records[i+1])-1] == ',') |
||
61 | records[i+1][strlen(records[i+1])-1] = '\0'; |
||
62 | sscanf(records[i+1], "%"PRId64"", &res); |
||
63 | debug("ID string: %s\t ID integer: %"PRId64"\n", records[i+1], res); |
||
64 | } |
||
65 | tokens_destroy(&records, ntoks); |
||
66 | return res;
|
||
67 | } |
||
68 | |||
69 | 3af4c8d7 | Luca Baldesi | char * janus_instance_streaming_handle_path(const struct janus_instance * janus) |
70 | c81c126e | Luca Baldesi | { |
71 | char * res = NULL; |
||
72 | 3af4c8d7 | Luca Baldesi | if (janus && janus->management_session && janus->streaming_plugin_handle && janus->endpoint)
|
73 | c81c126e | Luca Baldesi | { |
74 | res = malloc(sizeof(char) * (strlen(janus->endpoint) + 43)); // each identifier comprises of 20 characters at most |
||
75 | 3af4c8d7 | Luca Baldesi | sprintf(res, "%s/%"PRId64"/%"PRId64"", janus->endpoint, janus->management_session, janus->streaming_plugin_handle); |
76 | } |
||
77 | return res;
|
||
78 | } |
||
79 | |||
80 | char * janus_instance_videoroom_handle_path(const struct janus_instance * janus) |
||
81 | { |
||
82 | char * res = NULL; |
||
83 | if (janus && janus->management_session && janus->videoroom_plugin_handle && janus->endpoint)
|
||
84 | { |
||
85 | res = malloc(sizeof(char) * (strlen(janus->endpoint) + 43)); // each identifier comprises of 20 characters at most |
||
86 | sprintf(res, "%s/%"PRId64"/%"PRId64"", janus->endpoint, janus->management_session, janus->videoroom_plugin_handle); |
||
87 | c81c126e | Luca Baldesi | } |
88 | return res;
|
||
89 | } |
||
90 | |||
91 | char * janus_instance_session_path(const struct janus_instance * janus) |
||
92 | { |
||
93 | char * res = NULL; |
||
94 | if (janus && janus->management_session && janus->endpoint)
|
||
95 | { |
||
96 | res = malloc(sizeof(char) * (strlen(janus->endpoint) + 22)); // session identifier can be at most 20 characters long |
||
97 | sprintf(res, "%s/%"PRId64"", janus->endpoint, janus->management_session); |
||
98 | } |
||
99 | return res;
|
||
100 | } |
||
101 | |||
102 | struct janus_instance * janus_instance_create(struct mg_mgr *mongoose_srv, struct task_manager *tm, const char *config) |
||
103 | { |
||
104 | struct janus_instance * ji = NULL; |
||
105 | struct tag* tags;
|
||
106 | |||
107 | if (mongoose_srv && tm)
|
||
108 | { |
||
109 | tags = grapes_config_parse(config); |
||
110 | |||
111 | ji = malloc(sizeof(struct janus_instance)); |
||
112 | ji->endpoint = strdup(grapes_config_value_str_default(tags, "janus_endpoint", "127.0.0.1:8088/janus")); |
||
113 | ji->executable = strdup(grapes_config_value_str_default(tags, "janus_executable", "Tools/janus/bin/janus")); |
||
114 | ji->conf_param = strdup(grapes_config_value_str_default(tags, "janus_param", "--configs-folder=Tools/janus_conf")); |
||
115 | ji->logfile = strdup(grapes_config_value_str_default(tags, "janus_logfile", "janus.log")); |
||
116 | ji->janus_pid = INVALID_PID; |
||
117 | ji->management_session = 0;
|
||
118 | 3af4c8d7 | Luca Baldesi | ji->streaming_plugin_handle = 0;
|
119 | ji->videoroom_plugin_handle = 0;
|
||
120 | c81c126e | Luca Baldesi | ji->tm = tm; |
121 | ji->heartbeat = NULL;
|
||
122 | ji->mongoose_srv = mongoose_srv; |
||
123 | |||
124 | if(tags)
|
||
125 | free(tags); |
||
126 | } |
||
127 | return ji;
|
||
128 | } |
||
129 | |||
130 | void janus_instance_destroy(struct janus_instance ** ji) |
||
131 | { |
||
132 | if (ji && (*ji))
|
||
133 | { |
||
134 | if ((*ji)->janus_pid != INVALID_PID)
|
||
135 | 58fb2cdc | Luca Baldesi | kill((*ji)->janus_pid, SIGHUP); |
136 | c81c126e | Luca Baldesi | |
137 | if ((*ji)->heartbeat)
|
||
138 | task_manager_destroy_task((*ji)->tm, &((*ji)->heartbeat)); |
||
139 | free((*ji)->endpoint); |
||
140 | free((*ji)->executable); |
||
141 | free((*ji)->conf_param); |
||
142 | free((*ji)->logfile); |
||
143 | free(*ji); |
||
144 | *ji = NULL;
|
||
145 | } |
||
146 | } |
||
147 | |||
148 | void janus_instance_generic_handler(struct mg_connection *nc, int ev, void *ev_data) |
||
149 | { |
||
150 | struct http_message *hm = (struct http_message *) ev_data; |
||
151 | |||
152 | switch (ev) {
|
||
153 | case MG_EV_CONNECT:
|
||
154 | if (*(int *) ev_data != 0) |
||
155 | debug("Janus communication failure\n");
|
||
156 | break;
|
||
157 | case MG_EV_HTTP_REPLY:
|
||
158 | switch (hm->resp_code) {
|
||
159 | case 200: |
||
160 | default:
|
||
161 | debug("Janus answers: %d\n", hm->resp_code);
|
||
162 | } |
||
163 | nc->flags |= MG_F_SEND_AND_CLOSE; |
||
164 | break;
|
||
165 | case MG_EV_CLOSE:
|
||
166 | debug("Janus server closed connection\n");
|
||
167 | break;
|
||
168 | default:
|
||
169 | break;
|
||
170 | } |
||
171 | } |
||
172 | |||
173 | 3af4c8d7 | Luca Baldesi | void janus_instance_streaming_plugin_handler(struct mg_connection *nc, int ev, void *ev_data) |
174 | c81c126e | Luca Baldesi | { |
175 | struct janus_instance * janus;
|
||
176 | struct http_message *hm = (struct http_message *) ev_data; |
||
177 | char *buff;
|
||
178 | |||
179 | janus = nc->user_data; |
||
180 | switch (ev) {
|
||
181 | case MG_EV_CONNECT:
|
||
182 | if (*(int *) ev_data != 0) |
||
183 | debug("Janus communication failure\n");
|
||
184 | break;
|
||
185 | case MG_EV_HTTP_REPLY:
|
||
186 | switch (hm->resp_code) {
|
||
187 | case 200: |
||
188 | buff = malloc(sizeof(char) * (hm->body.len + 1)); |
||
189 | strncpy(buff, hm->body.p, hm->body.len); |
||
190 | buff[hm->body.len] = '\0'; // make sure string terminates |
||
191 | 3af4c8d7 | Luca Baldesi | janus->streaming_plugin_handle = janus_instance_msg_get_id(buff); |
192 | c81c126e | Luca Baldesi | free(buff); |
193 | 3af4c8d7 | Luca Baldesi | debug("Got plugin streaming_handle!\n");
|
194 | default:
|
||
195 | debug("Janus answers: %d\n", hm->resp_code);
|
||
196 | } |
||
197 | nc->flags |= MG_F_SEND_AND_CLOSE; |
||
198 | break;
|
||
199 | case MG_EV_CLOSE:
|
||
200 | debug("Janus server closed connection\n");
|
||
201 | break;
|
||
202 | default:
|
||
203 | break;
|
||
204 | } |
||
205 | } |
||
206 | |||
207 | void janus_instance_videoroom_plugin_handler(struct mg_connection *nc, int ev, void *ev_data) |
||
208 | { |
||
209 | struct janus_instance * janus;
|
||
210 | struct http_message *hm = (struct http_message *) ev_data; |
||
211 | char *buff;
|
||
212 | |||
213 | janus = nc->user_data; |
||
214 | switch (ev) {
|
||
215 | case MG_EV_CONNECT:
|
||
216 | if (*(int *) ev_data != 0) |
||
217 | debug("Janus communication failure\n");
|
||
218 | break;
|
||
219 | case MG_EV_HTTP_REPLY:
|
||
220 | switch (hm->resp_code) {
|
||
221 | case 200: |
||
222 | buff = malloc(sizeof(char) * (hm->body.len + 1)); |
||
223 | strncpy(buff, hm->body.p, hm->body.len); |
||
224 | buff[hm->body.len] = '\0'; // make sure string terminates |
||
225 | janus->videoroom_plugin_handle = janus_instance_msg_get_id(buff); |
||
226 | free(buff); |
||
227 | debug("Got plugin videoroom_handle!\n");
|
||
228 | c81c126e | Luca Baldesi | default:
|
229 | debug("Janus answers: %d\n", hm->resp_code);
|
||
230 | } |
||
231 | nc->flags |= MG_F_SEND_AND_CLOSE; |
||
232 | break;
|
||
233 | case MG_EV_CLOSE:
|
||
234 | debug("Janus server closed connection\n");
|
||
235 | break;
|
||
236 | default:
|
||
237 | break;
|
||
238 | } |
||
239 | } |
||
240 | |||
241 | void janus_instance_session_handler(struct mg_connection *nc, int ev, void *ev_data) |
||
242 | { |
||
243 | struct janus_instance * janus;
|
||
244 | struct mg_connection * conn;
|
||
245 | struct http_message *hm = (struct http_message *) ev_data; |
||
246 | char *buff;
|
||
247 | |||
248 | janus = nc->user_data; |
||
249 | switch (ev) {
|
||
250 | case MG_EV_CONNECT:
|
||
251 | if (*(int *) ev_data != 0) |
||
252 | debug("Janus communication failure\n");
|
||
253 | break;
|
||
254 | case MG_EV_HTTP_REPLY:
|
||
255 | switch (hm->resp_code) {
|
||
256 | case 200: |
||
257 | buff = malloc(sizeof(char) * (hm->body.len + 1)); |
||
258 | strncpy(buff, hm->body.p, hm->body.len); |
||
259 | buff[hm->body.len] = '\0'; // make sure string terminates |
||
260 | janus->management_session = janus_instance_msg_get_id(buff); |
||
261 | free(buff); |
||
262 | 3af4c8d7 | Luca Baldesi | |
263 | // Requesting handle for the streaming plugin
|
||
264 | buff = malloc(sizeof(char) * (strlen(janus->endpoint) + 22)); |
||
265 | sprintf(buff, "%s/%"PRId64"", janus->endpoint, janus->management_session); |
||
266 | conn = mg_connect_http(janus->mongoose_srv, janus_instance_streaming_plugin_handler, buff, NULL, JANUS_MSG_STREAMING_PLUGIN_CREATE);
|
||
267 | free(buff); |
||
268 | if (conn)
|
||
269 | conn->user_data = (void *) janus;
|
||
270 | |||
271 | // Requesting handle for the videoroom plugin
|
||
272 | c81c126e | Luca Baldesi | buff = malloc(sizeof(char) * (strlen(janus->endpoint) + 22)); |
273 | sprintf(buff, "%s/%"PRId64"", janus->endpoint, janus->management_session); |
||
274 | 3af4c8d7 | Luca Baldesi | conn = mg_connect_http(janus->mongoose_srv, janus_instance_videoroom_plugin_handler, buff, NULL, JANUS_MSG_VIDEOROOM_PLUGIN_CREATE);
|
275 | c81c126e | Luca Baldesi | free(buff); |
276 | if (conn)
|
||
277 | conn->user_data = (void *) janus;
|
||
278 | default:
|
||
279 | debug("Janus answers: %d\n", hm->resp_code);
|
||
280 | } |
||
281 | nc->flags |= MG_F_SEND_AND_CLOSE; |
||
282 | break;
|
||
283 | case MG_EV_CLOSE:
|
||
284 | debug("Janus server closed connection\n");
|
||
285 | break;
|
||
286 | default:
|
||
287 | break;
|
||
288 | } |
||
289 | } |
||
290 | |||
291 | int8_t janus_instance_create_management_handle(struct janus_instance *janus)
|
||
292 | { |
||
293 | struct mg_connection * conn;
|
||
294 | int8_t res = -1;
|
||
295 | |||
296 | if (janus)
|
||
297 | { |
||
298 | conn = mg_connect_http(janus->mongoose_srv, janus_instance_session_handler, janus->endpoint, NULL, JANUS_MSG_SESSION_CREATE);
|
||
299 | if (conn)
|
||
300 | { |
||
301 | conn->user_data = (void *) janus;
|
||
302 | res = 0;
|
||
303 | } |
||
304 | } |
||
305 | return res;
|
||
306 | } |
||
307 | |||
308 | uint8_t janus_instance_heartbeat(struct periodic_task * pt)
|
||
309 | { |
||
310 | struct janus_instance * janus;
|
||
311 | struct mg_connection * conn;
|
||
312 | char * uri;
|
||
313 | |||
314 | janus = (struct janus_instance *) periodic_task_get_data(pt);
|
||
315 | uri = janus_instance_session_path(janus); |
||
316 | if (uri)
|
||
317 | { |
||
318 | conn = mg_connect_http(janus->mongoose_srv, janus_instance_generic_handler, uri, NULL, JANUS_MSG_SESSION_KEEPALIVE);
|
||
319 | if (conn)
|
||
320 | conn->user_data = (void *) janus;
|
||
321 | free(uri); |
||
322 | } |
||
323 | return 0; |
||
324 | } |
||
325 | |||
326 | int8_t janus_instance_launch(struct janus_instance * ji)
|
||
327 | { |
||
328 | int8_t res = -1;
|
||
329 | struct stat s;
|
||
330 | char * argv[4]; |
||
331 | int fd;
|
||
332 | |||
333 | if (ji && ji->janus_pid == INVALID_PID)
|
||
334 | { |
||
335 | 3af4c8d7 | Luca Baldesi | info("%s - %s\n", ji->executable, ji->conf_param);
|
336 | c81c126e | Luca Baldesi | res = stat(ji->executable, &s); |
337 | // check exe existence
|
||
338 | if (res == 0 && S_ISREG(s.st_mode)) |
||
339 | { |
||
340 | ji->janus_pid = fork(); |
||
341 | if (ji->janus_pid != INVALID_PID)
|
||
342 | { |
||
343 | if (ji->janus_pid) // the parent |
||
344 | { |
||
345 | sleep(1); // let janus bootstrap |
||
346 | res = janus_instance_create_management_handle(ji); |
||
347 | if (res == 0) |
||
348 | ji->heartbeat = task_manager_new_task(ji->tm, janus_instance_heartbeat, NULL, 30000, ji); |
||
349 | } |
||
350 | else // the child |
||
351 | { |
||
352 | 58fb2cdc | Luca Baldesi | fd = creat(ji->logfile, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH); |
353 | c81c126e | Luca Baldesi | dup2(fd, 1); // make stdout go to file |
354 | dup2(fd, 2); // make stderr go to file - you may choose to not do this |
||
355 | close(fd); |
||
356 | |||
357 | 3af4c8d7 | Luca Baldesi | prctl(PR_SET_PDEATHSIG, SIGHUP); // makes kernel dispatch me a SIGHUP if parent dies
|
358 | |||
359 | c81c126e | Luca Baldesi | argv[0] = ji->executable;
|
360 | argv[1] = ji->conf_param;
|
||
361 | argv[2] = NULL; |
||
362 | res = execve(ji->executable, argv, NULL);
|
||
363 | info("Error on launching Janus execution\n");
|
||
364 | } |
||
365 | } else
|
||
366 | { |
||
367 | info("Error on forking\n");
|
||
368 | res = -1;
|
||
369 | } |
||
370 | |||
371 | |||
372 | } else
|
||
373 | info("Janus executable not found\n");
|
||
374 | } |
||
375 | return res;
|
||
376 | } |
||
377 | |||
378 | void janus_instance_streaming_point_handler(struct mg_connection *nc, int ev, void *ev_data) |
||
379 | { |
||
380 | uint64_t * mp_id; |
||
381 | struct http_message *hm = (struct http_message *) ev_data; |
||
382 | char *buff;
|
||
383 | void ** data;
|
||
384 | struct streamer_creation_callback * scc;
|
||
385 | |||
386 | data = nc->user_data; |
||
387 | mp_id = data[0];
|
||
388 | scc = data[1];
|
||
389 | switch (ev) {
|
||
390 | case MG_EV_CONNECT:
|
||
391 | if (*(int *) ev_data != 0) |
||
392 | debug("Janus communication failure\n");
|
||
393 | debug("Ora triggero!\n");
|
||
394 | break;
|
||
395 | case MG_EV_HTTP_REPLY:
|
||
396 | switch (hm->resp_code) {
|
||
397 | case 200: |
||
398 | buff = malloc(sizeof(char) * (hm->body.len + 1)); |
||
399 | strncpy(buff, hm->body.p, hm->body.len); |
||
400 | buff[hm->body.len] = '\0'; // make sure string terminates |
||
401 | debug(buff); |
||
402 | *mp_id = janus_instance_msg_get_id(buff); |
||
403 | free(buff); |
||
404 | default:
|
||
405 | debug("Janus answers: %d\n", hm->resp_code);
|
||
406 | } |
||
407 | nc->flags |= MG_F_SEND_AND_CLOSE; |
||
408 | break;
|
||
409 | case MG_EV_CLOSE:
|
||
410 | debug("Janus server closed connection\n");
|
||
411 | if (scc)
|
||
412 | { |
||
413 | debug("Janus instance calls creation trigger\n");
|
||
414 | streamer_creation_callback_trigger(scc, *mp_id ? 0 : 1); |
||
415 | streamer_creation_callback_destroy(&scc); |
||
416 | free(data); |
||
417 | } |
||
418 | break;
|
||
419 | default:
|
||
420 | break;
|
||
421 | } |
||
422 | } |
||
423 | |||
424 | 3af4c8d7 | Luca Baldesi | void janus_instance_videoroom_creation_handler(struct mg_connection *nc, int ev, void *ev_data) |
425 | { |
||
426 | struct http_message *hm = (struct http_message *) ev_data; |
||
427 | void ** data;
|
||
428 | struct streamer_creation_callback * scc;
|
||
429 | |||
430 | data = nc->user_data; |
||
431 | scc = data[0];
|
||
432 | switch (ev) {
|
||
433 | case MG_EV_CONNECT:
|
||
434 | if (*(int *) ev_data != 0) |
||
435 | debug("Janus communication failure\n");
|
||
436 | break;
|
||
437 | case MG_EV_HTTP_REPLY:
|
||
438 | switch (hm->resp_code) {
|
||
439 | case 200: |
||
440 | info("Room created\n");
|
||
441 | default:
|
||
442 | debug("Janus answers: %d\n", hm->resp_code);
|
||
443 | } |
||
444 | nc->flags |= MG_F_SEND_AND_CLOSE; |
||
445 | break;
|
||
446 | case MG_EV_CLOSE:
|
||
447 | debug("Janus server closed connection\n");
|
||
448 | if (scc)
|
||
449 | { |
||
450 | debug("Janus instance calls creation trigger\n");
|
||
451 | streamer_creation_callback_trigger(scc, 0);
|
||
452 | streamer_creation_callback_destroy(&scc); |
||
453 | free(data); |
||
454 | } |
||
455 | break;
|
||
456 | default:
|
||
457 | break;
|
||
458 | } |
||
459 | } |
||
460 | |||
461 | c81c126e | Luca Baldesi | int8_t janus_instance_create_streaming_point(struct janus_instance const * janus, uint64_t *mp_id, uint16_t audio_port, uint16_t video_port, struct streamer_creation_callback *scc) |
462 | { |
||
463 | struct mg_connection * conn;
|
||
464 | int8_t res = -1;
|
||
465 | char * uri;
|
||
466 | char * fmt = "{\"transaction\":\"random_str\",\"janus\":\"message\",\"body\":{\"request\":\"create\",\"type\":\"rtp\",\ |
||
467 | \"audio\":true,\"audioport\":%"PRId16",\"audiopt\":111,\"audiortpmap\":\"opus/48000/2\",\ |
||
468 | a95383e2 | Luca Baldesi | \"video\":true,\"videoport\":%"PRId16",\"videopt\":100,\"videortpmap\":\"VP8/90000\"}}"; |
469 | c81c126e | Luca Baldesi | char buff[280]; |
470 | void ** data;
|
||
471 | |||
472 | if (janus && mp_id && audio_port && video_port)
|
||
473 | { |
||
474 | 3af4c8d7 | Luca Baldesi | uri = janus_instance_streaming_handle_path(janus); |
475 | c81c126e | Luca Baldesi | if (uri)
|
476 | { |
||
477 | sprintf(buff, fmt, audio_port, video_port); |
||
478 | debug("Conctating Janus to create a new mountpoint\n");
|
||
479 | conn = mg_connect_http(janus->mongoose_srv, janus_instance_streaming_point_handler, uri, NULL, buff);
|
||
480 | if (conn)
|
||
481 | { |
||
482 | data = malloc(sizeof(void *) * 2); |
||
483 | data[0] = mp_id;
|
||
484 | data[1] = scc;
|
||
485 | conn->user_data = data; |
||
486 | res = 0;
|
||
487 | } else
|
||
488 | debug("Aaargh, no connection!\n");
|
||
489 | free(uri); |
||
490 | } |
||
491 | } |
||
492 | return res;
|
||
493 | } |
||
494 | |||
495 | int8_t janus_instance_destroy_streaming_point(struct janus_instance const * janus, uint64_t mp_id) |
||
496 | { |
||
497 | struct mg_connection * conn;
|
||
498 | int8_t res = -1;
|
||
499 | char * uri;
|
||
500 | char * fmt = "{\"transaction\":\"random_str\",\"janus\":\"message\",\"body\":{\"request\":\"destroy\",\"id\": %"PRId64"}}"; |
||
501 | char buff[120]; |
||
502 | |||
503 | if (janus && mp_id)
|
||
504 | { |
||
505 | 3af4c8d7 | Luca Baldesi | uri = janus_instance_streaming_handle_path(janus); |
506 | c81c126e | Luca Baldesi | if (uri)
|
507 | { |
||
508 | sprintf(buff, fmt, mp_id); |
||
509 | conn = mg_connect_http(janus->mongoose_srv, janus_instance_generic_handler, uri, NULL, buff);
|
||
510 | if (conn)
|
||
511 | { |
||
512 | conn->user_data = (void *) mp_id;
|
||
513 | res = 0;
|
||
514 | } |
||
515 | free(uri); |
||
516 | } |
||
517 | } |
||
518 | return res;
|
||
519 | } |
||
520 | 3af4c8d7 | Luca Baldesi | |
521 | int8_t janus_instance_create_videoroom(struct janus_instance const * janus, const char * room_id, struct streamer_creation_callback *scc) |
||
522 | { |
||
523 | struct mg_connection * conn;
|
||
524 | int8_t res = -1;
|
||
525 | char * uri;
|
||
526 | 58fb2cdc | Luca Baldesi | char * fmt = "{\"transaction\":\"random_str\",\"janus\":\"message\",\"body\":{\"request\":\"create\",\"room\":%s,\"publishers\":1,\"bitrate\":128000,\"record\":false,\"description\":\"Room %s\",\"fir_freq\":100}}"; |
527 | 3af4c8d7 | Luca Baldesi | |
528 | char buff[280]; |
||
529 | void ** data;
|
||
530 | |||
531 | if (janus && room_id)
|
||
532 | { |
||
533 | uri = janus_instance_videoroom_handle_path(janus); |
||
534 | if (uri)
|
||
535 | { |
||
536 | 58fb2cdc | Luca Baldesi | sprintf(buff, fmt, room_id, room_id); |
537 | 3af4c8d7 | Luca Baldesi | debug("Conctating Janus to create a new video room\n");
|
538 | conn = mg_connect_http(janus->mongoose_srv, janus_instance_videoroom_creation_handler, uri, NULL, buff);
|
||
539 | if (conn)
|
||
540 | { |
||
541 | data = malloc(sizeof(void *)); |
||
542 | data[0] = scc;
|
||
543 | conn->user_data = data; |
||
544 | res = 0;
|
||
545 | } else
|
||
546 | debug("Aaargh, no connection!\n");
|
||
547 | free(uri); |
||
548 | } |
||
549 | } |
||
550 | return res;
|
||
551 | } |
||
552 | |||
553 | int8_t janus_instance_destroy_videoroom(struct janus_instance const * janus, const char * room_id) |
||
554 | { |
||
555 | struct mg_connection * conn;
|
||
556 | int8_t res = -1;
|
||
557 | char * uri;
|
||
558 | char * fmt = "{\"transaction\":\"random_str\",\"janus\":\"message\",\"body\":{\"request\":\"destroy\",\"room\": %s}}"; |
||
559 | char buff[120]; |
||
560 | |||
561 | if (janus && room_id)
|
||
562 | { |
||
563 | uri = janus_instance_videoroom_handle_path(janus); |
||
564 | if (uri)
|
||
565 | { |
||
566 | sprintf(buff, fmt, room_id); |
||
567 | conn = mg_connect_http(janus->mongoose_srv, janus_instance_generic_handler, uri, NULL, buff);
|
||
568 | if (conn)
|
||
569 | { |
||
570 | conn->user_data = (void *) room_id;
|
||
571 | res = 0;
|
||
572 | } |
||
573 | free(uri); |
||
574 | } |
||
575 | } |
||
576 | return res;
|
||
577 | } |
||
578 | |||
579 | int8_t janus_instance_forward_rtp(struct janus_instance const * janus, const char * room_id, uint64_t participant_id, const char * rtp_dest, uint16_t audio_port, uint16_t video_port) |
||
580 | { |
||
581 | struct mg_connection * conn;
|
||
582 | int8_t res = -1;
|
||
583 | char * uri;
|
||
584 | 58fb2cdc | Luca Baldesi | char * fmt = "{\"transaction\":\"random_str\",\"janus\":\"message\",\"body\":{\"request\":\"rtp_forward\",\"room\":%s,\"publisher_id\":%"PRId64", \"host\": \"%s\",\"audio_port\":%"PRId16",\"video_port\":%"PRId16",\"audio_pt\":111,\"video_pt\":98}}"; |
585 | 3af4c8d7 | Luca Baldesi | |
586 | char buff[280]; |
||
587 | |||
588 | if (janus && room_id && rtp_dest && audio_port > 0 && video_port > 0) |
||
589 | { |
||
590 | uri = janus_instance_videoroom_handle_path(janus); |
||
591 | if (uri)
|
||
592 | { |
||
593 | sprintf(buff, fmt, room_id, participant_id, rtp_dest, audio_port, video_port); |
||
594 | 58fb2cdc | Luca Baldesi | debug("Conctating Janus to create a new video room\n");
|
595 | 3af4c8d7 | Luca Baldesi | conn = mg_connect_http(janus->mongoose_srv, janus_instance_generic_handler, uri, NULL, buff);
|
596 | if (conn)
|
||
597 | res = 0;
|
||
598 | else
|
||
599 | debug("Aaargh, no connection!\n");
|
||
600 | free(uri); |
||
601 | } |
||
602 | } |
||
603 | return res;
|
||
604 | } |