janus-gateway的videoroom插件的RTP包录制功能源码详解

已于 2024-02-24 19:57:07 修改
阅读量714 收藏 8
点赞数 6
文章标签： janus-gateway record webrtc rtmp
于 2024-02-24 19:49:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fireroll/article/details/136274799
版权

引:

janus-gateway在配置文件设置后，可以实现对videoroom插件的每个publisher的音频，视频，数据的RTP流录制成mjr文件。

对于音频，视频的mjr文件，可以使用自带的postprocessing工具janus-pp-rec转成mp4文件。

每个publisher音频和视频mjr文件是分立的两个文件，需要使用ffmpeg将两个合成一个mp4文件。

janus-gateway的原生代码中的录制功能是通过配置文件实现，只能配置成要么录，要么不录。如果要通过客户端的信令进行可控的频繁开关，则需要修改源码实现。

如果要对videoroom的publisher的RTP流转成RTMP流推送出去，可以使用第三方的enhanced-videoroom插件实现。

一、配置文件的录制参数设置

etc/janus/janus.plugin.videoroom.jcfg
房间中和录制相关的参数

# room-<unique room ID>: {
# description = This is my awesome room
...
# record = true|false (whether this room should be recorded, default=false)
# rec_dir = <folder where recordings should be stored, when enabled>
# lock_record = true|false (whether recording can only be started/stopped if the secret
#            is provided, or using the global enable_recording request, default=false)
#}
配置实例
room-1234: {
		description = "Demo Room"
		secret = "adminpwd"
		publishers = 6
		bitrate = 128000
		fir_freq = 10
		audiocodec = "opus"
		videocodec = "h264"
		record = true
		rec_dir = "/data/PJT-janus/record-samples"
}

二、录制初始化

当客户端为发布者，且发送的message为"configure"类型时，
将初始化录制, 将初始化音频、视频和数据文件的存储路径、文件名后，
打开文件以获得文件句柄后，写入文件头。

// janus_videoroom.c
static json_t *janus_videoroom_process_synchronous_request(janus_videoroom_session *session, json_t *message) {
	
	if(!strcasecmp(request_text, "create")) {
		/* Create a new VideoRoom */
		/* Added by Hank, For recording: */
		// if(rec_dir) {
			// videoroom->rec_dir = g_strdup(json_string_value(rec_dir));
		if (g_record_root_path != NULL) {
            videoroom->rec_dir = g_strdup(g_record_root_path);
			
            // 修改文件存储路径,在原有的录制根目录下,添加 /年月日/房间号/
			char new_rec_dir_arr[255] = {0};
				
			time_t timestamp = time(NULL); 
			struct tm *local_time = localtime(&timestamp);
			char formatted_date[11]={0};
			strftime(formatted_date,sizeof(formatted_date), "%Y%m%d",local_time);
			
			g_snprintf(new_rec_dir_arr, 255, "%s/%s/%s/",
					videoroom->rec_dir, formatted_date, videoroom->room_id_str);
			char *old_rec_dir = videoroom->rec_dir;
			char *new_rec_dir = g_strdup(new_rec_dir_arr);
			videoroom->rec_dir = new_rec_dir;
			g_free(old_rec_dir);		
			/* END-OF-Hank */
			
		}		
	}
}
/* Thread to handle incoming messages 
 * 当有房间“configure"消息时，
 * 进行本房间的发布者对应的视频、音频、数据录制文件创建
 */
