[wip]

Author: ThanhDodeurOdoo

src/models/ffmpeg.ts

@@ -15,12 +15,13 @@ export class FFMPEG extends EventEmitter {
         super();
         this.rtp = rtp;
         this.id = currentId++;
-        logger.trace(`creating FFMPEG for ${this.id} on ${this.rtp.type}`);
+        logger.verbose(`creating FFMPEG for ${this.id} on ${this.rtp.type}`);
         this._init();
     }
 
     close() {
         this._isClosed = true;
+        this.emit("close", this.id); // maybe different event if fail/saved properly
         this._cleanup();
     }
 
@@ -30,7 +31,8 @@ export class FFMPEG extends EventEmitter {
             this._cleanup();
             return;
         }
-        logger.trace(`FFMPEG ${this.id} is ready for ${this.rtp.type}`);
+        logger.trace(`To implement: FFMPEG start process ${this.id} for ${this.rtp.type}`);
+        // build FFMPEG params with rtp properties, start the process
     }
 
     private _cleanup() {

src/models/recorder.ts

@@ -49,11 +49,11 @@ export class Recorder extends EventEmitter {
      **/
     isTranscribing: boolean = false;
     state: RECORDER_STATE = RECORDER_STATE.STOPPED;
-    private folder?: Folder;
+    private _folder?: Folder;
     private readonly channel: Channel; // TODO rename with private prefix
-    private readonly tasks = new Map<SessionId, RecordingTask>();
+    private readonly _tasks = new Map<SessionId, RecordingTask>();
     /** Path to which the final recording will be uploaded to */
-    private readonly metaData: Metadata = {
+    private readonly _metaData: Metadata = {
         uploadAddress: "",
         timeStamps: {}
     };
@@ -67,7 +67,7 @@ export class Recorder extends EventEmitter {
         this._onSessionJoin = this._onSessionJoin.bind(this);
         this._onSessionLeave = this._onSessionLeave.bind(this);
         this.channel = channel;
-        this.metaData.uploadAddress = recordingAddress;
+        this._metaData.uploadAddress = recordingAddress;
     }
 
     async start() {
@@ -122,15 +122,15 @@ export class Recorder extends EventEmitter {
             logger.warn("recording failed at saving files"); // TODO more info
         }
         if (save && !hasFailure) {
-            await this.folder?.add("metadata.json", JSON.stringify(this.metaData));
-            await this.folder?.seal(
+            await this._folder?.add("metadata.json", JSON.stringify(this._metaData));
+            await this._folder?.seal(
                 path.join(recording.directory, `${this.channel.name}_${Date.now()}`)
             );
         } else {
-            await this.folder?.delete();
+            await this._folder?.delete();
         }
-        this.folder = undefined;
-        this.metaData.timeStamps = {};
+        this._folder = undefined;
+        this._metaData.timeStamps = {};
         this.state = RECORDER_STATE.STOPPED;
     }
 
@@ -139,21 +139,21 @@ export class Recorder extends EventEmitter {
         if (!session) {
             return;
         }
-        this.tasks.set(session.id, new RecordingTask(session, this._getTaskParameters()));
+        this._tasks.set(session.id, new RecordingTask(session, this._getTaskParameters()));
     }
 
     private _onSessionLeave(id: SessionId) {
-        const task = this.tasks.get(id);
+        const task = this._tasks.get(id);
         if (task) {
             task.stop();
-            this.tasks.delete(id);
+            this._tasks.delete(id);
         }
     }
 
     private _mark(tag: TIME_TAG) {
-        const events = this.metaData.timeStamps[Date.now()] || [];
+        const events = this._metaData.timeStamps[Date.now()] || [];
         events.push(tag);
-        this.metaData.timeStamps[Date.now()] = events;
+        this._metaData.timeStamps[Date.now()] = events;
     }
 
     private async _refreshConfiguration() {
@@ -177,28 +177,28 @@ export class Recorder extends EventEmitter {
 
     private async _update() {
         const params = this._getTaskParameters();
-        for (const task of this.tasks.values()) {
+        for (const task of this._tasks.values()) {
             Object.assign(task, params);
         }
     }
 
     private async _init() {
         this.state = RECORDER_STATE.STARTED;
-        this.folder = await getFolder();
+        this._folder = await getFolder();
         logger.trace(`TO IMPLEMENT: recording channel ${this.channel.name}`);
         for (const [sessionId, session] of this.channel.sessions) {
-            this.tasks.set(sessionId, new RecordingTask(session, this._getTaskParameters()));
+            this._tasks.set(sessionId, new RecordingTask(session, this._getTaskParameters()));
         }
         this.channel.on("sessionJoin", this._onSessionJoin);
         this.channel.on("sessionLeave", this._onSessionLeave);
     }
 
     private async _stopTasks() {
         const proms = [];
-        for (const task of this.tasks.values()) {
+        for (const task of this._tasks.values()) {
             proms.push(task.stop());
         }
-        this.tasks.clear();
+        this._tasks.clear();
         return Promise.allSettled(proms);
     }
 

src/models/recording_task.ts

@@ -2,7 +2,7 @@
 import { EventEmitter } from "node:events";
 
 import { RTP } from "#src/models/rtp.ts";
-import { Producer } from "mediasoup/node/lib/types";
+import type { Producer } from "mediasoup/node/lib/types";
 
 import { Session } from "#src/models/session.ts";
 import { Logger } from "#src/utils/utils.ts";

src/models/rtp.ts

@@ -1,4 +1,10 @@
-import type { Router, Producer, Consumer, PlainTransport } from "mediasoup/node/lib/types";
+import type {
+    Router,
+    Producer,
+    Consumer,
+    PlainTransport,
+    MediaKind
+} from "mediasoup/node/lib/types";
 import { getPort, type DynamicPort } from "#src/services/resources.ts";
 import { rtc } from "#src/config.ts";
 import { Deferred } from "#src/utils/utils.ts";
@@ -9,6 +15,7 @@ export class RTP {
     payloadType?: number;
     clockRate?: number;
     codec?: string;
+    kind?: MediaKind;
     channels?: number;
     type: STREAM_TYPE;
     private _router: Router;
@@ -59,20 +66,16 @@ export class RTP {
                 paused: true
             });
             if (this._isClosed) {
-                // may be closed by the time the consume is created
+                // may be closed by the time the consumer is created
                 this._cleanup();
                 return;
             }
-            // TODO may want to use producer.getStats() to get the codec info
-            // for val of producer.getStats().values() { if val.type === "codec": val.minetype, val.clockRate,... }
-            //const codecData = this._channel.router.rtpCapabilities.codecs.find(
-            //    (codec) => codec.kind === producer.kind
-            //);
             const codecData = this._producer.rtpParameters.codecs[0];
+            this.kind = this._producer.kind;
             this.payloadType = codecData.payloadType;
             this.clockRate = codecData.clockRate;
-            this.codec = codecData.mimeType.replace(`${this._producer.kind}`, "");
-            this.channels = this._producer.kind === "audio" ? codecData.channels : undefined;
+            this.codec = codecData.mimeType.replace(`${this.kind}`, "");
+            this.channels = this.kind === "audio" ? codecData.channels : undefined;
             this.isReady.resolve();
         } catch {
             this.close();