Single User

seamless_server/app_pubsub.py

@@ -123,12 +123,12 @@ class ServerLock(TypedDict):
     client_id: str
     member_object: Member
 
-MAX_SPEAKERS = os.environ.get("MAX_SPEAKERS")
+SINGLE_USER = os.environ.get("SINGLE_USER")
 
 if os.environ.get("LOCK_SERVER_COMPLETELY", "0") == "1":
     logger.info("LOCK_SERVER_COMPLETELY is set. Server will be locked on startup.")
-if MAX_SPEAKERS is not None and int(MAX_SPEAKERS):
-    logger.info(f"MAX_SPEAKERS is set to: {MAX_SPEAKERS}")
+if SINGLE_USER == "1":
+    logger.info(f"SINGLE_USER mode is set. Server will only allow one speaker or listener at a time.")
 dummy_server_lock_member_object = Member(
     client_id="seamless_user", session_id="dummy", name="Seamless User"
 )
@@ -428,6 +428,7 @@ async def join_room(sid, client_id, room_id_from_client, config_dict):
     }
     logger.info(f"[event: join_room] {args}")
     session_data = await get_session_data(sid)
+
     logger.info(f"session_data: {session_data}")
 
     room_id = room_id_from_client
@@ -459,6 +460,13 @@ async def join_room(sid, client_id, room_id_from_client, config_dict):
             session_id=sid,
             name=name,
         )
+        allow_user = check_and_lock_single_user(client_id, member)
+        if not allow_user:
+            logger.error(
+                f"In SINGLE_USER mode we only allow one user at a time. Ignoring request to configure stream from client {client_id}."
+            )
+            return {"status": "error", "message": "max_users"}
+
         logger.info(f"Created a new Member object: {member}")
         logger.info(f"Adding {member} to room {room_id}")
         room.members[client_id] = member
@@ -500,32 +508,22 @@ async def join_room(sid, client_id, room_id_from_client, config_dict):
             speaker_id for speaker_id in room.speakers if speaker_id != client_id
         ]
 
-    # If we currently own the server lock and are updating roles and we no longer have server lock specified, release it
-    if (
-        server_lock is not None
-        and server_lock["client_id"] == client_id
-        and config_dict.get("lockServerName") is None
-    ):
-        logger.info(f"[join_room] Releasing server lock: {pformat(server_lock)}")
-        server_lock = None
-
     # Only speakers should be able to lock the server
     if config_dict.get("lockServerName") is not None and "speaker" in config_dict.get(
         "roles", {}
     ):
         # If something goes wrong and the server gets stuck in a locked state the client can
         # force the server to remove the lock by passing the special name ESCAPE_HATCH_SERVER_LOCK_RELEASE_NAME
-        if (
-            server_lock is not None
-            and config_dict.get("lockServerName")
-            == ESCAPE_HATCH_SERVER_LOCK_RELEASE_NAME
-            # If we are locking the server completely we don't want someone to be able to unlock it
-            and not os.environ.get("LOCK_SERVER_COMPLETELY", "0") == "1"
-        ):
-            server_lock = None
-            logger.info(
-                f"🔓 Server lock has been reset by {client_id} using the escape hatch name {ESCAPE_HATCH_SERVER_LOCK_RELEASE_NAME}"
-            )
+        # TEMP: remove escape hatch for demo
+        # if (
+        #     server_lock is not None
+        #     and config_dict.get("lockServerName")
+        #     == ESCAPE_HATCH_SERVER_LOCK_RELEASE_NAME
+        # ):
+        #     server_lock = None
+        #     logger.info(
+        #         f"🔓 Server lock has been reset by {client_id} using the escape hatch name {ESCAPE_HATCH_SERVER_LOCK_RELEASE_NAME}"
+        #     )
 
         # If the server is not locked, set a lock. If it's already locked to this client, update the lock object
         if server_lock is None or server_lock.get("client_id") == client_id:
@@ -559,12 +557,21 @@ async def join_room(sid, client_id, room_id_from_client, config_dict):
 
     return {"roomsJoined": sio.rooms(sid), "roomID": room_id}
 
-def allow_speaker(room, client_id):
-    if MAX_SPEAKERS is not None and client_id in room.speakers:
-        room_statuses = {room_id: room.get_room_status_dict() for room_id, room in rooms.items()}
-        speakers = sum(room_status["activeTranscoders"] for room_status in room_statuses.values())
-        return speakers < int(MAX_SPEAKERS)
-    return True
+def check_and_lock_single_user(client_id, member):
+    global server_lock
+
+    if SINGLE_USER is None:
+        return True
+
+    if server_lock is None:
+        server_lock = {
+            "name": "single_user",
+            "client_id": client_id,
+            "member_object": member,
+        }
+        return True
+
+    return server_lock["client_id"] == client_id
 
 # TODO: Add code to prevent more than one speaker from connecting/streaming at a time
 @sio.event

streaming-react-app/src/RoomConfig.tsx