static void *janus_videoroom_handler(void *data) {
	while(g_atomic_int_get(&initialized) && !g_atomic_int_get(&stopping)) {
		msg = g_async_queue_pop(messages);
		janus_videoroom *videoroom = NULL;
		janus_videoroom_publisher *participant = NULL;
		janus_videoroom_subscriber *subscriber = NULL;
		
		janus_mutex_lock(&sessions_mutex);
		janus_videoroom_session *session = janus_videoroom_lookup_session(msg->handle);
		janus_mutex_unlock(&sessions_mutex);
		
		if(session->participant_type == janus_videoroom_p_type_none) {
			...
		} else if(session->participant_type == janus_videoroom_p_type_publisher) {
			/* 当 request_text = "configure" 时 */
			json_t *request = json_object_get(root, "request");
			const char *request_text = json_string_value(request);
			if(!strcasecmp(request_text, "join") 
		       || !strcasecmp(request_text, "joinandconfigure")) {
			   ...
			} else if(!strcasecmp(request_text, "configure") 
			          || !strcasecmp(request_text, "publish")) {
				   
					/* 录制相关配置，并创建本publisher的Video/Audio/Data录制文件  */
					gboolean record_locked = FALSE;
					if((record || recfile) && participant->room->lock_record && participant->room->room_secret) {
						JANUS_CHECK_SECRET(participant->room->room_secret, root, "secret", error_code, error_cause,
							JANUS_VIDEOROOM_ERROR_MISSING_ELEMENT, JANUS_VIDEOROOM_ERROR_INVALID_ELEMENT, JANUS_VIDEOROOM_ERROR_UNAUTHORIZED);
						if(error_code != 0) {
							/* Wrong secret provided, we'll prevent the recording state from being changed */
							record_locked = TRUE;
						}
					}
					janus_mutex_lock(&participant->rec_mutex);
					gboolean prev_recording_active = participant->recording_active;
					if(record && !record_locked) {
						participant->recording_active = json_is_true(record);
						JANUS_LOG(LOG_VERB, "Setting record property: %s (room %s, user %s)\n",
							participant->recording_active ? "true" : "false", participant->room_id_str, participant->user_id_str);
					}
					if(recfile && !record_locked) {
						participant->recording_base = g_strdup(json_string_value(recfile));
						JANUS_LOG(LOG_VERB, "Setting recording basename: %s (room %s, user %s)\n",
							participant->recording_base, participant->room_id_str, participant->user_id_str);
					}
					/* Do we need to do something with the recordings right now? */
					if(participant->recording_active != prev_recording_active) {
						/* Something changed */
						if(!participant->recording_active) {
							/* Not recording (anymore?) */
							janus_videoroom_recorder_close(participant);
						} else if(participant->recording_active && g_atomic_int_get(&participant->session->started)) {
							/* We've started recording, send a PLI/FIR and go on */
							GList *temp = participant->streams;
							while(temp) {
								janus_videoroom_publisher_stream *ps = (janus_videoroom_publisher_stream *)temp->data;
											
								janus_videoroom_recorder_create(participant, 
									participant->audio, participant->video, 
									participant->data); 
						}
						janus_mutex_unlock(&participant->rec_mutex);
						。。。
					}
				}
				janus_videoroom_message_free(msg);
				continue;
			}
		}
	} // end of while(g_atomic_int_get(&initialized) ...)
	return NULL;
}

