janus_sdp *janus_sdp_new(const char *name, const char *address) {
janus_sdp *sdp = g_malloc(sizeof(janus_sdp));
/* Fill in some predefined stuff */
sdp->version = 0;
sdp->o_name = g_strdup("-");
sdp->o_sessid = janus_get_real_time();
sdp->o_version = 1;
sdp->o_ipv4 = TRUE;
sdp->o_addr = g_strdup(address ? address : "127.0.0.1");
sdp->s_name = g_strdup(name ? name : "Janus session");
sdp->t_start = 0;
sdp->t_stop = 0;
sdp->c_ipv4 = TRUE;
sdp->c_addr = g_strdup(address ? address : "127.0.0.1");
sdp->attributes = NULL;
sdp->m_lines = NULL;
/* Done */
return sdp;
}
janus_recorder *janus_recorder_create(const char *dir, const char *codec, const char *filename) {
janus_recorder_medium type = JANUS_RECORDER_AUDIO;
if(codec == NULL) {
JANUS_LOG(LOG_ERR, "Missing codec information\n");
return NULL;
}
if(!strcasecmp(codec, "vp8") || !strcasecmp(codec, "vp9") || !strcasecmp(codec, "h264")) {
type = JANUS_RECORDER_VIDEO;
if(!strcasecmp(codec, "vp9")) {
JANUS_LOG(LOG_WARN, "The post-processor currently doesn't support VP9: recording anyway for the future\n");
}
} else if(!strcasecmp(codec, "opus") || !strcasecmp(codec, "g711") || !strcasecmp(codec, "pcmu") || !strcasecmp(codec, "pcma")) {
type = JANUS_RECORDER_AUDIO;
if(!strcasecmp(codec, "pcmu") || !strcasecmp(codec, "pcma"))
codec = "g711";
} else if(!strcasecmp(codec, "text")) {
/* FIXME We only handle text on data channels, so that's the only thing we can save too */
type = JANUS_RECORDER_DATA;
} else {
/* We don't recognize the codec: while we might go on anyway, we'd rather fail instead */
JANUS_LOG(LOG_ERR, "Unsupported codec '%s'\n", codec);
return NULL;
}
/* Create the recorder */
janus_recorder *rc = g_malloc0(sizeof(janus_recorder));
if(rc == NULL) {
JANUS_LOG(LOG_FATAL, "Memory error!\n");
return NULL;
}
rc->dir = NULL;
rc->filename = NULL;
rc->file = NULL;
rc->codec = g_strdup(codec);
rc->created = janus_get_real_time();
if(dir != NULL) {
/* Check if this directory exists, and create it if needed */
struct stat s;
int err = stat(dir, &s);
if(err == -1) {
if(ENOENT == errno) {
/* Directory does not exist, try creating it */
if(janus_mkdir(dir, 0755) < 0) {
JANUS_LOG(LOG_ERR, "mkdir error: %d\n", errno);
return NULL;
}
} else {
JANUS_LOG(LOG_ERR, "stat error: %d\n", errno);
return NULL;
}
} else {
if(S_ISDIR(s.st_mode)) {
/* Directory exists */
JANUS_LOG(LOG_VERB, "Directory exists: %s\n", dir);
} else {
/* File exists but it's not a directory? */
JANUS_LOG(LOG_ERR, "Not a directory? %s\n", dir);
return NULL;
}
}
}
char newname[1024];
memset(newname, 0, 1024);
if(filename == NULL) {
/* Choose a random username */
g_snprintf(newname, 1024, "janus-recording-%"SCNu32".mjr", janus_random_uint32());
} else {
/* Just append the extension */
g_snprintf(newname, 1024, "%s.mjr", filename);
}
/* Try opening the file now */
if(dir == NULL) {
rc->file = fopen(newname, "wb");
} else {
char path[1024];
memset(path, 0, 1024);
g_snprintf(path, 1024, "%s/%s", dir, newname);
rc->file = fopen(path, "wb");
}
if(rc->file == NULL) {
JANUS_LOG(LOG_ERR, "fopen error: %d\n", errno);
return NULL;
}
if(dir)
rc->dir = g_strdup(dir);
rc->filename = g_strdup(newname);
rc->type = type;
/* Write the first part of the header */
fwrite(header, sizeof(char), strlen(header), rc->file);
rc->writable = 1;
/* We still need to also write the info header first */
rc->header = 0;
janus_mutex_init(&rc->mutex);
return rc;
}
int janus_recorder_save_frame(janus_recorder *recorder, char *buffer, uint length) {
if(!recorder)
return -1;
janus_mutex_lock_nodebug(&recorder->mutex);
if(!buffer || length < 1) {
janus_mutex_unlock_nodebug(&recorder->mutex);
return -2;
}
if(!recorder->file) {
janus_mutex_unlock_nodebug(&recorder->mutex);
return -3;
}
if(!recorder->writable) {
janus_mutex_unlock_nodebug(&recorder->mutex);
return -4;
}
if(!recorder->header) {
/* Write info header as a JSON formatted info */
json_t *info = json_object();
/* FIXME Codecs should be configurable in the future */
const char *type = NULL;
if(recorder->type == JANUS_RECORDER_AUDIO)
type = "a";
else if(recorder->type == JANUS_RECORDER_VIDEO)
type = "v";
else if(recorder->type == JANUS_RECORDER_DATA)
type = "d";
json_object_set_new(info, "t", json_string(type)); /* Audio/Video/Data */
json_object_set_new(info, "c", json_string(recorder->codec)); /* Media codec */
json_object_set_new(info, "s", json_integer(recorder->created)); /* Created time */
json_object_set_new(info, "u", json_integer(janus_get_real_time())); /* First frame written time */
gchar *info_text = json_dumps(info, JSON_PRESERVE_ORDER);
json_decref(info);
uint16_t info_bytes = htons(strlen(info_text));
fwrite(&info_bytes, sizeof(uint16_t), 1, recorder->file);
fwrite(info_text, sizeof(char), strlen(info_text), recorder->file);
free(info_text);
/* Done */
recorder->header = 1;
}
/* Write frame header */
fwrite(frame_header, sizeof(char), strlen(frame_header), recorder->file);
uint16_t header_bytes = htons(recorder->type == JANUS_RECORDER_DATA ? (length+sizeof(gint64)) : length);
fwrite(&header_bytes, sizeof(uint16_t), 1, recorder->file);
if(recorder->type == JANUS_RECORDER_DATA) {
/* If it's data, then we need to prepend timing related info, as it's not there by itself */
gint64 now = htonll(janus_get_real_time());
fwrite(&now, sizeof(gint64), 1, recorder->file);
}
/* Save packet on file */
int temp = 0, tot = length;
while(tot > 0) {
temp = fwrite(buffer+length-tot, sizeof(char), tot, recorder->file);
if(temp <= 0) {
JANUS_LOG(LOG_ERR, "Error saving frame...\n");
janus_mutex_unlock_nodebug(&recorder->mutex);
return -5;
}
tot -= temp;
}
/* Done */
janus_mutex_unlock_nodebug(&recorder->mutex);
return 0;
}
janus_recorder *janus_recorder_create(const char *dir, const char *codec, const char *filename) {
janus_recorder_medium type = JANUS_RECORDER_AUDIO;
if(codec == NULL) {
JANUS_LOG(LOG_ERR, "Missing codec information\n");
return NULL;
}
if(!strcasecmp(codec, "vp8") || !strcasecmp(codec, "vp9") || !strcasecmp(codec, "h264")) {
type = JANUS_RECORDER_VIDEO;
} else if(!strcasecmp(codec, "opus")
|| !strcasecmp(codec, "g711") || !strcasecmp(codec, "pcmu") || !strcasecmp(codec, "pcma")
|| !strcasecmp(codec, "g722")) {
type = JANUS_RECORDER_AUDIO;
} else if(!strcasecmp(codec, "text")) {
/* FIXME We only handle text on data channels, so that's the only thing we can save too */
type = JANUS_RECORDER_DATA;
} else {
/* We don't recognize the codec: while we might go on anyway, we'd rather fail instead */
JANUS_LOG(LOG_ERR, "Unsupported codec '%s'\n", codec);
return NULL;
}
/* Create the recorder */
janus_recorder *rc = g_malloc0(sizeof(janus_recorder));
rc->dir = NULL;
rc->filename = NULL;
rc->file = NULL;
rc->codec = g_strdup(codec);
rc->created = janus_get_real_time();
const char *rec_dir = NULL;
const char *rec_file = NULL;
char *copy_for_parent = NULL;
char *copy_for_base = NULL;
/* Check dir and filename values */
if (filename != NULL) {
/* Helper copies to avoid overwriting */
copy_for_parent = g_strdup(filename);
copy_for_base = g_strdup(filename);
/* Get filename parent folder */
const char *filename_parent = dirname(copy_for_parent);
/* Get filename base file */
const char *filename_base = basename(copy_for_base);
if (!dir) {
/* If dir is NULL we have to create filename_parent and filename_base */
rec_dir = filename_parent;
rec_file = filename_base;
} else {
/* If dir is valid we have to create dir and filename*/
rec_dir = dir;
rec_file = filename;
if (strcasecmp(filename_parent, ".") || strcasecmp(filename_base, filename)) {
JANUS_LOG(LOG_WARN, "Unsupported combination of dir and filename %s %s\n", dir, filename);
}
}
}
if(rec_dir != NULL) {
/* Check if this directory exists, and create it if needed */
struct stat s;
int err = stat(rec_dir, &s);
if(err == -1) {
if(ENOENT == errno) {
/* Directory does not exist, try creating it */
if(janus_mkdir(rec_dir, 0755) < 0) {
JANUS_LOG(LOG_ERR, "mkdir error: %d\n", errno);
return NULL;
}
} else {
JANUS_LOG(LOG_ERR, "stat error: %d\n", errno);
return NULL;
}
} else {
if(S_ISDIR(s.st_mode)) {
/* Directory exists */
JANUS_LOG(LOG_VERB, "Directory exists: %s\n", rec_dir);
} else {
/* File exists but it's not a directory? */
JANUS_LOG(LOG_ERR, "Not a directory? %s\n", rec_dir);
return NULL;
}
}
}
char newname[1024];
memset(newname, 0, 1024);
if(rec_file == NULL) {
/* Choose a random username */
if(!rec_tempname) {
/* Use .mjr as an extension right away */
g_snprintf(newname, 1024, "janus-recording-%"SCNu32".mjr", janus_random_uint32());
} else {
/* Append the temporary extension to .mjr, we'll rename when closing */
g_snprintf(newname, 1024, "janus-recording-%"SCNu32".mjr.%s", janus_random_uint32(), rec_tempext);
}
} else {
/* Just append the extension */
if(!rec_tempname) {
/* Use .mjr as an extension right away */
g_snprintf(newname, 1024, "%s.mjr", rec_file);
} else {
/* Append the temporary extension to .mjr, we'll rename when closing */
g_snprintf(newname, 1024, "%s.mjr.%s", rec_file, rec_tempext);
}
}
/* Try opening the file now */
if(rec_dir == NULL) {
rc->file = fopen(newname, "wb");
} else {
char path[1024];
memset(path, 0, 1024);
g_snprintf(path, 1024, "%s/%s", rec_dir, newname);
rc->file = fopen(path, "wb");
}
if(rc->file == NULL) {
JANUS_LOG(LOG_ERR, "fopen error: %d\n", errno);
return NULL;
}
if(rec_dir)
rc->dir = g_strdup(rec_dir);
rc->filename = g_strdup(newname);
rc->type = type;
/* Write the first part of the header */
fwrite(header, sizeof(char), strlen(header), rc->file);
g_atomic_int_set(&rc->writable, 1);
/* We still need to also write the info header first */
g_atomic_int_set(&rc->header, 0);
janus_mutex_init(&rc->mutex);
/* Done */
g_atomic_int_set(&rc->destroyed, 0);
janus_refcount_init(&rc->ref, janus_recorder_free);
g_free(copy_for_parent);
g_free(copy_for_base);
return rc;
}
/* Thread to handle incoming messages */
static void *janus_videocall_handler(void *data) {
JANUS_LOG(LOG_VERB, "Joining VideoCall handler thread\n");
janus_videocall_message *msg = NULL;
int error_code = 0;
char error_cause[512];
json_t *root = NULL;
while(g_atomic_int_get(&initialized) && !g_atomic_int_get(&stopping)) {
msg = g_async_queue_pop(messages);
if(msg == NULL)
continue;
if(msg == &exit_message)
break;
if(msg->handle == NULL) {
janus_videocall_message_free(msg);
continue;
}
janus_videocall_session *session = (janus_videocall_session *)msg->handle->plugin_handle;
if(!session) {
JANUS_LOG(LOG_ERR, "No session associated with this handle...\n");
janus_videocall_message_free(msg);
continue;
}
if(session->destroyed) {
janus_videocall_message_free(msg);
continue;
}
/* Handle request */
error_code = 0;
root = NULL;
JANUS_LOG(LOG_VERB, "Handling message: %s\n", msg->message);
if(msg->message == NULL) {
JANUS_LOG(LOG_ERR, "No message??\n");
error_code = JANUS_VIDEOCALL_ERROR_NO_MESSAGE;
g_snprintf(error_cause, 512, "%s", "No message??");
goto error;
}
json_error_t error;
root = json_loads(msg->message, 0, &error);
if(!root) {
JANUS_LOG(LOG_ERR, "JSON error: on line %d: %s\n", error.line, error.text);
error_code = JANUS_VIDEOCALL_ERROR_INVALID_JSON;
g_snprintf(error_cause, 512, "JSON error: on line %d: %s", error.line, error.text);
goto error;
}
if(!json_is_object(root)) {
JANUS_LOG(LOG_ERR, "JSON error: not an object\n");
error_code = JANUS_VIDEOCALL_ERROR_INVALID_JSON;
g_snprintf(error_cause, 512, "JSON error: not an object");
goto error;
}
JANUS_VALIDATE_JSON_OBJECT(root, request_parameters,
error_code, error_cause, TRUE,
JANUS_VIDEOCALL_ERROR_MISSING_ELEMENT, JANUS_VIDEOCALL_ERROR_INVALID_ELEMENT);
if(error_code != 0)
goto error;
json_t *request = json_object_get(root, "request");
const char *request_text = json_string_value(request);
json_t *result = NULL;
char *sdp_type = NULL, *sdp = NULL;
if(!strcasecmp(request_text, "list")) {
result = json_object();
json_t *list = json_array();
JANUS_LOG(LOG_VERB, "Request for the list of peers\n");
/* Return a list of all available mountpoints */
janus_mutex_lock(&sessions_mutex);
GHashTableIter iter;
gpointer value;
g_hash_table_iter_init(&iter, sessions);
while (g_hash_table_iter_next(&iter, NULL, &value)) {
janus_videocall_session *user = value;
if(user != NULL && user->username != NULL)
json_array_append_new(list, json_string(user->username));
}
json_object_set_new(result, "list", list);
janus_mutex_unlock(&sessions_mutex);
} else if(!strcasecmp(request_text, "register")) {
/* Map this handle to a username */
if(session->username != NULL) {
JANUS_LOG(LOG_ERR, "Already registered (%s)\n", session->username);
error_code = JANUS_VIDEOCALL_ERROR_ALREADY_REGISTERED;
g_snprintf(error_cause, 512, "Already registered (%s)", session->username);
goto error;
}
JANUS_VALIDATE_JSON_OBJECT(root, username_parameters,
error_code, error_cause, TRUE,
JANUS_VIDEOCALL_ERROR_MISSING_ELEMENT, JANUS_VIDEOCALL_ERROR_INVALID_ELEMENT);
if(error_code != 0)
goto error;
json_t *username = json_object_get(root, "username");
const char *username_text = json_string_value(username);
janus_mutex_lock(&sessions_mutex);
if(g_hash_table_lookup(sessions, username_text) != NULL) {
janus_mutex_unlock(&sessions_mutex);
JANUS_LOG(LOG_ERR, "Username '%s' already taken\n", username_text);
error_code = JANUS_VIDEOCALL_ERROR_USERNAME_TAKEN;
g_snprintf(error_cause, 512, "Username '%s' already taken", username_text);
goto error;
}
janus_mutex_unlock(&sessions_mutex);
session->username = g_strdup(username_text);
if(session->username == NULL) {
JANUS_LOG(LOG_FATAL, "Memory error!\n");
error_code = JANUS_VIDEOCALL_ERROR_UNKNOWN_ERROR;
g_snprintf(error_cause, 512, "Memory error");
goto error;
}
janus_mutex_lock(&sessions_mutex);
g_hash_table_insert(sessions, (gpointer)session->username, session);
janus_mutex_unlock(&sessions_mutex);
result = json_object();
json_object_set_new(result, "event", json_string("registered"));
json_object_set_new(result, "username", json_string(username_text));
} else if(!strcasecmp(request_text, "call")) {
/* Call another peer */
if(session->username == NULL) {
JANUS_LOG(LOG_ERR, "Register a username first\n");
error_code = JANUS_VIDEOCALL_ERROR_REGISTER_FIRST;
g_snprintf(error_cause, 512, "Register a username first");
goto error;
}
if(session->peer != NULL) {
JANUS_LOG(LOG_ERR, "Already in a call\n");
error_code = JANUS_VIDEOCALL_ERROR_ALREADY_IN_CALL;
g_snprintf(error_cause, 512, "Already in a call");
goto error;
}
JANUS_VALIDATE_JSON_OBJECT(root, username_parameters,
error_code, error_cause, TRUE,
JANUS_VIDEOCALL_ERROR_MISSING_ELEMENT, JANUS_VIDEOCALL_ERROR_INVALID_ELEMENT);
if(error_code != 0)
goto error;
json_t *username = json_object_get(root, "username");
const char *username_text = json_string_value(username);
if(!strcmp(username_text, session->username)) {
JANUS_LOG(LOG_ERR, "You can't call yourself... use the EchoTest for that\n");
error_code = JANUS_VIDEOCALL_ERROR_USE_ECHO_TEST;
g_snprintf(error_cause, 512, "You can't call yourself... use the EchoTest for that");
goto error;
}
janus_mutex_lock(&sessions_mutex);
janus_videocall_session *peer = g_hash_table_lookup(sessions, username_text);
if(peer == NULL || peer->destroyed) {
janus_mutex_unlock(&sessions_mutex);
JANUS_LOG(LOG_ERR, "Username '%s' doesn't exist\n", username_text);
error_code = JANUS_VIDEOCALL_ERROR_NO_SUCH_USERNAME;
g_snprintf(error_cause, 512, "Username '%s' doesn't exist", username_text);
goto error;
}
if(peer->peer != NULL) {
janus_mutex_unlock(&sessions_mutex);
JANUS_LOG(LOG_VERB, "%s is busy\n", username_text);
result = json_object();
json_object_set_new(result, "event", json_string("hangup"));
json_object_set_new(result, "username", json_string(session->username));
json_object_set_new(result, "reason", json_string("User busy"));
} else {
janus_mutex_unlock(&sessions_mutex);
/* Any SDP to handle? if not, something's wrong */
if(!msg->sdp) {
JANUS_LOG(LOG_ERR, "Missing SDP\n");
error_code = JANUS_VIDEOCALL_ERROR_MISSING_SDP;
g_snprintf(error_cause, 512, "Missing SDP");
goto error;
}
janus_mutex_lock(&sessions_mutex);
session->peer = peer;
peer->peer = session;
session->has_audio = (strstr(msg->sdp, "m=audio") != NULL);
session->has_video = (strstr(msg->sdp, "m=video") != NULL);
janus_mutex_unlock(&sessions_mutex);
JANUS_LOG(LOG_VERB, "%s is calling %s\n", session->username, session->peer->username);
JANUS_LOG(LOG_VERB, "This is involving a negotiation (%s) as well:\n%s\n", msg->sdp_type, msg->sdp);
/* Send SDP to our peer */
json_t *call = json_object();
json_object_set_new(call, "videocall", json_string("event"));
json_t *calling = json_object();
json_object_set_new(calling, "event", json_string("incomingcall"));
json_object_set_new(calling, "username", json_string(session->username));
json_object_set_new(call, "result", calling);
char *call_text = json_dumps(call, JSON_INDENT(3) | JSON_PRESERVE_ORDER);
json_decref(call);
/* Make also sure we get rid of ULPfec, red, etc. */
char *sdp = g_strdup(msg->sdp);
if(strstr(sdp, "ulpfec")) {
/* FIXME This really needs some better code */
sdp = janus_string_replace(sdp, "a=rtpmap:116 red/90000\r\n", "");
sdp = janus_string_replace(sdp, "a=rtpmap:117 ulpfec/90000\r\n", "");
sdp = janus_string_replace(sdp, "a=rtpmap:96 rtx/90000\r\n", "");
sdp = janus_string_replace(sdp, "a=fmtp:96 apt=100\r\n", "");
sdp = janus_string_replace(sdp, "a=rtpmap:97 rtx/90000\r\n", "");
sdp = janus_string_replace(sdp, "a=fmtp:97 apt=101\r\n", "");
sdp = janus_string_replace(sdp, "a=rtpmap:98 rtx/90000\r\n", "");
sdp = janus_string_replace(sdp, "a=fmtp:98 apt=116\r\n", "");
sdp = janus_string_replace(sdp, " 116", "");
sdp = janus_string_replace(sdp, " 117", "");
sdp = janus_string_replace(sdp, " 96", "");
sdp = janus_string_replace(sdp, " 97", "");
sdp = janus_string_replace(sdp, " 98", "");
}
g_atomic_int_set(&session->hangingup, 0);
JANUS_LOG(LOG_VERB, "Pushing event to peer: %s\n", call_text);
int ret = gateway->push_event(peer->handle, &janus_videocall_plugin, NULL, call_text, msg->sdp_type, sdp);
g_free(sdp);
JANUS_LOG(LOG_VERB, " >> %d (%s)\n", ret, janus_get_api_error(ret));
g_free(call_text);
/* Send an ack back */
result = json_object();
json_object_set_new(result, "event", json_string("calling"));
}
} else if(!strcasecmp(request_text, "accept")) {
/* Accept a call from another peer */
if(session->peer == NULL) {
JANUS_LOG(LOG_ERR, "No incoming call to accept\n");
error_code = JANUS_VIDEOCALL_ERROR_NO_CALL;
g_snprintf(error_cause, 512, "No incoming call to accept");
goto error;
}
/* Any SDP to handle? if not, something's wrong */
if(!msg->sdp) {
JANUS_LOG(LOG_ERR, "Missing SDP\n");
error_code = JANUS_VIDEOCALL_ERROR_MISSING_SDP;
g_snprintf(error_cause, 512, "Missing SDP");
goto error;
}
JANUS_LOG(LOG_VERB, "%s is accepting a call from %s\n", session->username, session->peer->username);
JANUS_LOG(LOG_VERB, "This is involving a negotiation (%s) as well:\n%s\n", msg->sdp_type, msg->sdp);
session->has_audio = (strstr(msg->sdp, "m=audio") != NULL);
session->has_video = (strstr(msg->sdp, "m=video") != NULL);
/* Send SDP to our peer */
json_t *call = json_object();
json_object_set_new(call, "videocall", json_string("event"));
json_t *calling = json_object();
json_object_set_new(calling, "event", json_string("accepted"));
json_object_set_new(calling, "username", json_string(session->username));
json_object_set_new(call, "result", calling);
char *call_text = json_dumps(call, JSON_INDENT(3) | JSON_PRESERVE_ORDER);
json_decref(call);
g_atomic_int_set(&session->hangingup, 0);
JANUS_LOG(LOG_VERB, "Pushing event to peer: %s\n", call_text);
int ret = gateway->push_event(session->peer->handle, &janus_videocall_plugin, NULL, call_text, msg->sdp_type, msg->sdp);
JANUS_LOG(LOG_VERB, " >> %d (%s)\n", ret, janus_get_api_error(ret));
g_free(call_text);
/* Send an ack back */
result = json_object();
json_object_set_new(result, "event", json_string("accepted"));
} else if(!strcasecmp(request_text, "set")) {
/* Update the local configuration (audio/video mute/unmute, bitrate cap or recording) */
JANUS_VALIDATE_JSON_OBJECT(root, set_parameters,
error_code, error_cause, TRUE,
JANUS_VIDEOCALL_ERROR_MISSING_ELEMENT, JANUS_VIDEOCALL_ERROR_INVALID_ELEMENT);
if(error_code != 0)
goto error;
json_t *audio = json_object_get(root, "audio");
json_t *video = json_object_get(root, "video");
json_t *bitrate = json_object_get(root, "bitrate");
json_t *record = json_object_get(root, "record");
json_t *recfile = json_object_get(root, "filename");
if(audio) {
session->audio_active = json_is_true(audio);
JANUS_LOG(LOG_VERB, "Setting audio property: %s\n", session->audio_active ? "true" : "false");
}
if(video) {
if(!session->video_active && json_is_true(video)) {
/* Send a PLI */
JANUS_LOG(LOG_VERB, "Just (re-)enabled video, sending a PLI to recover it\n");
char buf[12];
memset(buf, 0, 12);
janus_rtcp_pli((char *)&buf, 12);
gateway->relay_rtcp(session->handle, 1, buf, 12);
}
session->video_active = json_is_true(video);
JANUS_LOG(LOG_VERB, "Setting video property: %s\n", session->video_active ? "true" : "false");
}
if(bitrate) {
session->bitrate = json_integer_value(bitrate);
JANUS_LOG(LOG_VERB, "Setting video bitrate: %"SCNu64"\n", session->bitrate);
if(session->bitrate > 0) {
/* FIXME Generate a new REMB (especially useful for Firefox, which doesn't send any we can cap later) */
char buf[24];
memset(buf, 0, 24);
janus_rtcp_remb((char *)&buf, 24, session->bitrate);
JANUS_LOG(LOG_VERB, "Sending REMB\n");
gateway->relay_rtcp(session->handle, 1, buf, 24);
/* FIXME How should we handle a subsequent "no limit" bitrate? */
}
}
if(record) {
if(msg->sdp) {
session->has_audio = (strstr(msg->sdp, "m=audio") != NULL);
session->has_video = (strstr(msg->sdp, "m=video") != NULL);
}
gboolean recording = json_is_true(record);
const char *recording_base = json_string_value(recfile);
JANUS_LOG(LOG_VERB, "Recording %s (base filename: %s)\n", recording ? "enabled" : "disabled", recording_base ? recording_base : "not provided");
janus_mutex_lock(&session->rec_mutex);
if(!recording) {
/* Not recording (anymore?) */
if(session->arc) {
janus_recorder_close(session->arc);
JANUS_LOG(LOG_INFO, "Closed audio recording %s\n", session->arc->filename ? session->arc->filename : "??");
janus_recorder_free(session->arc);
}
session->arc = NULL;
if(session->vrc) {
janus_recorder_close(session->vrc);
JANUS_LOG(LOG_INFO, "Closed video recording %s\n", session->vrc->filename ? session->vrc->filename : "??");
janus_recorder_free(session->vrc);
}
session->vrc = NULL;
} else {
/* We've started recording, send a PLI and go on */
char filename[255];
gint64 now = janus_get_real_time();
if(session->has_audio) {
/* FIXME We assume we're recording Opus, here */
memset(filename, 0, 255);
if(recording_base) {
/* Use the filename and path we have been provided */
g_snprintf(filename, 255, "%s-audio", recording_base);
session->arc = janus_recorder_create(NULL, "opus", filename);
if(session->arc == NULL) {
/* FIXME We should notify the fact the recorder could not be created */
JANUS_LOG(LOG_ERR, "Couldn't open an audio recording file for this VideoCall user!\n");
}
} else {
/* Build a filename */
g_snprintf(filename, 255, "videocall-%s-%s-%"SCNi64"-audio",
session->username ? session->username : "******",
(session->peer && session->peer->username) ? session->peer->username : "******",
now);
session->arc = janus_recorder_create(NULL, "opus", filename);
if(session->arc == NULL) {
/* FIXME We should notify the fact the recorder could not be created */
JANUS_LOG(LOG_ERR, "Couldn't open an audio recording file for this VideoCall user!\n");
}
}
}
if(session->has_video) {
/* FIXME We assume we're recording VP8, here */
memset(filename, 0, 255);
if(recording_base) {
/* Use the filename and path we have been provided */
g_snprintf(filename, 255, "%s-video", recording_base);
session->vrc = janus_recorder_create(NULL, "vp8", filename);
if(session->vrc == NULL) {
/* FIXME We should notify the fact the recorder could not be created */
JANUS_LOG(LOG_ERR, "Couldn't open an video recording file for this VideoCall user!\n");
}
} else {
/* Build a filename */
g_snprintf(filename, 255, "videocall-%s-%s-%"SCNi64"-video",
session->username ? session->username : "******",
(session->peer && session->peer->username) ? session->peer->username : "******",
now);
session->vrc = janus_recorder_create(NULL, "vp8", filename);
if(session->vrc == NULL) {
/* FIXME We should notify the fact the recorder could not be created */
JANUS_LOG(LOG_ERR, "Couldn't open an video recording file for this VideoCall user!\n");
}
}
/* Send a PLI */
JANUS_LOG(LOG_VERB, "Recording video, sending a PLI to kickstart it\n");
char buf[12];
memset(buf, 0, 12);
janus_rtcp_pli((char *)&buf, 12);
gateway->relay_rtcp(session->handle, 1, buf, 12);
}
}
janus_mutex_unlock(&session->rec_mutex);
}
/* Send an ack back */
result = json_object();
json_object_set_new(result, "event", json_string("set"));
} else if(!strcasecmp(request_text, "hangup")) {
/* Hangup an ongoing call or reject an incoming one */
janus_mutex_lock(&sessions_mutex);
janus_videocall_session *peer = session->peer;
if(peer == NULL) {
JANUS_LOG(LOG_WARN, "No call to hangup\n");
} else {
JANUS_LOG(LOG_VERB, "%s is hanging up the call with %s\n", session->username, peer->username);
session->peer = NULL;
peer->peer = NULL;
}
janus_mutex_unlock(&sessions_mutex);
/* Notify the success as an hangup message */
result = json_object();
json_object_set_new(result, "event", json_string("hangup"));
json_object_set_new(result, "username", json_string(session->username));
json_object_set_new(result, "reason", json_string("We did the hangup"));
if(peer != NULL) {
/* Send event to our peer too */
json_t *call = json_object();
json_object_set_new(call, "videocall", json_string("event"));
json_t *calling = json_object();
json_object_set_new(calling, "event", json_string("hangup"));
json_object_set_new(calling, "username", json_string(session->username));
json_object_set_new(calling, "reason", json_string("Remote hangup"));
json_object_set_new(call, "result", calling);
char *call_text = json_dumps(call, JSON_INDENT(3) | JSON_PRESERVE_ORDER);
json_decref(call);
JANUS_LOG(LOG_VERB, "Pushing event to peer: %s\n", call_text);
int ret = gateway->push_event(peer->handle, &janus_videocall_plugin, NULL, call_text, NULL, NULL);
JANUS_LOG(LOG_VERB, " >> %d (%s)\n", ret, janus_get_api_error(ret));
g_free(call_text);
}
} else {
JANUS_LOG(LOG_ERR, "Unknown request (%s)\n", request_text);
error_code = JANUS_VIDEOCALL_ERROR_INVALID_REQUEST;
g_snprintf(error_cause, 512, "Unknown request (%s)", request_text);
goto error;
}
json_decref(root);
/* Prepare JSON event */
json_t *event = json_object();
json_object_set_new(event, "videocall", json_string("event"));
if(result != NULL)
json_object_set_new(event, "result", result);
char *event_text = json_dumps(event, JSON_INDENT(3) | JSON_PRESERVE_ORDER);
json_decref(event);
JANUS_LOG(LOG_VERB, "Pushing event: %s\n", event_text);
int ret = gateway->push_event(msg->handle, &janus_videocall_plugin, msg->transaction, event_text, sdp_type, sdp);
JANUS_LOG(LOG_VERB, " >> %d (%s)\n", ret, janus_get_api_error(ret));
g_free(event_text);
if(sdp)
g_free(sdp);
janus_videocall_message_free(msg);
continue;
error:
{
if(root != NULL)
json_decref(root);
/* Prepare JSON error event */
json_t *event = json_object();
json_object_set_new(event, "videocall", json_string("event"));
json_object_set_new(event, "error_code", json_integer(error_code));
json_object_set_new(event, "error", json_string(error_cause));
char *event_text = json_dumps(event, JSON_INDENT(3) | JSON_PRESERVE_ORDER);
json_decref(event);
JANUS_LOG(LOG_VERB, "Pushing event: %s\n", event_text);
int ret = gateway->push_event(msg->handle, &janus_videocall_plugin, msg->transaction, event_text, NULL, NULL);
JANUS_LOG(LOG_VERB, " >> %d (%s)\n", ret, janus_get_api_error(ret));
g_free(event_text);
janus_videocall_message_free(msg);
}
}
JANUS_LOG(LOG_VERB, "Leaving VideoCall handler thread\n");
return NULL;
}
/* Thread to handle incoming messages */
static void *janus_echotest_handler(void *data) {
JANUS_LOG(LOG_VERB, "Joining EchoTest handler thread\n");
janus_echotest_message *msg = NULL;
int error_code = 0;
char *error_cause = g_malloc0(512);
if(error_cause == NULL) {
JANUS_LOG(LOG_FATAL, "Memory error!\n");
return NULL;
}
json_t *root = NULL;
while(g_atomic_int_get(&initialized) && !g_atomic_int_get(&stopping)) {
msg = g_async_queue_pop(messages);
if(msg == NULL)
continue;
if(msg == &exit_message)
break;
if(msg->handle == NULL) {
janus_echotest_message_free(msg);
continue;
}
janus_echotest_session *session = NULL;
janus_mutex_lock(&sessions_mutex);
if(g_hash_table_lookup(sessions, msg->handle) != NULL ) {
session = (janus_echotest_session *)msg->handle->plugin_handle;
}
janus_mutex_unlock(&sessions_mutex);
if(!session) {
JANUS_LOG(LOG_ERR, "No session associated with this handle...\n");
janus_echotest_message_free(msg);
continue;
}
if(session->destroyed) {
janus_echotest_message_free(msg);
continue;
}
/* Handle request */
error_code = 0;
root = NULL;
JANUS_LOG(LOG_VERB, "Handling message: %s\n", msg->message);
if(msg->message == NULL) {
JANUS_LOG(LOG_ERR, "No message??\n");
error_code = JANUS_ECHOTEST_ERROR_NO_MESSAGE;
g_snprintf(error_cause, 512, "%s", "No message??");
goto error;
}
json_error_t error;
root = json_loads(msg->message, 0, &error);
if(!root) {
JANUS_LOG(LOG_ERR, "JSON error: on line %d: %s\n", error.line, error.text);
error_code = JANUS_ECHOTEST_ERROR_INVALID_JSON;
g_snprintf(error_cause, 512, "JSON error: on line %d: %s", error.line, error.text);
goto error;
}
if(!json_is_object(root)) {
JANUS_LOG(LOG_ERR, "JSON error: not an object\n");
error_code = JANUS_ECHOTEST_ERROR_INVALID_JSON;
g_snprintf(error_cause, 512, "JSON error: not an object");
goto error;
}
/* Parse request */
json_t *audio = json_object_get(root, "audio");
if(audio && !json_is_boolean(audio)) {
JANUS_LOG(LOG_ERR, "Invalid element (audio should be a boolean)\n");
error_code = JANUS_ECHOTEST_ERROR_INVALID_ELEMENT;
g_snprintf(error_cause, 512, "Invalid value (audio should be a boolean)");
goto error;
}
json_t *video = json_object_get(root, "video");
if(video && !json_is_boolean(video)) {
JANUS_LOG(LOG_ERR, "Invalid element (video should be a boolean)\n");
error_code = JANUS_ECHOTEST_ERROR_INVALID_ELEMENT;
g_snprintf(error_cause, 512, "Invalid value (video should be a boolean)");
goto error;
}
json_t *bitrate = json_object_get(root, "bitrate");
if(bitrate && (!json_is_integer(bitrate) || json_integer_value(bitrate) < 0)) {
JANUS_LOG(LOG_ERR, "Invalid element (bitrate should be a positive integer)\n");
error_code = JANUS_ECHOTEST_ERROR_INVALID_ELEMENT;
g_snprintf(error_cause, 512, "Invalid value (bitrate should be a positive integer)");
goto error;
}
json_t *record = json_object_get(root, "record");
if(record && !json_is_boolean(record)) {
JANUS_LOG(LOG_ERR, "Invalid element (record should be a boolean)\n");
error_code = JANUS_ECHOTEST_ERROR_INVALID_ELEMENT;
g_snprintf(error_cause, 512, "Invalid value (record should be a boolean)");
goto error;
}
json_t *recfile = json_object_get(root, "filename");
if(recfile && !json_is_string(recfile)) {
JANUS_LOG(LOG_ERR, "Invalid element (filename should be a string)\n");
error_code = JANUS_ECHOTEST_ERROR_INVALID_ELEMENT;
g_snprintf(error_cause, 512, "Invalid value (filename should be a string)");
goto error;
}
/* Enforce request */
if(audio) {
session->audio_active = json_is_true(audio);
JANUS_LOG(LOG_VERB, "Setting audio property: %s\n", session->audio_active ? "true" : "false");
}
if(video) {
if(!session->video_active && json_is_true(video)) {
/* Send a PLI */
JANUS_LOG(LOG_VERB, "Just (re-)enabled video, sending a PLI to recover it\n");
char buf[12];
memset(buf, 0, 12);
janus_rtcp_pli((char *)&buf, 12);
gateway->relay_rtcp(session->handle, 1, buf, 12);
}
session->video_active = json_is_true(video);
JANUS_LOG(LOG_VERB, "Setting video property: %s\n", session->video_active ? "true" : "false");
}
if(bitrate) {
session->bitrate = json_integer_value(bitrate);
JANUS_LOG(LOG_VERB, "Setting video bitrate: %"SCNu64"\n", session->bitrate);
if(session->bitrate > 0) {
/* FIXME Generate a new REMB (especially useful for Firefox, which doesn't send any we can cap later) */
char buf[24];
memset(buf, 0, 24);
janus_rtcp_remb((char *)&buf, 24, session->bitrate);
JANUS_LOG(LOG_VERB, "Sending REMB\n");
gateway->relay_rtcp(session->handle, 1, buf, 24);
/* FIXME How should we handle a subsequent "no limit" bitrate? */
}
}
if(record) {
if(msg->sdp) {
session->has_audio = (strstr(msg->sdp, "m=audio") != NULL);
session->has_video = (strstr(msg->sdp, "m=video") != NULL);
}
gboolean recording = json_is_true(record);
const char *recording_base = json_string_value(recfile);
JANUS_LOG(LOG_VERB, "Recording %s (base filename: %s)\n", recording ? "enabled" : "disabled", recording_base ? recording_base : "not provided");
if(!recording) {
/* Not recording (anymore?) */
if(session->arc) {
janus_recorder_close(session->arc);
JANUS_LOG(LOG_INFO, "Closed audio recording %s\n", session->arc->filename ? session->arc->filename : "??");
janus_recorder_free(session->arc);
}
session->arc = NULL;
if(session->vrc) {
janus_recorder_close(session->vrc);
JANUS_LOG(LOG_INFO, "Closed video recording %s\n", session->vrc->filename ? session->vrc->filename : "??");
janus_recorder_free(session->vrc);
}
session->vrc = NULL;
} else {
/* We've started recording, send a PLI and go on */
char filename[255];
gint64 now = janus_get_real_time();
if(session->has_audio) {
/* FIXME We assume we're recording Opus, here */
memset(filename, 0, 255);
if(recording_base) {
/* Use the filename and path we have been provided */
g_snprintf(filename, 255, "%s-audio", recording_base);
session->arc = janus_recorder_create(NULL, "opus", filename);
if(session->arc == NULL) {
/* FIXME We should notify the fact the recorder could not be created */
JANUS_LOG(LOG_ERR, "Couldn't open an audio recording file for this EchoTest user!\n");
}
} else {
/* Build a filename */
g_snprintf(filename, 255, "echotest-%p-%"SCNi64"-audio", session, now);
session->arc = janus_recorder_create(NULL, "opus", filename);
if(session->arc == NULL) {
/* FIXME We should notify the fact the recorder could not be created */
JANUS_LOG(LOG_ERR, "Couldn't open an audio recording file for this EchoTest user!\n");
}
}
}
if(session->has_video) {
/* FIXME We assume we're recording VP8, here */
memset(filename, 0, 255);
if(recording_base) {
/* Use the filename and path we have been provided */
g_snprintf(filename, 255, "%s-video", recording_base);
session->vrc = janus_recorder_create(NULL, "vp8", filename);
if(session->vrc == NULL) {
/* FIXME We should notify the fact the recorder could not be created */
JANUS_LOG(LOG_ERR, "Couldn't open an video recording file for this EchoTest user!\n");
}
} else {
/* Build a filename */
g_snprintf(filename, 255, "echotest-%p-%"SCNi64"-video", session, now);
session->vrc = janus_recorder_create(NULL, "vp8", filename);
if(session->vrc == NULL) {
/* FIXME We should notify the fact the recorder could not be created */
JANUS_LOG(LOG_ERR, "Couldn't open an video recording file for this EchoTest user!\n");
}
}
/* Send a PLI */
JANUS_LOG(LOG_VERB, "Recording video, sending a PLI to kickstart it\n");
char buf[12];
memset(buf, 0, 12);
janus_rtcp_pli((char *)&buf, 12);
gateway->relay_rtcp(session->handle, 1, buf, 12);
}
}
}
/* Any SDP to handle? */
if(msg->sdp) {
JANUS_LOG(LOG_VERB, "This is involving a negotiation (%s) as well:\n%s\n", msg->sdp_type, msg->sdp);
session->has_audio = (strstr(msg->sdp, "m=audio") != NULL);
session->has_video = (strstr(msg->sdp, "m=video") != NULL);
}
if(!audio && !video && !bitrate && !record && !msg->sdp) {
JANUS_LOG(LOG_ERR, "No supported attributes (audio, video, bitrate, record, jsep) found\n");
error_code = JANUS_ECHOTEST_ERROR_INVALID_ELEMENT;
g_snprintf(error_cause, 512, "Message error: no supported attributes (audio, video, bitrate, record, jsep) found");
goto error;
}
json_decref(root);
/* Prepare JSON event */
json_t *event = json_object();
json_object_set_new(event, "echotest", json_string("event"));
json_object_set_new(event, "result", json_string("ok"));
char *event_text = json_dumps(event, JSON_INDENT(3) | JSON_PRESERVE_ORDER);
json_decref(event);
JANUS_LOG(LOG_VERB, "Pushing event: %s\n", event_text);
if(!msg->sdp) {
int ret = gateway->push_event(msg->handle, &janus_echotest_plugin, msg->transaction, event_text, NULL, NULL);
JANUS_LOG(LOG_VERB, " >> %d (%s)\n", ret, janus_get_api_error(ret));
} else {
/* Forward the same offer to the gateway, to start the echo test */
const char *type = NULL;
if(!strcasecmp(msg->sdp_type, "offer"))
type = "answer";
if(!strcasecmp(msg->sdp_type, "answer"))
type = "offer";
/* Any media direction that needs to be fixed? */
char *sdp = g_strdup(msg->sdp);
if(strstr(sdp, "a=recvonly")) {
/* Turn recvonly to inactive, as we simply bounce media back */
sdp = janus_string_replace(sdp, "a=recvonly", "a=inactive");
} else if(strstr(sdp, "a=sendonly")) {
/* Turn sendonly to recvonly */
sdp = janus_string_replace(sdp, "a=sendonly", "a=recvonly");
/* FIXME We should also actually not echo this media back, though... */
}
/* Make also sure we get rid of ULPfec, red, etc. */
if(strstr(sdp, "ulpfec")) {
/* FIXME This really needs some better code */
sdp = janus_string_replace(sdp, "a=rtpmap:116 red/90000\r\n", "");
sdp = janus_string_replace(sdp, "a=rtpmap:117 ulpfec/90000\r\n", "");
sdp = janus_string_replace(sdp, "a=rtpmap:96 rtx/90000\r\n", "");
sdp = janus_string_replace(sdp, "a=fmtp:96 apt=100\r\n", "");
sdp = janus_string_replace(sdp, "a=rtpmap:97 rtx/90000\r\n", "");
sdp = janus_string_replace(sdp, "a=fmtp:97 apt=101\r\n", "");
sdp = janus_string_replace(sdp, "a=rtpmap:98 rtx/90000\r\n", "");
sdp = janus_string_replace(sdp, "a=fmtp:98 apt=116\r\n", "");
sdp = janus_string_replace(sdp, " 116", "");
sdp = janus_string_replace(sdp, " 117", "");
sdp = janus_string_replace(sdp, " 96", "");
sdp = janus_string_replace(sdp, " 97", "");
sdp = janus_string_replace(sdp, " 98", "");
}
/* How long will the gateway take to push the event? */
g_atomic_int_set(&session->hangingup, 0);
gint64 start = janus_get_monotonic_time();
int res = gateway->push_event(msg->handle, &janus_echotest_plugin, msg->transaction, event_text, type, sdp);
JANUS_LOG(LOG_VERB, " >> Pushing event: %d (took %"SCNu64" us)\n",
res, janus_get_monotonic_time()-start);
g_free(sdp);
}
g_free(event_text);
janus_echotest_message_free(msg);
continue;
error:
{
if(root != NULL)
json_decref(root);
/* Prepare JSON error event */
json_t *event = json_object();
json_object_set_new(event, "echotest", json_string("event"));
json_object_set_new(event, "error_code", json_integer(error_code));
json_object_set_new(event, "error", json_string(error_cause));
char *event_text = json_dumps(event, JSON_INDENT(3) | JSON_PRESERVE_ORDER);
json_decref(event);
JANUS_LOG(LOG_VERB, "Pushing event: %s\n", event_text);
int ret = gateway->push_event(msg->handle, &janus_echotest_plugin, msg->transaction, event_text, NULL, NULL);
JANUS_LOG(LOG_VERB, " >> %d (%s)\n", ret, janus_get_api_error(ret));
g_free(event_text);
janus_echotest_message_free(msg);
}
}
g_free(error_cause);
JANUS_LOG(LOG_VERB, "Leaving EchoTest handler thread\n");
return NULL;
}