@@ -27,12 +27,14 @@ type Props = {
   serverState: ServerState | null;
   onJoinRoomOrUpdateRoles?: () => void;
   streamingStatus: StreamingStatus;
+  setHasMaxUsers: (hasMaxUsers: boolean) => void;
 };
 
 export default function RoomConfig({
   roomState,
   serverState,
   onJoinRoomOrUpdateRoles,
+  setHasMaxUsers,
   streamingStatus,
 }: Props) {
   const {socket, clientID} = useSocket();
@@ -90,6 +92,13 @@ export default function RoomConfig({
         configObject,
         (result) => {
           console.log('join_room result:', result);
+          if (result.message === 'max_users') {
+            setHasMaxUsers(true);
+            setJoinInProgress(false);
+            return;
+          } else {
+            setHasMaxUsers(false);
+          }
           if (createNewRoom) {
             setRoomID(result.roomID);
           }

streaming-react-app/src/SocketWrapper.tsx

@@ -11,9 +11,10 @@ import {getURLParams} from './URLParams';
 
 // The time to wait before showing a "disconnected" screen upon initial app load
 const INITIAL_DISCONNECT_SCREEN_DELAY = 2000;
-const SERVER_URL_DEFAULT = `${window.location.protocol === "https:" ? "wss" : "ws"
-                    }://${window.location.host}`;
-                    
+// const SERVER_URL_DEFAULT = `${window.location.protocol === "https:" ? "wss" : "ws"
+//                     }://${window.location.host}`;
+const SERVER_URL_DEFAULT = 'http://localhost:8000/'
+
 export default function SocketWrapper({children}) {
   const [socket, setSocket] = useState<Socket | null>(null);
   const [connected, setConnected] = useState<boolean | null>(null);

streaming-react-app/src/StreamingInterface.tsx

@@ -152,7 +152,7 @@ export default function StreamingInterface() {
     useState<StreamingStatus>('stopped');
 
   const isStreamConfiguredRef = useRef<boolean>(false);
-  const [hasMaxSpeakers, setHasMaxSpeakers] = useState<boolean>(false);
+  const [hasMaxUsers, setHasMaxUsers] = useState<boolean>(false);
 
   const [outputMode, setOutputMode] = useState<SupportedOutputMode>('s2s&t');
   const [inputSource, setInputSource] =
@@ -309,7 +309,6 @@ export default function StreamingInterface() {
       console.log('[configureStreamAsync] sending config', config);
 
       socket.emit('configure_stream', config, (statusObject) => {
-        setHasMaxSpeakers(statusObject.message === 'max_speakers')
         if (statusObject.status === 'ok') {
           isStreamConfiguredRef.current = true;
           console.debug(
@@ -757,20 +756,20 @@ export default function StreamingInterface() {
             <div className="header-container-sra">
               <div>
                 <Typography variant="body2" sx={{color: '#65676B'}}>
-                  Welcome! This space is limited to one speaker at a time. 
-                  If using the live HF space, sharing room code to listeners on another 
-                  IP address may not work because it's running on different replicas. 
+                  Welcome! This space is limited to one user at a time.
+                  If using the live HF space, sharing room code to listeners on another
+                  IP address may not work because it's running on different replicas.
                   Use headphones if you are both speaker and listener to prevent feedback.
                   <br/>
-                  If max speakers reached, please duplicate the space <a target="_blank" rel="noopener noreferrer" href="https://huggingface.co/spaces/facebook/seamless-streaming?duplicate=true">here</a>. 
-                  In your duplicated space, join a room as speaker or listener (or both), 
+                  If max users reached, please duplicate the space <a target="_blank" rel="noopener noreferrer" href="https://huggingface.co/spaces/facebook/seamless-streaming?duplicate=true">here</a>.
+                  In your duplicated space, join a room as speaker or listener (or both),
                   and share the room code to invite listeners.
                   <br/>
                   Check out the seamless_communication <a target="_blank" rel="noopener noreferrer" href="https://github.com/facebookresearch/seamless_communication/tree/main">README</a> for more information.
                   <br/>
                   SeamlessStreaming model is a research model and is not released
-                  for production deployment. It is important to use a microphone with 
-                  noise cancellation (for e.g. a smartphone), otherwise you may see model hallucination on noises. 
+                  for production deployment. It is important to use a microphone with
+                  noise cancellation (for e.g. a smartphone), otherwise you may see model hallucination on noises.
                   It works best if you pause every couple of sentences, or you may wish adjust the VAD threshold
                   in the model config. The real-time performance will degrade
                   if you try streaming multiple speakers at the same time.
@@ -783,6 +782,7 @@ export default function StreamingInterface() {
                   roomState={roomState}
                   serverState={serverState}
                   streamingStatus={streamingStatus}
+                  setHasMaxUsers={setHasMaxUsers}
                   onJoinRoomOrUpdateRoles={() => {
                     // If the user has switched from speaker to listener we need to tell the
                     // player to play eagerly, since currently the listener doesn't have any stop/start controls
@@ -955,6 +955,13 @@ export default function StreamingInterface() {
                     </Grid>
                   </Stack>
 
+                  <Typography variant="body2" sx={{color: '#65676B'}}>
+                    Note: we don't recommend echo cancellation, as it may distort
+                    the input audio (dropping words/sentences) if there is output
+                    audio playing. Instead, you should use headphones if you'd like
+                    to listen to the output audio while speaking.
+                  </Typography>
+
                   <Stack
                     direction="row"
                     spacing={2}
@@ -1120,13 +1127,6 @@ export default function StreamingInterface() {
                       </Alert>
                     </div>
                   )}
-                  {serverState != null && hasMaxSpeakers && (
-                    <div>
-                      <Alert severity="error">
-                        {`Maximum number of speakers reached. Please try again at a later time.`}
-                      </Alert>
-                    </div>
-                  )}
                   {serverState != null &&
                     serverState.totalActiveTranscoders >=
                       TOTAL_ACTIVE_TRANSCODER_WARNING_THRESHOLD && (
@@ -1156,6 +1156,13 @@ export default function StreamingInterface() {
             )}
           </div>
 
+          {hasMaxUsers && (
+            <div>
+              <Alert severity="error">
+                {`Maximum number of users reached. Please try again at a later time.`}
+              </Alert>
+            </div>
+          )}
           {debugParam && roomID != null && <DebugSection />}
 
           <div className="translation-text-container-sra horizontal-padding-sra">