/**********  创建本发布者对应的音频、视频、数据录制文件 *******************/
static void janus_videoroom_recorder_create(janus_videoroom_publisher *participant, 
				 gboolean audio, gboolean video, 
				 gboolean data) {
	char filename[255];
	janus_recorder *rc = NULL;
	gint64 now = janus_get_real_time();

	// 设置音频文件的存储路径和文件名
	if(audio && participant->arc == NULL) {
		memset(filename, 0, 255);
		if(participant->recording_base) {
			/* Use the filename and path we have been provided */
			g_snprintf(filename, 255, "%s-audio", participant->recording_base);
			rc = janus_recorder_create(participant->room->rec_dir,
									   janus_audiocodec_name(participant->acodec), filename);
			if(rc == NULL) {
				JANUS_LOG(LOG_ERR, "Couldn't open an audio recording file for this publisher!\n");
			}
		} else {
			/* Build a filename */
			g_snprintf(filename, 255, "videoroom-%s-user-%s-%"SCNi64"-audio",
				participant->room_id_str, participant->user_id_str, now);
			rc = janus_recorder_create(participant->room->rec_dir,
										janus_audiocodec_name(participant->acodec), filename);
			if(rc == NULL) {
				JANUS_LOG(LOG_ERR, "Couldn't open an audio recording file for this publisher!\n");
			}
		}
		/* If media is encrypted, mark it in the recording */
		if(participant->e2ee)
			janus_recorder_encrypted(rc);
		participant->arc = rc;
	}

	// 设置视频文件的存储路径和文件名
	if(video && participant->vrc == NULL) {
		janus_rtp_switching_context_reset(&participant->rec_ctx);
		janus_rtp_simulcasting_context_reset(&participant->rec_simctx);
		participant->rec_simctx.substream_target = 2;
		participant->rec_simctx.templayer_target = 2;
		memset(filename, 0, 255);
		if(participant->recording_base) {
			/* Use the filename and path we have been provided */
			g_snprintf(filename, 255, "%s-video", participant->recording_base);
			rc = janus_recorder_create_full(participant->room->rec_dir,
											janus_videocodec_name(participant->vcodec), participant->vfmtp, filename);
			if(rc == NULL) {
				JANUS_LOG(LOG_ERR, "Couldn't open an video recording file for this publisher!\n");
			}
		} else {
			/* Build a filename */
			g_snprintf(filename, 255, "videoroom-%s-user-%s-%"SCNi64"-video",
				participant->room_id_str, participant->user_id_str, now);
			rc = janus_recorder_create_full(participant->room->rec_dir,
				janus_videocodec_name(participant->vcodec), participant->vfmtp, filename);
			if(rc == NULL) {
				JANUS_LOG(LOG_ERR, "Couldn't open an video recording file for this publisher!\n");
			}
		}
		/* If media is encrypted, mark it in the recording */
		if(participant->e2ee)
			janus_recorder_encrypted(rc);
		participant->vrc = rc;
	}

	// 设置数据文件的存储路径和文件名
	if(data && participant->drc == NULL) {
		memset(filename, 0, 255);
		if(participant->recording_base) {
			/* Use the filename and path we have been provided */
			g_snprintf(filename, 255, "%s-data", participant->recording_base);
			rc = janus_recorder_create(participant->room->rec_dir,
				"text", filename);
			if(rc == NULL) {
				JANUS_LOG(LOG_ERR, "Couldn't open an data recording file for this publisher!\n");
			}
		} else {
			/* Build a filename */
			g_snprintf(filename, 255, "videoroom-%s-user-%s-%"SCNi64"-data",
				participant->room_id_str, participant->user_id_str, now);
			rc = janus_recorder_create(participant->room->rec_dir,
				"text", filename);
			if(rc == NULL) {
				JANUS_LOG(LOG_ERR, "Couldn't open an data recording file for this publisher!\n");
			}
		}
		/* Media encryption doesn't apply to data channels */
		participant->drc = rc;
	}
}
// record.c
/* Info header in the structured recording */
static const char *header = "MJR00002";
/* Frame header in the structured recording */
static const char *frame_header = "MEET";

janus_recorder *janus_recorder_create(const char *dir, const char *codec, const char *filename) {
	/* Same as janus_recorder_create_full, but with no fmtp */
	return janus_recorder_create_full(dir, codec, NULL, filename);
}


