[IMP] WIP: /

Author: ThanhDodeurOdoo

src/config.js

@@ -216,6 +216,8 @@ export const recording = Object.freeze({
     maxDuration: 1000 * 60 * 60, // 1 hour
     fileTTL: 1000 * 60 * 60 * 24, // 24 hours
     fileType: "mp4",
+    videoCodec: "libx264",
+    audioCodec: "aac",
     audioLimit: 20,
     cameraLimit: 4, // how many camera can be merged into one recording
     screenLimit: 1,

src/models/recorder.js

@@ -113,8 +113,11 @@ export class Recorder extends EventEmitter {
     async _start_fragment(ids) {
         const oldProcess = this.ffmpeg;
         this.state = RECORDER_STATE.UPDATING;
+        /** @type {RtpData[]} */
         const audioRtps = [];
+        /** @type {RtpData[]} */
         const cameraRtps = [];
+        /** @type {RtpData[]} */
         const screenRtps = [];
         for (const id of ids) {
             const session = this.channel.sessions.get(id);
@@ -123,22 +126,25 @@ export class Recorder extends EventEmitter {
                 continue;
             }
             if (audioRtps.length < recording.audioLimit) {
-                const audioRtpData = session.getRtp(STREAM_TYPE.AUDIO);
+                const audioRtpData = await session.getRtp(STREAM_TYPE.AUDIO);
                 audioRtpData && audioRtps.push(audioRtpData);
             }
             if (cameraRtps.length < recording.cameraLimit) {
-                const cameraRtpData = session.getRtp(STREAM_TYPE.CAMERA);
+                const cameraRtpData = await session.getRtp(STREAM_TYPE.CAMERA);
                 cameraRtpData && cameraRtps.push(cameraRtpData);
             }
             if (screenRtps.length < recording.screenLimit) {
-                const screenRtpData = session.getRtp(STREAM_TYPE.SCREEN);
+                const screenRtpData = await session.getRtp(STREAM_TYPE.SCREEN);
                 screenRtpData && screenRtps.push(screenRtpData);
             }
         }
-        const tempPath = path.join(recording.directory, `call_${Date.now()}.${recording.fileType}`);
+        const tempPath = path.join(
+            recording.directory,
+            `__FRAGMENT__-${this.uuid}-${Date.now()}.${recording.fileType}`
+        );
         this.ffmpeg = new FFMPEG(tempPath);
         try {
-            await this.ffmpeg.start(audioRtps, screenRtps, cameraRtps); // args should be base on the rtp transports
+            await this.ffmpeg.merge({ audioRtps, screenRtps, cameraRtps }); // args should be base on the rtp transports
             this.state = RECORDER_STATE.RECORDING;
         } catch (error) {
             logger.error(`Failed to start recording: ${error.message}`);
@@ -206,6 +212,11 @@ export class Recorder extends EventEmitter {
         if (filePaths.length === 1) {
             return filePaths[0];
         }
-        return filePaths[1]; // TODO merge logic with FFMPEG
+        const ffmpeg = new FFMPEG(
+            path.join(recording.directory, `__MERGED__-${this.uuid}.${recording.fileType}`)
+        );
+        // should await for ffmpeg complete event.
+        await ffmpeg.concat(filePaths);
+        return ""; // TODO merge logic with FFMPEG
     }
 }

src/models/session.js

@@ -498,7 +498,7 @@ export class Session extends EventEmitter {
 
     /**
      * @param {STREAM_TYPE[keyof STREAM_TYPE]} type
-     * @return {Promise<RtpData | undefined>}
+     * @return {RtpData}
      */
     async getRtp(type) {
         if (this._rtp[type]) {

src/utils/ffmpeg.js

@@ -48,15 +48,17 @@ const SCREEN_LAYOUT = {
  * @param {RtpData[]} screenRtps
  * @return {string}
  */
-function formatFfmpegSdp({ audioRtps, screenRtps, cameraRtps }) {
+function formatSdp({ audioRtps, screenRtps, cameraRtps }) {
     logger.info(`TODO: ${screenRtps}`);
     const sdp = ["v=0", "o=- 0 0 IN IP4 127.0.0.1", "s=FFmpeg", "c=IN IP4 127.0.0.1", "t=0 0"];
     for (const audioRtp of audioRtps) {
         sdp.push(`m=audio ${audioRtp.port} RTP/AVP ${audioRtp.payloadType}`);
         sdp.push(`a=rtpmap:${audioRtp.payloadType} ${audioRtp.codec}/${audioRtp.clockRate}`);
         sdp.push(`a=sendonly`);
     }
-    sdp.push(`-c:a aac -b:a 128k -ac 2 -filter_complex amerge=inputs=${audioRtps.length}`);
+    sdp.push(
+        `-c:a ${recording.audioCodec} -b:a 128k -ac 2 -filter_complex amerge=inputs=${audioRtps.length}`
+    );
     if (cameraRtps.length > 0) {
         const layout = SCREEN_LAYOUT[cameraRtps.length];
         if (!layout) {
@@ -68,7 +70,7 @@ function formatFfmpegSdp({ audioRtps, screenRtps, cameraRtps }) {
             sdp.push(`a=sendonly`);
         }
         sdp.push(`-filter_complex`, layout(cameraRtps.map((rtp) => rtp.label)));
-        sdp.push("-c:v libx264"); // TODO move outside of the condition, should also account for screenRtps
+        sdp.push(`-c:v ${recording.videoCodec}`); // TODO move outside of the condition, should also account for screenRtps
     }
     return sdp.join("\n");
 }
@@ -122,8 +124,8 @@ export class FFMPEG extends EventEmitter {
      * @param {RtpData[]} rtpInputs.screenRtps
      * @param {RtpData[]} rtpInputs.cameraRtps
      */
-    async start(rtpInputs) {
-        const sdp = formatFfmpegSdp(rtpInputs);
+    async merge(rtpInputs) {
+        const sdp = formatSdp(rtpInputs);
         this._process = child_process.spawn("ffmpeg", this._processArgs, {
             stdio: ["pipe", "pipe", process.stderr],
         });
@@ -144,6 +146,10 @@ export class FFMPEG extends EventEmitter {
         );
     }
 
+    concat(filePaths) {
+        return filePaths[0];
+    }
+
     kill() {
         this._process?.kill("SIGINT");
     }