Kurento Endpunkte, um aufzuzeichnen, um Screencasts

Question

Ich versuche, eine Webcam mit kurento Medienserver aufnehmen, hier ist die Funktion, die ich im Backend bin:

var startScreen = (sessionId, ws, sdpOffer, callback) => { 
    console.log("Start screen") 
    getKurentoClient((error, kurentoClient) => { 
    if (error) { 
     return callback(error) 
    } 

    kurentoClient.create('MediaPipeline', (error, pipeline) => { 
     if (error) { 
     return callback(error) 
     } 


    var recordParams = { 
     stopOnEndOfStream: true, 
     mediaProfile: 'WEBM_VIDEO_ONLY', 
     uri: 'file:///PATH/TO/VIDEO/screen.webm' 
     } 
     pipeline.create('RecorderEndpoint', recordParams, (error, recorder) => { 
     if (error) return callback(error) 

     screenRecorder = recorder 
     recorder.record(() => console.log("recording")) 
     pipeline.create('WebRtcEndpoint', (error, webRtcEndpoint) => { 
      if (error) { 
      pipeline.release() 
      return callback(error) 
      } 

     screenRtcEndpoint = webRtcEndpoint 

      if (candidatesQueue[sessionId]) { 
      while(candidatesQueue[sessionId].length) { 
       var candidate = candidatesQueue[sessionId].shift() 
       webRtcEndpoint.addIceCandidate(candidate) 
      } 
      } 
      webRtcEndpoint.on('OnIceCandidate', (event) => { 
      var candidate = kurento.register.complexTypes.IceCandidate(event.candidate) 
      ws.send(JSON.stringify({ 
       id: 'iceCandidateScreen', 
       candidate: candidate 
      })) 
      }) 

      webRtcEndpoint.processOffer(sdpOffer, (error, sdpAnswer) => { 
      if (error) { 
       pipeline.release() 
       return callback(error) 
      } 

      sessions[sessionId] = { 
       'pipeline': pipeline, 
       'webRtcEndpoint': webRtcEndpoint 
      } 

      webRtcEndpoint.connect(webRtcEndpoint, error => { 
      if (error) { 
       return callback(error) 
      } 
      console.log("Connect webrtcEndpoint") 
      webRtcEndpoint.connect(screenRecorder, error => { 
       if (error) { 
       return callback(error) 
       } 
       console.log("connect to the screen recorder") 
      }) 

      callback(null, sdpAnswer) 
      }) 

      }) 

      webRtcEndpoint.gatherCandidates((error) => { 
      if (error) { 
       return callback(error) 
      } 
      }) 
     }) 
     }) 
    }) 
    }) 
} 

die Pipeline etwa wie folgt aussieht:

mediaPipeline -> recorderEndpoint and recorder.record -> WebRtcEndpoint connect webrtcendpoint -> connect recorder endpoint 

am vorderen Ende ich das tun:

mediaConstrains = { 
    audio: false, 
    video: { 
    mandatory: { 
     maxWidth: 640, 
     maxHeight: 480, 
     maxFrameRate: 15, 
     minFrameRate: 1 
    } 
    } 
} 

var getMediaConstrains =() => mediaConstrains 

var setMediaConstrains = (config) => { 
    mediaConstrains = config 
} 

var startScreen =() => { 
    var options = { 
    mediaConstrains: mediaConstrains, 
    onicecandidate: onIceCandidate, 
    configuration: { iceServers: [ 
     {'url': 'turn:numb.viagenie.ca:3478', 
      'username': 'email@email.com', 
     'credential': 'passwordrandom'} 
    ] } 
    } 

    webRtcPeerScreen = kurentoUtils.WebRtcPeer.WebRtcPeerSendonly(options, function (error) { 
    if (error) { 
     return onError(error) 
    } 

    this.generateOffer(onOfferScreen) 
    }) 
} 

Dies ist nur für Screencasts welche nicht funktioniert, ich bin mit fast genau dem gleichen Code eine Webcam aufnehmen, die ihr voll funktionsfähigen, Dies ist die Funktion stop:

var stop =() => { 
    if (webRtcPeerWebcam && webRtcPeerScreen) { 
    webRtcPeerWebcam.dispose() 
    webRtcPeerWebcam = null 
    webRtcPeerScreen.dispose() 
    webRtcPeerScreen = null 

    var message = { 
     id: 'stop' 
    } 
    sendMessage(message) 
    } 
} 

Wo ich die Pipeline am vorderen Ende verfügen, aber ich dieses schicken Nachricht an das Backend und dann diese WSS Nachricht ruft diese Funktion:

var stop = (sessionId) => { 
    if (sessions[sessionId]) { 
    var pipeline = sessions[sessionId].pipeline 
    pipeline.release() 
    delete sessions[sessionId] 
    delete candidatesQueue[sessionId] 
    } 
} 

