--- /dev/null
+#!/usr/bin/env sh
+
+##############################################################################
+##
+## Gradle start up script for UN*X
+##
+##############################################################################
+
+# Attempt to set APP_HOME
+# Resolve links: $0 may be a link
+PRG="$0"
+# Need this for relative symlinks.
+while [ -h "$PRG" ] ; do
+ ls=`ls -ld "$PRG"`
+ link=`expr "$ls" : '.*-> \(.*\)$'`
+ if expr "$link" : '/.*' > /dev/null; then
+ PRG="$link"
+ else
+ PRG=`dirname "$PRG"`"/$link"
+ fi
+done
+SAVED="`pwd`"
+cd "`dirname \"$PRG\"`/" >/dev/null
+APP_HOME="`pwd -P`"
+cd "$SAVED" >/dev/null
+
+APP_NAME="Gradle"
+APP_BASE_NAME=`basename "$0"`
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS=""
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD="maximum"
+
+warn () {
+ echo "$*"
+}
+
+die () {
+ echo
+ echo "$*"
+ echo
+ exit 1
+}
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "`uname`" in
+ CYGWIN* )
+ cygwin=true
+ ;;
+ Darwin* )
+ darwin=true
+ ;;
+ MINGW* )
+ msys=true
+ ;;
+ NONSTOP* )
+ nonstop=true
+ ;;
+esac
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+ if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+ # IBM's JDK on AIX uses strange locations for the executables
+ JAVACMD="$JAVA_HOME/jre/sh/java"
+ else
+ JAVACMD="$JAVA_HOME/bin/java"
+ fi
+ if [ ! -x "$JAVACMD" ] ; then
+ die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+ fi
+else
+ JAVACMD="java"
+ which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
+ MAX_FD_LIMIT=`ulimit -H -n`
+ if [ $? -eq 0 ] ; then
+ if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
+ MAX_FD="$MAX_FD_LIMIT"
+ fi
+ ulimit -n $MAX_FD
+ if [ $? -ne 0 ] ; then
+ warn "Could not set maximum file descriptor limit: $MAX_FD"
+ fi
+ else
+ warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
+ fi
+fi
+
+# For Darwin, add options to specify how the application appears in the dock
+if $darwin; then
+ GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
+fi
+
+# For Cygwin, switch paths to Windows format before running java
+if $cygwin ; then
+ APP_HOME=`cygpath --path --mixed "$APP_HOME"`
+ CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+ JAVACMD=`cygpath --unix "$JAVACMD"`
+
+ # We build the pattern for arguments to be converted via cygpath
+ ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
+ SEP=""
+ for dir in $ROOTDIRSRAW ; do
+ ROOTDIRS="$ROOTDIRS$SEP$dir"
+ SEP="|"
+ done
+ OURCYGPATTERN="(^($ROOTDIRS))"
+ # Add a user-defined pattern to the cygpath arguments
+ if [ "$GRADLE_CYGPATTERN" != "" ] ; then
+ OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
+ fi
+ # Now convert the arguments - kludge to limit ourselves to /bin/sh
+ i=0
+ for arg in "$@" ; do
+ CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
+ CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option
+
+ if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition
+ eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
+ else
+ eval `echo args$i`="\"$arg\""
+ fi
+ i=$((i+1))
+ done
+ case $i in
+ (0) set -- ;;
+ (1) set -- "$args0" ;;
+ (2) set -- "$args0" "$args1" ;;
+ (3) set -- "$args0" "$args1" "$args2" ;;
+ (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+ (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+ (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+ (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+ (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+ (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+ esac
+fi
+
+# Escape application args
+save () {
+ for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
+ echo " "
+}
+APP_ARGS=$(save "$@")
+
+# Collect all arguments for the java command, following the shell quoting and substitution rules
+eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
+
+# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
+if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
+ cd "$(dirname "$0")"
+fi
+
+exec "$JAVACMD" "$@"
--- /dev/null
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import org.asynchttpclient.DefaultAsyncHttpClient;
+import org.asynchttpclient.DefaultAsyncHttpClientConfig;
+import org.asynchttpclient.ws.WebSocket;
+import org.asynchttpclient.ws.WebSocketListener;
+import org.asynchttpclient.ws.WebSocketUpgradeHandler;
+import org.freedesktop.gstreamer.*;
+import org.freedesktop.gstreamer.Element.PAD_ADDED;
+import org.freedesktop.gstreamer.elements.DecodeBin;
+import org.freedesktop.gstreamer.elements.WebRTCBin;
+import org.freedesktop.gstreamer.elements.WebRTCBin.CREATE_OFFER;
+import org.freedesktop.gstreamer.elements.WebRTCBin.ON_ICE_CANDIDATE;
+import org.freedesktop.gstreamer.elements.WebRTCBin.ON_NEGOTIATION_NEEDED;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+
+/**
+ * Demo gstreamer app for negotiating and streaming a sendrecv webrtc stream
+ * with a browser JS app.
+ *
+ * @author stevevangasse
+ */
+public class WebrtcSendRecv {
+
+ private static final Logger logger = LoggerFactory.getLogger(WebrtcSendRecv.class);
+ private static final String REMOTE_SERVER_URL = "wss://webrtc.nirbheek.in:8443";
+ private static final String VIDEO_BIN_DESCRIPTION = "videotestsrc ! videoconvert ! queue ! vp8enc deadline=1 ! rtpvp8pay ! queue ! capsfilter caps=application/x-rtp,media=video,encoding-name=VP8,payload=97";
+ private static final String AUDIO_BIN_DESCRIPTION = "audiotestsrc ! audioconvert ! audioresample ! queue ! opusenc ! rtpopuspay ! queue ! capsfilter caps=application/x-rtp,media=audio,encoding-name=OPUS,payload=96";
+
+ private final String serverUrl;
+ private final String peerId;
+ private final ObjectMapper mapper = new ObjectMapper();
+ private WebSocket websocket;
+ private WebRTCBin webRTCBin;
+ private Pipeline pipe;
+
+ public static void main(String[] args) throws Exception {
+ if (args.length == 0) {
+ logger.error("Please pass at least the peer-id from the signalling server e.g java -jar build/libs/gst-java.jar --peer-id=1234 --server=wss://webrtc.nirbheek.in:8443");
+ return;
+ }
+ String serverUrl = REMOTE_SERVER_URL;
+ String peerId = null;
+ for (int i=0; i<args.length; i++) {
+ if (args[i].startsWith("--server=")) {
+ serverUrl = args[i].substring("--server=".length());
+ } else if (args[i].startsWith("--peer-id=")) {
+ peerId = args[i].substring("--peer-id=".length());
+ }
+ }
+ logger.info("Using peer id {}, on server: {}", peerId, serverUrl);
+ WebrtcSendRecv webrtcSendRecv = new WebrtcSendRecv(peerId, serverUrl);
+ webrtcSendRecv.startCall();
+ }
+
+ private WebrtcSendRecv(String peerId, String serverUrl) {
+ this.peerId = peerId;
+ this.serverUrl = serverUrl;
+ Gst.init();
+ webRTCBin = new WebRTCBin("sendrecv");
+
+ Bin video = Gst.parseBinFromDescription(VIDEO_BIN_DESCRIPTION, true);
+ Bin audio = Gst.parseBinFromDescription(AUDIO_BIN_DESCRIPTION, true);
+
+ pipe = new Pipeline();
+ pipe.addMany(webRTCBin, video, audio);
+ video.link(webRTCBin);
+ audio.link(webRTCBin);
+ setupPipeLogging(pipe);
+
+ // When the pipeline goes to PLAYING, the on_negotiation_needed() callback will be called, and we will ask webrtcbin to create an offer which will match the pipeline above.
+ webRTCBin.connect(onNegotiationNeeded);
+ webRTCBin.connect(onIceCandidate);
+ webRTCBin.connect(onIncomingStream);
+ }
+
+ private void startCall() throws Exception {
+ DefaultAsyncHttpClientConfig httpClientConfig =
+ new DefaultAsyncHttpClientConfig
+ .Builder()
+ .setUseInsecureTrustManager(true)
+ .build();
+
+ websocket = new DefaultAsyncHttpClient(httpClientConfig)
+ .prepareGet(serverUrl)
+ .execute(
+ new WebSocketUpgradeHandler
+ .Builder()
+ .addWebSocketListener(webSocketListener)
+ .build())
+ .get();
+
+ Gst.main();
+ }
+
+ private WebSocketListener webSocketListener = new WebSocketListener() {
+
+ @Override
+ public void onOpen(WebSocket websocket) {
+ logger.info("websocket onOpen");
+ websocket.sendTextFrame("HELLO 564322");
+ }
+
+ @Override
+ public void onClose(WebSocket websocket, int code, String reason) {
+ logger.info("websocket onClose: " + code + " : " + reason);
+ Gst.quit();
+ }
+
+ @Override
+ public void onTextFrame(String payload, boolean finalFragment, int rsv) {
+ if (payload.equals("HELLO")) {
+ websocket.sendTextFrame("SESSION " + peerId);
+ } else if (payload.equals("SESSION_OK")) {
+ pipe.play();
+ } else if (payload.startsWith("ERROR")) {
+ logger.error(payload);
+ Gst.quit();
+ } else {
+ handleSdp(payload);
+ }
+ }
+
+ @Override
+ public void onError(Throwable t) {
+ logger.error("onError", t);
+ }
+ };
+
+ private void handleSdp(String payload) {
+ try {
+ JsonNode answer = mapper.readTree(payload);
+ if (answer.has("sdp")) {
+ String sdpStr = answer.get("sdp").get("sdp").textValue();
+ logger.info("answer SDP:\n{}", sdpStr);
+ SDPMessage sdpMessage = new SDPMessage();
+ sdpMessage.parseBuffer(sdpStr);
+ WebRTCSessionDescription description = new WebRTCSessionDescription(WebRTCSDPType.ANSWER, sdpMessage);
+ webRTCBin.setRemoteDescription(description);
+ }
+ else if (answer.has("ice")) {
+ String candidate = answer.get("ice").get("candidate").textValue();
+ int sdpMLineIndex = answer.get("ice").get("sdpMLineIndex").intValue();
+ logger.info("Adding ICE candidate: {}", candidate);
+ webRTCBin.addIceCandidate(sdpMLineIndex, candidate);
+ }
+ } catch (IOException e) {
+ logger.error("Problem reading payload", e);
+ }
+ }
+
+ private CREATE_OFFER onOfferCreated = offer -> {
+ webRTCBin.setLocalDescription(offer);
+ try {
+ JsonNode rootNode = mapper.createObjectNode();
+ JsonNode sdpNode = mapper.createObjectNode();
+ ((ObjectNode) sdpNode).put("type", "offer");
+ ((ObjectNode) sdpNode).put("sdp", offer.getSDPMessage().toString());
+ ((ObjectNode) rootNode).set("sdp", sdpNode);
+ String json = mapper.writeValueAsString(rootNode);
+ logger.info("Sending offer:\n{}", json);
+ websocket.sendTextFrame(json);
+ } catch (JsonProcessingException e) {
+ logger.error("Couldn't write JSON", e);
+ }
+ };
+
+ private ON_NEGOTIATION_NEEDED onNegotiationNeeded = elem -> {
+ logger.info("onNegotiationNeeded: " + elem.getName());
+
+ // When webrtcbin has created the offer, it will hit our callback and we send SDP offer over the websocket to signalling server
+ webRTCBin.createOffer(onOfferCreated);
+ };
+
+ private ON_ICE_CANDIDATE onIceCandidate = (sdpMLineIndex, candidate) -> {
+ JsonNode rootNode = mapper.createObjectNode();
+ JsonNode iceNode = mapper.createObjectNode();
+ ((ObjectNode) iceNode).put("candidate", candidate);
+ ((ObjectNode) iceNode).put("sdpMLineIndex", sdpMLineIndex);
+ ((ObjectNode) rootNode).set("ice", iceNode);
+
+ try {
+ String json = mapper.writeValueAsString(rootNode);
+ logger.info("ON_ICE_CANDIDATE: " + json);
+ websocket.sendTextFrame(json);
+ } catch (JsonProcessingException e) {
+ logger.error("Couldn't write JSON", e);
+ }
+ };
+
+ private PAD_ADDED onIncomingDecodebinStream = (element, pad) -> {
+ logger.info("onIncomingDecodebinStream");
+ if (!pad.hasCurrentCaps()) {
+ logger.info("Pad has no caps, ignoring: {}", pad.getName());
+ return;
+ }
+ Structure caps = pad.getCaps().getStructure(0);
+ String name = caps.getName();
+ if (name.startsWith("video")) {
+ logger.info("onIncomingDecodebinStream video");
+ Element queue = ElementFactory.make("queue", "my-videoqueue");
+ Element videoconvert = ElementFactory.make("videoconvert", "my-videoconvert");
+ Element autovideosink = ElementFactory.make("autovideosink", "my-autovideosink");
+ pipe.addMany(queue, videoconvert, autovideosink);
+ queue.syncStateWithParent();
+ videoconvert.syncStateWithParent();
+ autovideosink.syncStateWithParent();
+ pad.link(queue.getStaticPad("sink"));
+ queue.link(videoconvert);
+ videoconvert.link(autovideosink);
+ }
+ if (name.startsWith("audio")) {
+ logger.info("onIncomingDecodebinStream audio");
+ Element queue = ElementFactory.make("queue", "my-audioqueue");
+ Element audioconvert = ElementFactory.make("audioconvert", "my-audioconvert");
+ Element audioresample = ElementFactory.make("audioresample", "my-audioresample");
+ Element autoaudiosink = ElementFactory.make("autoaudiosink", "my-autoaudiosink");
+ pipe.addMany(queue, audioconvert, audioresample, autoaudiosink);
+ queue.syncStateWithParent();
+ audioconvert.syncStateWithParent();
+ audioresample.syncStateWithParent();
+ autoaudiosink.syncStateWithParent();
+ pad.link(queue.getStaticPad("sink"));
+ queue.link(audioconvert);
+ audioconvert.link(audioresample);
+ audioresample.link(autoaudiosink);
+ }
+ };
+
+ private PAD_ADDED onIncomingStream = (element, pad) -> {
+ if (pad.getDirection() != PadDirection.SRC) {
+ logger.info("Pad is not source, ignoring: {}", pad.getDirection());
+ return;
+ }
+ logger.info("Receiving stream! Element: {} Pad: {}", element.getName(), pad.getName());
+ DecodeBin decodebin = new DecodeBin("my-decoder-" + pad.getName());
+ decodebin.connect(onIncomingDecodebinStream);
+ pipe.add(decodebin);
+ decodebin.syncStateWithParent();
+ webRTCBin.link(decodebin);
+ };
+
+ private void setupPipeLogging(Pipeline pipe) {
+ Bus bus = pipe.getBus();
+ bus.connect((Bus.EOS) source -> {
+ logger.info("Reached end of stream: " + source.toString());
+ Gst.quit();
+ });
+
+ bus.connect((Bus.ERROR) (source, code, message) -> {
+ logger.error("Error from source: '{}', with code: {}, and message '{}'", source, code, message);
+ });
+
+ bus.connect((source, old, current, pending) -> {
+ if (source instanceof Pipeline) {
+ logger.info("Pipe state changed from {} to new {}", old, current);
+ }
+ });
+ }
+}
+
projects / platform / upstream / gstreamer.git / commitdiff