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

    引:

    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
    房间中和录制相关的参数

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

    二、录制初始化

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

    1. // janus_videoroom.c
    2. static json_t *janus_videoroom_process_synchronous_request(janus_videoroom_session *session, json_t *message) {
    3. 	
    4. 	if(!strcasecmp(request_text, "create")) {
    5. 		/* Create a new VideoRoom */
    6. 		/* Added by Hank, For recording: */
    7. 		// if(rec_dir) {
    8. 			// videoroom->rec_dir = g_strdup(json_string_value(rec_dir));
    9. 		if (g_record_root_path != NULL) {
    10.             videoroom->rec_dir = g_strdup(g_record_root_path);
    11. 			
    12.             // 修改文件存储路径,在原有的录制根目录下,添加 /年月日/房间号/
    13. 			char new_rec_dir_arr[255] = {0};
    14. 				
    15. 			time_t timestamp = time(NULL); 
    16. 			struct tm *local_time = localtime(×tamp);
    17. 			char formatted_date[11]={0};
    18. 			strftime(formatted_date,sizeof(formatted_date), "%Y%m%d",local_time);
    19. 			
    20. 			g_snprintf(new_rec_dir_arr, 255, "%s/%s/%s/",
    21. 					videoroom->rec_dir, formatted_date, videoroom->room_id_str);
    22. 			char *old_rec_dir = videoroom->rec_dir;
    23. 			char *new_rec_dir = g_strdup(new_rec_dir_arr);
    24. 			videoroom->rec_dir = new_rec_dir;
    25. 			g_free(old_rec_dir);		
    26. 			/* END-OF-Hank */
    27. 			
    28. 		}		
    29. 	}
    30. }
    1. /* Thread to handle incoming messages 
    2.  * 当有房间“configure"消息时，
    3.  * 进行本房间的发布者对应的视频、音频、数据录制文件创建
    4.  */
    5. static void *janus_videoroom_handler(void *data) {
    6. 	while(g_atomic_int_get(&initialized) && !g_atomic_int_get(&stopping)) {
    7. 		msg = g_async_queue_pop(messages);
    8. 		janus_videoroom *videoroom = NULL;
    9. 		janus_videoroom_publisher *participant = NULL;
    10. 		janus_videoroom_subscriber *subscriber = NULL;
    11. 		
    12. 		janus_mutex_lock(&sessions_mutex);
    13. 		janus_videoroom_session *session = janus_videoroom_lookup_session(msg->handle);
    14. 		janus_mutex_unlock(&sessions_mutex);
    15. 		
    16. 		if(session->participant_type == janus_videoroom_p_type_none) {
    17. 			...
    18. 		} else if(session->participant_type == janus_videoroom_p_type_publisher) {
    19. 			/* 当 request_text = "configure" 时 */
    20. 			json_t *request = json_object_get(root, "request");
    21. 			const char *request_text = json_string_value(request);
    22. 			if(!strcasecmp(request_text, "join") 
    23. 		       || !strcasecmp(request_text, "joinandconfigure")) {
    24. 			   ...
    25. 			} else if(!strcasecmp(request_text, "configure") 
    26. 			          || !strcasecmp(request_text, "publish")) {
    27. 				   
    28. 					/* 录制相关配置，并创建本publisher的Video/Audio/Data录制文件  */
    29. 					gboolean record_locked = FALSE;
    30. 					if((record || recfile) && participant->room->lock_record && participant->room->room_secret) {
    31. 						JANUS_CHECK_SECRET(participant->room->room_secret, root, "secret", error_code, error_cause,
    32. 							JANUS_VIDEOROOM_ERROR_MISSING_ELEMENT, JANUS_VIDEOROOM_ERROR_INVALID_ELEMENT, JANUS_VIDEOROOM_ERROR_UNAUTHORIZED);
    33. 						if(error_code != 0) {
    34. 							/* Wrong secret provided, we'll prevent the recording state from being changed */
    35. 							record_locked = TRUE;
    36. 						}
    37. 					}
    38. 					janus_mutex_lock(&participant->rec_mutex);
    39. 					gboolean prev_recording_active = participant->recording_active;
    40. 					if(record && !record_locked) {
    41. 						participant->recording_active = json_is_true(record);
    42. 						JANUS_LOG(LOG_VERB, "Setting record property: %s (room %s, user %s)\n",
    43. 							participant->recording_active ? "true" : "false", participant->room_id_str, participant->user_id_str);
    44. 					}
    45. 					if(recfile && !record_locked) {
    46. 						participant->recording_base = g_strdup(json_string_value(recfile));
    47. 						JANUS_LOG(LOG_VERB, "Setting recording basename: %s (room %s, user %s)\n",
    48. 							participant->recording_base, participant->room_id_str, participant->user_id_str);
    49. 					}
    50. 					/* Do we need to do something with the recordings right now? */
    51. 					if(participant->recording_active != prev_recording_active) {
    52. 						/* Something changed */
    53. 						if(!participant->recording_active) {
    54. 							/* Not recording (anymore?) */
    55. 							janus_videoroom_recorder_close(participant);
    56. 						} else if(participant->recording_active && g_atomic_int_get(&participant->session->started)) {
    57. 							/* We've started recording, send a PLI/FIR and go on */
    58. 							GList *temp = participant->streams;
    59. 							while(temp) {
    60. 								janus_videoroom_publisher_stream *ps = (janus_videoroom_publisher_stream *)temp->data;
    61. 											
    62. 								janus_videoroom_recorder_create(participant, 
    63. 									participant->audio, participant->video, 
    64. 									participant->data); 
    65. 						}
    66. 						janus_mutex_unlock(&participant->rec_mutex);
    67. 						。。。
    68. 					}
    69. 				}
    70. 				janus_videoroom_message_free(msg);
    71. 				continue;
    72. 			}
    73. 		}
    74. 	} // end of while(g_atomic_int_get(&initialized) ...)
    75. 	return NULL;
    76. }
    1. /**********  创建本发布者对应的音频、视频、数据录制文件 *******************/
    2. static void janus_videoroom_recorder_create(janus_videoroom_publisher *participant, 
    3. 				 gboolean audio, gboolean video, 
    4. 				 gboolean data) {
    5. 	char filename[255];
    6. 	janus_recorder *rc = NULL;
    7. 	gint64 now = janus_get_real_time();
    8.  
    9. 	// 设置音频文件的存储路径和文件名
    10. 	if(audio && participant->arc == NULL) {
    11. 		memset(filename, 0, 255);
    12. 		if(participant->recording_base) {
    13. 			/* Use the filename and path we have been provided */
    14. 			g_snprintf(filename, 255, "%s-audio", participant->recording_base);
    15. 			rc = janus_recorder_create(participant->room->rec_dir,
    16. 									   janus_audiocodec_name(participant->acodec), filename);
    17. 			if(rc == NULL) {
    18. 				JANUS_LOG(LOG_ERR, "Couldn't open an audio recording file for this publisher!\n");
    19. 			}
    20. 		} else {
    21. 			/* Build a filename */
    22. 			g_snprintf(filename, 255, "videoroom-%s-user-%s-%"SCNi64"-audio",
    23. 				participant->room_id_str, participant->user_id_str, now);
    24. 			rc = janus_recorder_create(participant->room->rec_dir,
    25. 										janus_audiocodec_name(participant->acodec), filename);
    26. 			if(rc == NULL) {
    27. 				JANUS_LOG(LOG_ERR, "Couldn't open an audio recording file for this publisher!\n");
    28. 			}
    29. 		}
    30. 		/* If media is encrypted, mark it in the recording */
    31. 		if(participant->e2ee)
    32. 			janus_recorder_encrypted(rc);
    33. 		participant->arc = rc;
    34. 	}
    35.  
    36. 	// 设置视频文件的存储路径和文件名
    37. 	if(video && participant->vrc == NULL) {
    38. 		janus_rtp_switching_context_reset(&participant->rec_ctx);
    39. 		janus_rtp_simulcasting_context_reset(&participant->rec_simctx);
    40. 		participant->rec_simctx.substream_target = 2;
    41. 		participant->rec_simctx.templayer_target = 2;
    42. 		memset(filename, 0, 255);
    43. 		if(participant->recording_base) {
    44. 			/* Use the filename and path we have been provided */
    45. 			g_snprintf(filename, 255, "%s-video", participant->recording_base);
    46. 			rc = janus_recorder_create_full(participant->room->rec_dir,
    47. 											janus_videocodec_name(participant->vcodec), participant->vfmtp, filename);
    48. 			if(rc == NULL) {
    49. 				JANUS_LOG(LOG_ERR, "Couldn't open an video recording file for this publisher!\n");
    50. 			}
    51. 		} else {
    52. 			/* Build a filename */
    53. 			g_snprintf(filename, 255, "videoroom-%s-user-%s-%"SCNi64"-video",
    54. 				participant->room_id_str, participant->user_id_str, now);
    55. 			rc = janus_recorder_create_full(participant->room->rec_dir,
    56. 				janus_videocodec_name(participant->vcodec), participant->vfmtp, filename);
    57. 			if(rc == NULL) {
    58. 				JANUS_LOG(LOG_ERR, "Couldn't open an video recording file for this publisher!\n");
    59. 			}
    60. 		}
    61. 		/* If media is encrypted, mark it in the recording */
    62. 		if(participant->e2ee)
    63. 			janus_recorder_encrypted(rc);
    64. 		participant->vrc = rc;
    65. 	}
    66.  
    67. 	// 设置数据文件的存储路径和文件名
    68. 	if(data && participant->drc == NULL) {
    69. 		memset(filename, 0, 255);
    70. 		if(participant->recording_base) {
    71. 			/* Use the filename and path we have been provided */
    72. 			g_snprintf(filename, 255, "%s-data", participant->recording_base);
    73. 			rc = janus_recorder_create(participant->room->rec_dir,
    74. 				"text", filename);
    75. 			if(rc == NULL) {
    76. 				JANUS_LOG(LOG_ERR, "Couldn't open an data recording file for this publisher!\n");
    77. 			}
    78. 		} else {
    79. 			/* Build a filename */
    80. 			g_snprintf(filename, 255, "videoroom-%s-user-%s-%"SCNi64"-data",
    81. 				participant->room_id_str, participant->user_id_str, now);
    82. 			rc = janus_recorder_create(participant->room->rec_dir,
    83. 				"text", filename);
    84. 			if(rc == NULL) {
    85. 				JANUS_LOG(LOG_ERR, "Couldn't open an data recording file for this publisher!\n");
    86. 			}
    87. 		}
    88. 		/* Media encryption doesn't apply to data channels */
    89. 		participant->drc = rc;
    90. 	}
    91. }
    1. // record.c
    2. /* Info header in the structured recording */
    3. static const char *header = "MJR00002";
    4. /* Frame header in the structured recording */
    5. static const char *frame_header = "MEET";
    6.  
    7. janus_recorder *janus_recorder_create(const char *dir, const char *codec, const char *filename) {
    8. 	/* Same as janus_recorder_create_full, but with no fmtp */
    9. 	return janus_recorder_create_full(dir, codec, NULL, filename);
    10. }
    11.  
    12.  
    13. /* 
    14. 打开文件;
    15. 写入文件头；MJR00002
    16. */
    17. janus_recorder *janus_recorder_create_full(const char *dir, const char *codec, const char *fmtp, const char *filename) {
    18. 	janus_recorder_medium type = JANUS_RECORDER_AUDIO;
    19. 	if(codec == NULL) {
    20. 		JANUS_LOG(LOG_ERR, "Missing codec information\n");
    21. 		return NULL;
    22. 	}
    23. 	if(!strcasecmp(codec, "vp8") || !strcasecmp(codec, "vp9") || !strcasecmp(codec, "h264")
    24. 			 || !strcasecmp(codec, "av1") || !strcasecmp(codec, "h265")) {
    25. 		type = JANUS_RECORDER_VIDEO;
    26. 	} else if(!strcasecmp(codec, "opus") || !strcasecmp(codec, "multiopus")
    27. 			|| !strcasecmp(codec, "g711") || !strcasecmp(codec, "pcmu") || !strcasecmp(codec, "pcma")
    28. 			|| !strcasecmp(codec, "g722")) {
    29. 		type = JANUS_RECORDER_AUDIO;
    30. 	} else if(!strcasecmp(codec, "text")) {
    31. 		/* FIXME We only handle text on data channels, so that's the only thing we can save too */
    32. 		type = JANUS_RECORDER_DATA;
    33. 	} else {
    34. 		/* We don't recognize the codec: while we might go on anyway, we'd rather fail instead */
    35. 		JANUS_LOG(LOG_ERR, "Unsupported codec '%s'\n", codec);
    36. 		return NULL;
    37. 	}
    38. 	/* Create the recorder */
    39. 	janus_recorder *rc = g_malloc0(sizeof(janus_recorder));
    40. 	janus_refcount_init(&rc->ref, janus_recorder_free);
    41. 	rc->dir = NULL;
    42. 	rc->filename = NULL;
    43. 	rc->file = NULL;
    44. 	rc->codec = g_strdup(codec);
    45. 	rc->fmtp = fmtp ? g_strdup(fmtp) : NULL;
    46. 	rc->created = janus_get_real_time();
    47. 	const char *rec_dir = NULL;
    48. 	const char *rec_file = NULL;
    49. 	char *copy_for_parent = NULL;
    50. 	char *copy_for_base = NULL;
    51. 	/* 检查路径和文件名是否合规 */
    52. 	if(filename != NULL) {
    53. 		/* Helper copies to avoid overwriting */
    54. 		copy_for_parent = g_strdup(filename);
    55. 		copy_for_base = g_strdup(filename);
    56. 		/* Get filename parent folder */
    57. 		const char *filename_parent = dirname(copy_for_parent);
    58. 		/* Get filename base file */
    59. 		const char *filename_base = basename(copy_for_base);
    60. 		if(!dir) {
    61. 			/* If dir is NULL we have to create filename_parent and filename_base */
    62. 			rec_dir = filename_parent;
    63. 			rec_file = filename_base;
    64. 		} else {
    65. 			/* If dir is valid we have to create dir and filename*/
    66. 			rec_dir = dir;
    67. 			rec_file = filename;
    68. 			if(strcasecmp(filename_parent, ".") || strcasecmp(filename_base, filename)) {
    69. 				JANUS_LOG(LOG_WARN, "Unsupported combination of dir and filename %s %s\n", dir, filename);
    70. 			}
    71. 		}
    72. 	}
    73. 	// 检查路径是否存在，如果不存在,则创建路径
    74. 	if(rec_dir != NULL) {
    75. 		/* Check if this directory exists, and create it if needed */
    76. 		struct stat s;
    77. 		int err = stat(rec_dir, &s);
    78. 		if(err == -1) {
    79. 			if(ENOENT == errno) {
    80. 				/* Directory does not exist, try creating it */
    81. 				if(janus_mkdir(rec_dir, 0755) < 0) {
    82. 					JANUS_LOG(LOG_ERR, "mkdir (%s) error: %d (%s)\n", rec_dir, errno, strerror(errno));
    83. 					janus_recorder_destroy(rc);
    84. 					g_free(copy_for_parent);
    85. 					g_free(copy_for_base);
    86. 					return NULL;
    87. 				}
    88. 			} else {
    89. 				JANUS_LOG(LOG_ERR, "stat (%s) error: %d (%s)\n", rec_dir, errno, strerror(errno));
    90. 				janus_recorder_destroy(rc);
    91. 				g_free(copy_for_parent);
    92. 				g_free(copy_for_base);
    93. 				return NULL;
    94. 			}
    95. 		} else {
    96. 			if(S_ISDIR(s.st_mode)) {
    97. 				/* Directory exists */
    98. 				JANUS_LOG(LOG_VERB, "Directory exists: %s\n", rec_dir);
    99. 			} else {
    100. 				/* File exists but it's not a directory? */
    101. 				JANUS_LOG(LOG_ERR, "Not a directory? %s\n", rec_dir);
    102. 				janus_recorder_destroy(rc);
    103. 				g_free(copy_for_parent);
    104. 				g_free(copy_for_base);
    105. 				return NULL;
    106. 			}
    107. 		}
    108. 	}
    109. 	char newname[1024];
    110. 	memset(newname, 0, 1024);
    111. 	// 给文件名加上.mjr的后缀
    112. 	if(rec_file == NULL) {
    113. 		/* Choose a random username */
    114. 		if(!rec_tempname) {
    115. 			/* Use .mjr as an extension right away */
    116. 			g_snprintf(newname, 1024, "janus-recording-%"SCNu32".mjr", janus_random_uint32());
    117. 		} else {
    118. 			/* Append the temporary extension to .mjr, we'll rename when closing */
    119. 			g_snprintf(newname, 1024, "janus-recording-%"SCNu32".mjr.%s", janus_random_uint32(), rec_tempext);
    120. 		}
    121. 	} else {
    122. 		/* Just append the extension */
    123. 		if(!rec_tempname) {
    124. 			/* Use .mjr as an extension right away */
    125. 			g_snprintf(newname, 1024, "%s.mjr", rec_file);
    126. 		} else {
    127. 			/* Append the temporary extension to .mjr, we'll rename when closing */
    128. 			g_snprintf(newname, 1024, "%s.mjr.%s", rec_file, rec_tempext);
    129. 		}
    130. 	}
    131. 	/* 打开文件，准备写入 */
    132. 	if(rec_dir == NULL) {
    133. 		/* Make sure folder to save to is not protected */
    134. 		if(janus_is_folder_protected(newname)) {
    135. 			JANUS_LOG(LOG_ERR, "Target recording path '%s' is in protected folder...\n", newname);
    136. 			janus_recorder_destroy(rc);
    137. 			g_free(copy_for_parent);
    138. 			g_free(copy_for_base);
    139. 			return NULL;
    140. 		}
    141. 		rc->file = fopen(newname, "wb");
    142. 	} else {
    143. 		char path[1024];
    144. 		memset(path, 0, 1024);
    145. 		g_snprintf(path, 1024, "%s/%s", rec_dir, newname);
    146. 		/* Make sure folder to save to is not protected */
    147. 		if(janus_is_folder_protected(path)) {
    148. 			JANUS_LOG(LOG_ERR, "Target recording path '%s' is in protected folder...\n", path);
    149. 			janus_recorder_destroy(rc);
    150. 			g_free(copy_for_parent);
    151. 			g_free(copy_for_base);
    152. 			return NULL;
    153. 		}
    154. 		rc->file = fopen(path, "wb");
    155. 	}
    156. 	if(rc->file == NULL) {
    157. 		JANUS_LOG(LOG_ERR, "fopen error: %d\n", errno);
    158. 		janus_recorder_destroy(rc);
    159. 		g_free(copy_for_parent);
    160. 		g_free(copy_for_base);
    161. 		return NULL;
    162. 	}
    163. 	if(rec_dir)
    164. 		rc->dir = g_strdup(rec_dir);
    165. 	rc->filename = g_strdup(newname);
    166. 	rc->type = type;
    167. 	/* 写入文件头: 
    168. 	   static const char *header = "MJR00002";
    169. 	*/
    170. 	size_t res = fwrite(header, sizeof(char), strlen(header), rc->file);
    171. 	if(res != strlen(header)) {
    172. 		JANUS_LOG(LOG_ERR, "Couldn't write .mjr header (%zu != %zu, %s)\n",
    173. 			res, strlen(header), strerror(errno));
    174. 		janus_recorder_destroy(rc);
    175. 		g_free(copy_for_parent);
    176. 		g_free(copy_for_base);
    177. 		return NULL;
    178. 	}
    179. 	g_atomic_int_set(&rc->writable, 1);
    180. 	
    181. 	/* 除了写入上面的文件头外，还需要写入信息头, 
    182. 	   所以在这里将写入信息头的标志置0
    183. 	 */
    184. 	g_atomic_int_set(&rc->header, 0);
    185. 	janus_mutex_init(&rc->mutex);
    186. 	
    187. 	/* Done */
    188. 	g_atomic_int_set(&rc->destroyed, 0);
    189. 	g_free(copy_for_parent);
    190. 	g_free(copy_for_base);
    191. 	return rc;
    192. }

    三、录制数据

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

    1. void janus_videoroom_incoming_rtp(janus_plugin_session *handle, janus_plugin_rtp *pkt) {
    2. static void janus_videoroom_incoming_rtp_internal(janus_videoroom_session *session, janus_videoroom_publisher *participant, janus_plugin_rtp *pkt) {
    3.  
    4. 	if(handle == NULL || g_atomic_int_get(&handle->stopped) || g_atomic_int_get(&stopping) || !g_atomic_int_get(&initialized))
    5. 		return;
    6. 	janus_videoroom_session *session = (janus_videoroom_session *)handle->plugin_handle;
    7. 	if(!session || g_atomic_int_get(&session->destroyed) || session->participant_type != janus_videoroom_p_type_publisher)
    8. 		return;
    9. 	janus_videoroom_publisher *participant = janus_videoroom_session_get_publisher_nodebug(session);
    10. 	if(participant == NULL)
    11. 		return;
    12. 	if(g_atomic_int_get(&participant->destroyed) || participant->kicked || participant->room == NULL) {
    13. 		janus_videoroom_publisher_dereference_nodebug(participant);
    14. 		return;
    15. 	}
    16. 	janus_videoroom *videoroom = participant->room;
    17.  
    18. 	gboolean video = pkt->video;
    19. 	char *buf = pkt->buffer;
    20. 	uint16_t len = pkt->length;
    21.  
    22. 	/* 写入帧数据到录制文件  */
    23. 	if(!video || (participant->ssrc[0] == 0 && participant->rid[0] == NULL)) {
    24. 		janus_recorder_save_frame(video ? participant->vrc : participant->arc, buf, len);
    25. 	} else {
    26. 		/* We're simulcasting, save the best video quality */
    27. 		gboolean save = janus_rtp_simulcasting_context_process_rtp(&participant->rec_simctx,
    28. 			buf, len, participant->ssrc, participant->rid, participant->vcodec, &participant->rec_ctx);
    29. 		if(save) {
    30. 			uint32_t seq_number = ntohs(rtp->seq_number);
    31. 			uint32_t timestamp = ntohl(rtp->timestamp);
    32. 			uint32_t ssrc = ntohl(rtp->ssrc);
    33. 			janus_rtp_header_update(rtp, &participant->rec_ctx, TRUE, 0);
    34. 			/* We use a fixed SSRC for the whole recording */
    35. 			rtp->ssrc = participant->ssrc[0];
    36. 			
    37. 			janus_recorder_save_frame(participant->vrc, buf, len);
    38. 			/* Restore the header, as it will be needed by subscribers */
    39. 			rtp->ssrc = htonl(ssrc);
    40. 			rtp->timestamp = htonl(timestamp);
    41. 			rtp->seq_number = htons(seq_number);
    42. 		}
    43. 	}
    44. }
    45.  
    46.  
    47.  
    48. // record.c
    49. int janus_recorder_save_frame(janus_recorder *recorder, char *buffer, uint length) {
    50. 	if(!recorder)
    51. 		return -1;
    52. 	janus_mutex_lock_nodebug(&recorder->mutex);
    53. 	if(!buffer || length < 1) {
    54. 		janus_mutex_unlock_nodebug(&recorder->mutex);
    55. 		return -2;
    56. 	}
    57. 	if(!recorder->file) {
    58. 		janus_mutex_unlock_nodebug(&recorder->mutex);
    59. 		return -3;
    60. 	}
    61. 	if(!g_atomic_int_get(&recorder->writable)) {
    62. 		janus_mutex_unlock_nodebug(&recorder->mutex);
    63. 		return -4;
    64. 	}
    65. 	gint64 now = janus_get_monotonic_time();
    66. 	
    67. 	// 如果是第一个包，则需要准备好信息头的数据, 将它的长度和内容写入到文件
    68. 	if(!g_atomic_int_get(&recorder->header)) {
    69. 		/* Write info header as a JSON formatted info */
    70. 		json_t *info = json_object();
    71. 		/* FIXME Codecs should be configurable in the future */
    72. 		const char *type = NULL;
    73. 		if(recorder->type == JANUS_RECORDER_AUDIO)
    74. 			type = "a";
    75. 		else if(recorder->type == JANUS_RECORDER_VIDEO)
    76. 			type = "v";
    77. 		else if(recorder->type == JANUS_RECORDER_DATA)
    78. 			type = "d";
    79. 		json_object_set_new(info, "t", json_string(type));								/* Audio/Video/Data */
    80. 		json_object_set_new(info, "c", json_string(recorder->codec));					/* Media codec */
    81. 		if(recorder->fmtp)
    82. 			json_object_set_new(info, "f", json_string(recorder->fmtp));				/* Codec-specific info */
    83. 		json_object_set_new(info, "s", json_integer(recorder->created));				/* Created time */
    84. 		json_object_set_new(info, "u", json_integer(janus_get_real_time()));			/* First frame written time */
    85. 		/* If media will be end-to-end encrypted, mark it in the recording header */
    86. 		if(recorder->encrypted)
    87. 			json_object_set_new(info, "e", json_true());
    88. 		gchar *info_text = json_dumps(info, JSON_PRESERVE_ORDER);
    89. 		json_decref(info);
    90. 		uint16_t info_bytes = htons(strlen(info_text));
    91. 		
    92. 		// 将信息头的长度(info_bytes)写入文件
    93. 		size_t res = fwrite(&info_bytes, sizeof(uint16_t), 1, recorder->file);
    94. 		if(res != 1) {
    95. 			JANUS_LOG(LOG_WARN, "Couldn't write size of JSON header in .mjr file (%zu != %zu, %s), expect issues post-processing\n",
    96. 				res, sizeof(uint16_t), strerror(errno));
    97. 		}
    98. 		// 将信息头的内容(info_text) 写入文件
    99. 		res = fwrite(info_text, sizeof(char), strlen(info_text), recorder->file);
    100. 		if(res != strlen(info_text)) {
    101. 			JANUS_LOG(LOG_WARN, "Couldn't write JSON header in .mjr file (%zu != %zu, %s), expect issues post-processing\n",
    102. 				res, strlen(info_text), strerror(errno));
    103. 		}
    104. 		free(info_text);
    105. 		/* Done */
    106. 		recorder->started = now;
    107. 		// 将是否写入信息头的标志置 1 ; 
    108. 		g_atomic_int_set(&recorder->header, 1);
    109. 	}
    110.  
    111. 	/* Write frame header (fixed part[4], timestamp[4], length[2]) 
    112. 	   写入4个字节长度的固定内容的mjr包头:
    113. 	   static const char *frame_header = "MEET";
    114. 	 */
    115. 	size_t res = fwrite(frame_header, sizeof(char), strlen(frame_header), recorder->file);
    116. 	if(res != strlen(frame_header)) {
    117. 		JANUS_LOG(LOG_WARN, "Couldn't write frame header in .mjr file (%zu != %zu, %s), expect issues post-processing\n",
    118. 			res, strlen(frame_header), strerror(errno));
    119. 	}
    120. 	// 写入4个字节长度的时间戳
    121. 	uint32_t timestamp = (uint32_t)(now > recorder->started ? ((now - recorder->started)/1000) : 0);
    122. 	timestamp = htonl(timestamp);
    123. 	res = fwrite(×tamp, sizeof(uint32_t), 1, recorder->file);
    124. 	if(res != 1) {
    125. 		JANUS_LOG(LOG_WARN, "Couldn't write frame timestamp in .mjr file (%zu != %zu, %s), expect issues post-processing\n",
    126. 			res, sizeof(uint32_t), strerror(errno));
    127. 	}
    128. 	// 写入2个字节长度的帧长度
    129. 	uint16_t header_bytes = htons(recorder->type == JANUS_RECORDER_DATA ? (length+sizeof(gint64)) : length);
    130. 	res = fwrite(&header_bytes, sizeof(uint16_t), 1, recorder->file);
    131. 	if(res != 1) {
    132. 		JANUS_LOG(LOG_WARN, "Couldn't write size of frame in .mjr file (%zu != %zu, %s), expect issues post-processing\n",
    133. 			res, sizeof(uint16_t), strerror(errno));
    134. 	}
    135. 	if(recorder->type == JANUS_RECORDER_DATA) {
    136. 		/* If it's data, then we need to prepend timing related info, as it's not there by itself */
    137. 		gint64 now = htonll(janus_get_real_time());
    138. 		res = fwrite(&now, sizeof(gint64), 1, recorder->file);
    139. 		if(res != 1) {
    140. 			JANUS_LOG(LOG_WARN, "Couldn't write data timestamp in .mjr file (%zu != %zu, %s), expect issues post-processing\n",
    141. 				res, sizeof(gint64), strerror(errno));
    142. 		}
    143. 	}
    144. 	/* Save packet on file 
    145. 	   写入帧数据到文件
    146. 	 */
    147. 	int temp = 0, tot = length;
    148. 	while(tot > 0) {
    149. 		temp = fwrite(buffer+length-tot, sizeof(char), tot, recorder->file);
    150. 		if(temp <= 0) {
    151. 			JANUS_LOG(LOG_ERR, "Error saving frame...\n");
    152. 			janus_mutex_unlock_nodebug(&recorder->mutex);
    153. 			return -5;
    154. 		}
    155. 		tot -= temp;
    156. 	}
    157. 	/* Done */
    158. 	janus_mutex_unlock_nodebug(&recorder->mutex);
    159. 	return 0;
    160. }
    161.

    四、录制结束

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

    1. /* Thread responsible for a specific remote publisher */
    2. static void *janus_videoroom_remote_publisher_thread(void *user_data) {
    3. 	/* If we got here, the remote publisher has been removed from the
    4. 	 * room: let's notify all other publishers in the room */
    5. 	janus_mutex_lock(&publisher->rec_mutex);
    6. 	g_free(publisher->recording_base);
    7. 	publisher->recording_base = NULL;
    8. 	// 结束录制，看是否要对录制文件进行重命名
    9. 	janus_videoroom_recorder_close(publisher);
    10. 	janus_mutex_unlock(&publisher->rec_mutex);
    11. }	
    12.  
    13. // janus_videoroom.c
    14. static void janus_videoroom_recorder_close(janus_videoroom_publisher *participant) {
    15. 	if(participant->arc) {
    16. 		janus_recorder *rc = participant->arc;
    17. 		participant->arc = NULL;
    18. 		janus_recorder_close(rc);
    19. 		JANUS_LOG(LOG_INFO, "Closed audio recording %s\n", rc->filename ? rc->filename : "??");
    20. 		janus_recorder_destroy(rc);
    21. 	}
    22. 	if(participant->vrc) {
    23. 		janus_recorder *rc = participant->vrc;
    24. 		participant->vrc = NULL;
    25. 		janus_recorder_close(rc);
    26. 		JANUS_LOG(LOG_INFO, "Closed video recording %s\n", rc->filename ? rc->filename : "??");
    27. 		janus_recorder_destroy(rc);
    28. 	}
    29. 	if(participant->drc) {
    30. 		janus_recorder *rc = participant->drc;
    31. 		participant->drc = NULL;
    32. 		janus_recorder_close(rc);
    33. 		JANUS_LOG(LOG_INFO, "Closed data recording %s\n", rc->filename ? rc->filename : "??");
    34. 		janus_recorder_destroy(rc);
    35. 	}
    36. }
    37.  
    38. //record.c
    39. // 结束录制，看是否要对录制文件进行重命名
    40. int janus_recorder_close(janus_recorder *recorder) {
    41. 	if(!recorder || !g_atomic_int_compare_and_exchange(&recorder->writable, 1, 0))
    42. 		return -1;
    43. 	janus_mutex_lock_nodebug(&recorder->mutex);
    44. 	if(recorder->file) {
    45. 		fseek(recorder->file, 0L, SEEK_END);
    46. 		size_t fsize = ftell(recorder->file);
    47. 		fseek(recorder->file, 0L, SEEK_SET);
    48. 		JANUS_LOG(LOG_INFO, "File is %zu bytes: %s\n", fsize, recorder->filename);
    49. 	}
    50. 	if(rec_tempname) {
    51. 		/* We need to rename the file, to remove the temporary extension */
    52. 		char newname[1024];
    53. 		memset(newname, 0, 1024);
    54. 		g_snprintf(newname, strlen(recorder->filename)-strlen(rec_tempext), "%s", recorder->filename);
    55. 		char oldpath[1024];
    56. 		memset(oldpath, 0, 1024);
    57. 		char newpath[1024];
    58. 		memset(newpath, 0, 1024);
    59. 		if(recorder->dir) {
    60. 			g_snprintf(newpath, 1024, "%s/%s", recorder->dir, newname);
    61. 			g_snprintf(oldpath, 1024, "%s/%s", recorder->dir, recorder->filename);
    62. 		} else {
    63. 			g_snprintf(newpath, 1024, "%s", newname);
    64. 			g_snprintf(oldpath, 1024, "%s", recorder->filename);
    65. 		}
    66. 		if(rename(oldpath, newpath) != 0) {
    67. 			JANUS_LOG(LOG_ERR, "Error renaming %s to %s...\n", recorder->filename, newname);
    68. 		} else {
    69. 			JANUS_LOG(LOG_INFO, "Recording renamed: %s\n", newname);
    70. 			g_free(recorder->filename);
    71. 			recorder->filename = g_strdup(newname);
    72. 		}
    73. 	}
    74. 	janus_mutex_unlock_nodebug(&recorder->mutex);
    75. 	return 0;
    76. }

  • 相关阅读:
    leaflet 地图遮罩、扣洞
    CPP-Templates-2nd--第十一章 泛型库
    运营攻略︱推动用户增长的方法
    【送书活动】强势挑战Java，Kotlin杀回TIOBE榜单Top 20！学Kotlin看哪些书？
    【C++从入门到精通】第1篇：C++基础知识（上）
    智慧工厂视频智能分析系统
    【JAVA刷题初阶】刷爆力扣第十弹——二叉树
    【红日靶场】vulnstack4-完整渗透过程
    LSTM和双向LSTM讲解及实践
    数学建模学习笔记（10）：因子分析法
  • 原文地址：https://blog.csdn.net/fireroll/article/details/136274799