/* 
打开文件;
写入文件头；MJR00002
*/
janus_recorder *janus_recorder_create_full(const char *dir, const char *codec, const char *fmtp, 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")
			 || !strcasecmp(codec, "av1") || !strcasecmp(codec, "h265")) {
		type = JANUS_RECORDER_VIDEO;
	} else if(!strcasecmp(codec, "opus") || !strcasecmp(codec, "multiopus")
			|| !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));
	janus_refcount_init(&rc->ref, janus_recorder_free);
	rc->dir = NULL;
	rc->filename = NULL;
	rc->file = NULL;
	rc->codec = g_strdup(codec);
	rc->fmtp = fmtp ? g_strdup(fmtp) : NULL;
	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;
	/* 检查路径和文件名是否合规 */
	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 (%s) error: %d (%s)\n", rec_dir, errno, strerror(errno));
					janus_recorder_destroy(rc);
					g_free(copy_for_parent);
					g_free(copy_for_base);
					return NULL;
				}
			} else {
				JANUS_LOG(LOG_ERR, "stat (%s) error: %d (%s)\n", rec_dir, errno, strerror(errno));
				janus_recorder_destroy(rc);
				g_free(copy_for_parent);
				g_free(copy_for_base);
				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);
				janus_recorder_destroy(rc);
				g_free(copy_for_parent);
				g_free(copy_for_base);
				return NULL;
			}
		}
	}
	char newname[1024];
	memset(newname, 0, 1024);
	// 给文件名加上.mjr的后缀
	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);
		}
	}
	/* 打开文件，准备写入 */
	if(rec_dir == NULL) {
		/* Make sure folder to save to is not protected */
		if(janus_is_folder_protected(newname)) {
			JANUS_LOG(LOG_ERR, "Target recording path '%s' is in protected folder...\n", newname);
			janus_recorder_destroy(rc);
			g_free(copy_for_parent);
			g_free(copy_for_base);
			return NULL;
		}
		rc->file = fopen(newname, "wb");
	} else {
		char path[1024];
		memset(path, 0, 1024);
		g_snprintf(path, 1024, "%s/%s", rec_dir, newname);
		/* Make sure folder to save to is not protected */
		if(janus_is_folder_protected(path)) {
			JANUS_LOG(LOG_ERR, "Target recording path '%s' is in protected folder...\n", path);
			janus_recorder_destroy(rc);
			g_free(copy_for_parent);
			g_free(copy_for_base);
			return NULL;
		}
		rc->file = fopen(path, "wb");
	}
	if(rc->file == NULL) {
		JANUS_LOG(LOG_ERR, "fopen error: %d\n", errno);
		janus_recorder_destroy(rc);
		g_free(copy_for_parent);
		g_free(copy_for_base);
		return NULL;
	}
	if(rec_dir)
		rc->dir = g_strdup(rec_dir);
	rc->filename = g_strdup(newname);
	rc->type = type;
	/* 写入文件头: 
	   static const char *header = "MJR00002";
	*/
	size_t res = fwrite(header, sizeof(char), strlen(header), rc->file);
	if(res != strlen(header)) {
		JANUS_LOG(LOG_ERR, "Couldn't write .mjr header (%zu != %zu, %s)\n",
			res, strlen(header), strerror(errno));
		janus_recorder_destroy(rc);
		g_free(copy_for_parent);
		g_free(copy_for_base);
		return NULL;
	}
	g_atomic_int_set(&rc->writable, 1);
	
	/* 除了写入上面的文件头外，还需要写入信息头, 
	   所以在这里将写入信息头的标志置0
	 */
	g_atomic_int_set(&rc->header, 0);
	janus_mutex_init(&rc->mutex);
	
	/* Done */
	g_atomic_int_set(&rc->destroyed, 0);
	g_free(copy_for_parent);
	g_free(copy_for_base);
	return rc;
}

三、录制数据

对每个接收到的RTP包：
首先：如果是第一个RTP包，则需要先写信息头到文件;
然后:
      写入4字节的帧头"MEET";
      写入4字节的帧时间戳;
      写入2字节的帧长度;
最后: 写入帧数据；