ich denke, das vielleicht das Problem, warum dies für die Aufzeichnung des Screencasts nicht funktioniert oder vielleicht die Pipelines nicht ordnungsgemäß

ich verbinde auf jeden Fall Vielen Dank!

PD: Ich fand diese auf KMS-Protokolle:

KurentoMediaElementImpl MediaElementImpl.cpp:434 mediaFlowOutStateChange() <kmswebrtcendpoint373> Media N OT Flowing OUT in pad default with type video 

Answer 1

Die erste und wichtigste Punkt ist, dass Sie Kandidaten verarbeiten, und jene Kandidaten zu sammeln, bevor der SDP Verhandlungen. Dies funktioniert nicht, daher denke ich, dass Ihr webrtc überhaupt nicht funktioniert, egal wie Sie die Endpunkte verbinden.

Zweitens erstellen Sie den Recorder vor dem WebRtcEndpoint und danach record aufrufen. Der Recorder hat nichts angeschlossen und kein Medium fließt IN. Ich würde vorschlagen, dass Sie die Methode record aufrufen, nachdem Sie den WebRtcEndpoint mit dem Rekorder verbunden haben und nachdem das Medium fließt. Zu diesem Zweck können Sie einen Zuhörer auf das Ereignis MediaStateChanged wie so

webRtcEndpoint.on('MediaStateChanged', function (event) { 
    if ((event.oldState !== event.newState) && (event.newState === 'CONNECTED')) { 
    // Start recording 
    recorderEndpoint.record(); 
    } 
}); 

Schließen Sie den WebRtcEndpoint an den Recorder hinzufügen rechts, nachdem Sie es erstellen.

Auch nur als Randnotiz, diese Linie nicht sinnvoll, da der Endpunkt sendonly

webRtcEndpoint.connect(webRtcEndpoint, error => { 

einfach zusammenzufassen, ist es das, was ich vorschlage. Vergessen Sie nicht, die Lücken zu füllen, die Sie finden könnten, denn ohne die Callbacks von OnIceCandidate und so weiter zu füllen, wird es nicht funktionieren.

var startScreen = (sessionId, ws, sdpOffer, callback) => { 
 
    console.log("Start screen") 
 
    getKurentoClient((error, kurentoClient) => { 
 
    if (error) { 
 
     return callback(error) 
 
    } 
 

 
    kurentoClient.create('MediaPipeline', (error, pipeline) => { 
 
     pipeline.create('RecorderEndpoint', recordParams, (error, recorder) => { 
 
     pipeline.create('WebRtcEndpoint', (error, webRtcEndpoint) => { 
 
      webRtcEndpoint.connect(screenRecorder, error => { 
 
      webRtcEndpoint.processOffer(sdpOffer, (error, sdpAnswer) => { 
 
       // The SDP negotiation must be completed before processing candidates 
 
       callback(null, sdpAnswer) 
 
       if (candidatesQueue[sessionId]) { 
 
       while (candidatesQueue[sessionId].length) { 
 
        var candidate = candidatesQueue[sessionId].shift() 
 
        webRtcEndpoint.addIceCandidate(candidate) 
 
       } 
 
       } 
 

 
       webRtcEndpoint.on('MediaStateChanged', function(event) { 
 
       // This will start recording right after media starts flowing 
 
       if ((event.oldState !== event.newState) && (event.newState === 'CONNECTED')) { 
 
        // Start recording 
 
        recorderEndpoint.record(); 
 
       } 
 
       }) 
 
       
 
       webRtcEndpoint.on('OnIceCandidate', (event) => { /* your code here */ }) 
 
       // Candidates must be gathered after the negotiation is completed, and the 
 
       // event handler is bound 
 
       webRtcEndpoint.gatherCandidates((error) => { /* your code here */ }) 
 
      }) 
 
      }) 
 
     }) 
 
     }) 
 
    }) 
 
    }) 
 
}

Answer 2

Es ist sehr zu empfehlen stop Methode auf RecorderEndpoint vor der Veröffentlichung zu nennen, sonst gibt es keine Garantie, dass die Medien in die Datei geschrieben wurde.

Abhängig von der Version von KMS, die Sie verwenden, können Sie sogar auf das Ereignis (Stopped) warten, um sicherzustellen, dass alle Medien in die Datei geschrieben wurden.

Darüber hinaus scheint Ihr Code WebrtcEndpoint mit RecorderEndpoint nicht zu verbinden, überprüfen Sie dies.

Edit:

Sie sollten auch prüfen, ob RecorderEndpoint ist Medien richtig sowie wenn WebRtcEndpoint empfängt von dem Netzwerk zu empfangen. Sie können MediaFlowOutStateChange und MediaFlowInStateChange sowie isMediaFlowingInisMediaFlowingOut Methoden verwenden (siehe kmd für akzeptierte Parameter)