|
janus_plugin * | create (void) |
|
int | janus_nosip_init (janus_callbacks *callback, const char *config_path) |
|
void | janus_nosip_destroy (void) |
|
int | janus_nosip_get_api_compatibility (void) |
|
int | janus_nosip_get_version (void) |
|
const char * | janus_nosip_get_version_string (void) |
|
const char * | janus_nosip_get_description (void) |
|
const char * | janus_nosip_get_name (void) |
|
const char * | janus_nosip_get_author (void) |
|
const char * | janus_nosip_get_package (void) |
|
void | janus_nosip_create_session (janus_plugin_session *handle, int *error) |
|
struct janus_plugin_result * | janus_nosip_handle_message (janus_plugin_session *handle, char *transaction, json_t *message, json_t *jsep) |
|
void | janus_nosip_setup_media (janus_plugin_session *handle) |
|
void | janus_nosip_incoming_rtp (janus_plugin_session *handle, int video, char *buf, int len) |
|
void | janus_nosip_incoming_rtcp (janus_plugin_session *handle, int video, char *buf, int len) |
|
void | janus_nosip_hangup_media (janus_plugin_session *handle) |
|
void | janus_nosip_destroy_session (janus_plugin_session *handle, int *error) |
|
json_t * | janus_nosip_query_session (janus_plugin_session *handle) |
|
void | janus_nosip_sdp_process (janus_nosip_session *session, janus_sdp *sdp, gboolean answer, gboolean update, gboolean *changed) |
|
char * | janus_nosip_sdp_manipulate (janus_nosip_session *session, janus_sdp *sdp, gboolean answer) |
|
Janus NoSIP plugin.
- Author
- Lorenzo Miniero loren.nosp@m.zo@m.nosp@m.eetec.nosp@m.ho.c.nosp@m.om
- Copyright
- GNU General Public License v3
This is quite a basic plugin, as it only takes care of acting as an RTP bridge. It is named "NoSIP" since, as the name suggests, signalling takes no place here, and is entirely up to the application. The typical usage of this application is something like this:
- a WebRTC application handles signalling on its own (e.g., SIP), but needs to interact with a peer that doesn't support WebRTC (DTLS/ICE);
- it creates a handle with the NoSIP plugin, creates a JSEP SDP offer, and passes it to the plugin;
- the plugin creates a barebone SDP that can be used to communicate with the legacy peer, binds to the ports for RTP/RTCP, and sends this plain SDP back to the application;
- the application uses this barebone SDP in its signalling, and expects an answer from the peer;
- the SDP answer from the peer will be barebone as well, and so unfit for WebRTC usage; as such, the application passes it to the plugin as the answer to match the offer created before;
- the plugin matches the answer to the offer, and starts exchanging RTP/RTCP with the legacy peer: media coming from the peer is relayed via WebRTC to the application, and WebRTC stuff coming from the application is relayed via plain RTP/RTCP to the legacy peer.
The same behaviour can be followed if the application is the callee instead, with the only difference being that the barebone offer will come from the peer in this case, and the application will ask the NoSIP plugin for a barebone answer instead.
As you can see, the behaviour is pretty much the same as the SIP plugin, with the key difference being that in this case there's no SIP stack in the plugin itself. All signalling is left to the application, and Janus (via the NoSIP plugin) is only responsible for bridging the media. This might be more appropriate than the SIP plugin in cases where developers want to keep control on the signalling layer, while still involving a gateway of sorts. Of course, SIP is just an example here: other signalling protocols may be involved as well (e.g., IAX, XMPP, others). The NoSIP plugin, though, will generate and expect plain SDP, so you'll need to take care of any adaptation that may be needed to make this work with the signalling protocol of your choice.
Actual API docs: TBD.
Plugins