void janus_videoroom_incoming_rtp(janus_plugin_session *handle, janus_plugin_rtp *pkt) {
static void janus_videoroom_incoming_rtp_internal(janus_videoroom_session *session, janus_videoroom_publisher *participant, janus_plugin_rtp *pkt) {

	if(handle == NULL || g_atomic_int_get(&handle->stopped) || g_atomic_int_get(&stopping) || !g_atomic_int_get(&initialized))
		return;
	janus_videoroom_session *session = (janus_videoroom_session *)handle->plugin_handle;
	if(!session || g_atomic_int_get(&session->destroyed) || session->participant_type != janus_videoroom_p_type_publisher)
		return;
	janus_videoroom_publisher *participant = janus_videoroom_session_get_publisher_nodebug(session);
	if(participant == NULL)
		return;
	if(g_atomic_int_get(&participant->destroyed) || participant->kicked || participant->room == NULL) {
		janus_videoroom_publisher_dereference_nodebug(participant);
		return;
	}
	janus_videoroom *videoroom = participant->room;

	gboolean video = pkt->video;
	char *buf = pkt->buffer;
	uint16_t len = pkt->length;

	/* 写入帧数据到录制文件  */
	if(!video || (participant->ssrc[0] == 0 && participant->rid[0] == NULL)) {
		janus_recorder_save_frame(video ? participant->vrc : participant->arc, buf, len);
	} else {
		/* We're simulcasting, save the best video quality */
		gboolean save = janus_rtp_simulcasting_context_process_rtp(&participant->rec_simctx,
			buf, len, participant->ssrc, participant->rid, participant->vcodec, &participant->rec_ctx);
		if(save) {
			uint32_t seq_number = ntohs(rtp->seq_number);
			uint32_t timestamp = ntohl(rtp->timestamp);
			uint32_t ssrc = ntohl(rtp->ssrc);
			janus_rtp_header_update(rtp, &participant->rec_ctx, TRUE, 0);
			/* We use a fixed SSRC for the whole recording */
			rtp->ssrc = participant->ssrc[0];
			
			janus_recorder_save_frame(participant->vrc, buf, len);
			/* Restore the header, as it will be needed by subscribers */
			rtp->ssrc = htonl(ssrc);
			rtp->timestamp = htonl(timestamp);
			rtp->seq_number = htons(seq_number);
		}
	}
}



// record.c
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(!g_atomic_int_get(&recorder->writable)) {
		janus_mutex_unlock_nodebug(&recorder->mutex);
		return -4;
	}
	gint64 now = janus_get_monotonic_time();
	
	// 如果是第一个包，则需要准备好信息头的数据, 将它的长度和内容写入到文件
	if(!g_atomic_int_get(&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 */
		if(recorder->fmtp)
			json_object_set_new(info, "f", json_string(recorder->fmtp));				/* Codec-specific info */
		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 */
		/* If media will be end-to-end encrypted, mark it in the recording header */
		if(recorder->encrypted)
			json_object_set_new(info, "e", json_true());
		gchar *info_text = json_dumps(info, JSON_PRESERVE_ORDER);
		json_decref(info);
		uint16_t info_bytes = htons(strlen(info_text));
		
		// 将信息头的长度(info_bytes)写入文件
		size_t res = fwrite(&info_bytes, sizeof(uint16_t), 1, recorder->file);
		if(res != 1) {
			JANUS_LOG(LOG_WARN, "Couldn't write size of JSON header in .mjr file (%zu != %zu, %s), expect issues post-processing\n",
				res, sizeof(uint16_t), strerror(errno));
		}
		// 将信息头的内容(info_text) 写入文件
		res = fwrite(info_text, sizeof(char), strlen(info_text), recorder->file);
		if(res != strlen(info_text)) {
			JANUS_LOG(LOG_WARN, "Couldn't write JSON header in .mjr file (%zu != %zu, %s), expect issues post-processing\n",
				res, strlen(info_text), strerror(errno));
		}
		free(info_text);
		/* Done */
		recorder->started = now;
		// 将是否写入信息头的标志置 1 ; 
		g_atomic_int_set(&recorder->header, 1);
	}

	/* Write frame header (fixed part[4], timestamp[4], length[2]) 
	   写入4个字节长度的固定内容的mjr包头:
	   static const char *frame_header = "MEET";
	 */
	size_t res = fwrite(frame_header, sizeof(char), strlen(frame_header), recorder->file);
	if(res != strlen(frame_header)) {
		JANUS_LOG(LOG_WARN, "Couldn't write frame header in .mjr file (%zu != %zu, %s), expect issues post-processing\n",
			res, strlen(frame_header), strerror(errno));
	}
	// 写入4个字节长度的时间戳
	uint32_t timestamp = (uint32_t)(now > recorder->started ? ((now - recorder->started)/1000) : 0);
	timestamp = htonl(timestamp);
	res = fwrite(&timestamp, sizeof(uint32_t), 1, recorder->file);
	if(res != 1) {
		JANUS_LOG(LOG_WARN, "Couldn't write frame timestamp in .mjr file (%zu != %zu, %s), expect issues post-processing\n",
			res, sizeof(uint32_t), strerror(errno));
	}
	// 写入2个字节长度的帧长度
	uint16_t header_bytes = htons(recorder->type == JANUS_RECORDER_DATA ? (length+sizeof(gint64)) : length);
	res = fwrite(&header_bytes, sizeof(uint16_t), 1, recorder->file);
	if(res != 1) {
		JANUS_LOG(LOG_WARN, "Couldn't write size of frame in .mjr file (%zu != %zu, %s), expect issues post-processing\n",
			res, sizeof(uint16_t), strerror(errno));
	}
	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());
		res = fwrite(&now, sizeof(gint64), 1, recorder->file);
		if(res != 1) {
			JANUS_LOG(LOG_WARN, "Couldn't write data timestamp in .mjr file (%zu != %zu, %s), expect issues post-processing\n",
				res, sizeof(gint64), strerror(errno));
		}
	}
	/* 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;
}

四、录制结束

对录制文件重命名后，
关闭文件句柄;

/* Thread responsible for a specific remote publisher */
static void *janus_videoroom_remote_publisher_thread(void *user_data) {
	/* If we got here, the remote publisher has been removed from the
	 * room: let's notify all other publishers in the room */
	janus_mutex_lock(&publisher->rec_mutex);
	g_free(publisher->recording_base);
	publisher->recording_base = NULL;
	// 结束录制，看是否要对录制文件进行重命名
	janus_videoroom_recorder_close(publisher);
	janus_mutex_unlock(&publisher->rec_mutex);
}	

// janus_videoroom.c
static void janus_videoroom_recorder_close(janus_videoroom_publisher *participant) {
	if(participant->arc) {
		janus_recorder *rc = participant->arc;
		participant->arc = NULL;
		janus_recorder_close(rc);
		JANUS_LOG(LOG_INFO, "Closed audio recording %s\n", rc->filename ? rc->filename : "??");
		janus_recorder_destroy(rc);
	}
	if(participant->vrc) {
		janus_recorder *rc = participant->vrc;
		participant->vrc = NULL;
		janus_recorder_close(rc);
		JANUS_LOG(LOG_INFO, "Closed video recording %s\n", rc->filename ? rc->filename : "??");
		janus_recorder_destroy(rc);
	}
	if(participant->drc) {
		janus_recorder *rc = participant->drc;
		participant->drc = NULL;
		janus_recorder_close(rc);
		JANUS_LOG(LOG_INFO, "Closed data recording %s\n", rc->filename ? rc->filename : "??");
		janus_recorder_destroy(rc);
	}
}

//record.c
// 结束录制，看是否要对录制文件进行重命名
int janus_recorder_close(janus_recorder *recorder) {
	if(!recorder || !g_atomic_int_compare_and_exchange(&recorder->writable, 1, 0))
		return -1;
	janus_mutex_lock_nodebug(&recorder->mutex);
	if(recorder->file) {
		fseek(recorder->file, 0L, SEEK_END);
		size_t fsize = ftell(recorder->file);
		fseek(recorder->file, 0L, SEEK_SET);
		JANUS_LOG(LOG_INFO, "File is %zu bytes: %s\n", fsize, recorder->filename);
	}
	if(rec_tempname) {
		/* We need to rename the file, to remove the temporary extension */
		char newname[1024];
		memset(newname, 0, 1024);
		g_snprintf(newname, strlen(recorder->filename)-strlen(rec_tempext), "%s", recorder->filename);
		char oldpath[1024];
		memset(oldpath, 0, 1024);
		char newpath[1024];
		memset(newpath, 0, 1024);
		if(recorder->dir) {
			g_snprintf(newpath, 1024, "%s/%s", recorder->dir, newname);
			g_snprintf(oldpath, 1024, "%s/%s", recorder->dir, recorder->filename);
		} else {
			g_snprintf(newpath, 1024, "%s", newname);
			g_snprintf(oldpath, 1024, "%s", recorder->filename);
		}
		if(rename(oldpath, newpath) != 0) {
			JANUS_LOG(LOG_ERR, "Error renaming %s to %s...\n", recorder->filename, newname);
		} else {
			JANUS_LOG(LOG_INFO, "Recording renamed: %s\n", newname);
			g_free(recorder->filename);
			recorder->filename = g_strdup(newname);
		}
	}
	janus_mutex_unlock_nodebug(&recorder->mutex);
	return 0;
}

北雨南萍
关注
  • 6
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
janus-video-room-js：javascript Web浏览器客户端，实现了Janus WebRTC网关的janus-gateway-js的子集
03-04
janus-video-room-js javascript Web浏览器客户端，它实现了Janus WebRTC网关的janus-gateway-js的子集。 安装 npm i janus-video-room-js --save 使用例 演示项目 let sampelRoom = new janusvideo . Janus . JanusRoom ( "wss://janus.conf.meetecho.com/ws" , { keepalive : 'true' } ) ; /** * on joined room success */ sampelRoom . eventRoomjoined . on ( ( info : any ) => { console . debug ( "Roomjoined" ) ; console . debug ( info )
前端janus的使用
菜鸟的灵魂
12-16 226
其实janus源码内部调用webrtc进一步封装好了接口createOffer，读者不用关心复杂的媒体协商peerconnection这些复杂的概念（当时本人在这里花费很长时间去理解，读者如果感兴趣，可建议先去了解webrtc的常用api，janus源码有使用到流的获取，以及对peerconnection的处理），你只要知道你的浏览器获取本地音视频等流信息通过createOffer这个接口就可以实现。通过传不同个参数，每new一个janus就是一个新的会议室，这里我们只考虑一个会议室的情况。
janus 安装部署
纵横四海的博客
11-13 525
本文使用docker进行安装，还没有安装docker和docker-compose的，请自行安装，这里就不介绍了。
janus搭建的web音视频sdk
菜鸟的灵魂
12-09 113
当时公司内部的前端开发人员无人了解这一块的知识，本人喜欢挑战性的业务，主动承担起这块业务的能力建设，并最终完成web音视频sdk从0～1的开发，给公司弥补了这块能力的欠缺。前端调用Janus库，流媒体服务端也需要启一个Janus服务，前端和服务端使用协议进行连接（比如本人使用的websocket），建立好连接之后，前后端采用信令（可以理解为接口）的方式进行数据传输。如果你们的业务变化不大，除了追求性能外，还需要录制、推流之类的功能，那么你可以选择使用Medooze，它可以很好的满足你们的需求。
开源webrtc服务器对比
隔壁老王呀的专栏
03-30 5518
开源系统是目前市面上比较常见的，分别从服务器类型、编解码能力、文档的完整性和开发商来进行对比。大家都知道WebRTC的服务器模型有两种，分别是SFU和MCU，SFU实现的是简单转发的路由功能，而MCU可以提供更多扩展性的功能实现，而且MCU型的服务器往往包含SFU，所以MCU的实现难度较大。其次，文档的完整性也是非常重要的，因为对于开发者来说，文档具有非常重要的指导作用。最后是开发商，这个主要涉...
改造的janus视频网关
lxqiong的专栏
06-01 3205
janus视频网关 从选型决定使用janus作为框架，开发视频会议系统已经有一长段时间了，也很想总结一下janus整个框架和videoroom插件。 janus是依webrtc设计的服务端视频网关，所以在协议层支持sdp协议（会话协议描述），pc（点对点传输）等功能。 sdp：重要的信息是媒体的编解码信息和传输使用的端口。 pc：peerconnection，依据sdp描述的端口信息，进行打孔，流...
JanusWebrtc VideoRoom插件 Android使用总结
qq_27025225的博客
10-15 607
janus VideoRoom插件官方文档 实例Demo GitHub地址 JanusWebrtc详见：Janus（一）开源服务器介绍 - 简书janus-gateway Janus 是由Meetecho设计和开发的开源、通用的基于SFU架构的WebRTC流媒体服务器，它支持在Linux的服务器或MacOS上的机器进...https://www.jianshu.com/p/78f2689158dd在安卓上使用时，音视频编码录音传输全由Webrtc自行处理，调用时 1、确保权限获取正常，麦克.
Janus VideoRoom信令分析--public、subscribe
chenquangobeijing的专栏
09-05 399
public、subscribe主要信令记录：
Janus WebRTC服务器部署
热门推荐
风平浪静的专栏
09-24 2万+
第一步：安装janus依赖库和工具，并设置环境变量 apt install git aptitude aptitude install libmicrohttpd-dev libjansson-dev libssl-dev libcurl4-openssl-dev aptitude install libsofia-sip-ua-dev libglib2.0-dev libopus-dev ...
Janus videoroom 视频录制
zhangshaoxu的专栏
08-05 944
本文主要描述Janus的videoroom模块录制视频功能，并将webrtc的数据包转换成可以播放的视频文件
cordova-webrtc-janus-gateway:如何在janus-gateway中使用PhoneRTC的示例
05-14
这是如何在janus-gateway中使用PhoneRTC的示例。 此示例再现了janus-gateway echotest演示，因此它成功地将音频和视频发送到webrtc janus-gateway服务器，并将其接收回来，它使用了转弯服务器（即使不需要它，只是...
janus-gateway-js:用于Node.js和浏览器的Janus-gateway WebRTC客户端
04-27
janus-gateway-js 关于 现代javascript客户端。 基于websockets。 原始客户端可以在以下位置找到 。 使用例 此示例假定Janus服务器在本地主机上运行，​​并且在其默认端口8188上启用了WebSocket支持 var janus = ...
janus-gateway-android
05-02
janus-gateway-android 这是一个API封装程序，它利用本机WebRTC构建并简化了与通信。 这是一个进步的过程。 它被设计为类似于的。 由于这还处于初期阶段，因此非常欢迎任何坚持和投入。 当前工作的示例： 回声...
janus-webrtc-gateway-docker：适用于媒体流专家用户的完美Docker镜像（https：github.commeetechojanus-gateway）
02-02
janus-webrtc-gateway-docker：适用于媒体流专家用户的完美Docker镜像（https：github.commeetechojanus-gateway）
WebRTC音视频通话-WebRTC视频自定义RTCVideoCapturer相机
一名开发者
08-15 6509
WebRTC音视频通话-WebRTC视频自定义RTCVideoCapturer相机。主要获得相机采集的画面CVPixelBufferRef，将处理后的CVPixelBufferRef生成RTCVideoFrame，通过调用WebRTC的localVideoSource中实现的didCaptureVideoFrame方法
电力系统调度过程连续潮流matlab代码.zip
04-26
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。
【基于Java+Springboot的毕业设计】付费问答系统(源码+演示视频+说明).rar
04-26
【基于Java+Springboot的毕业设计】付费问答系统(源码+演示视频+说明).rar 【项目技术】 开发语言：Java 框架：Spingboot+vue 架构：B/S 数据库：mysql 【演示视频-编号：330】 https://pan.quark.cn/s/8dea014f4d36 【实现功能】 付费问答系统通过MySQL数据库与Spring Boot框架进行开发，付费问答系统能够实现新闻类型管理，问题帖子管理，付费记录管理，新闻信息管理，用户管理，轮播图管理等功能。
关于旁路电容和耦合电容-(详细说明)
最新发布
04-26
关于旁路电容和耦合电容-(详细说明)
janus gateway
05-30
Janus Gateway是一个开源的...Janus Gateway提供了一组API和插件，使开发人员可以轻松地将其集成到各种不同的应用程序中。同时，Janus Gateway还支持多种不同的编解码器和协议，包括VP8、VP9、H.264、Opus和WebRTC等。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

北雨南萍

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值