Streaming From Raspberry Pi to YouTube

1) youtuberun.sh – after open we will see  ffmpeg command:

ffmpeg -threads 0 -f v4l2 -i /dev/video0 -ar 44100 -ac 2 -acodec pcm_s16le -f s16le -ac 2 -i /dev/zero -acodec aac -ab 128k -strict experimental -s 1280x720 -b 6000000 -aspect 16:9 -vcodec h264_omx -vb 820k -pix_fmt yuv420p -g 60 -r 30 -f flv rtmp://a.rtmp.youtube.com/live2/SECRET_KEY

if the image is not streaming to YouTube, I recommend run this command directly in the console and check the logs, it may turn out that we do not have ffmpeg installed (then install by calling sudo apt-get install ffmpeg) or our camera is at a different address than / dev/video0 (then edit the file and save), in this file we can also change the parameters of our stream sent to YouTube – a preview of the stream can be found at: https://www.youtube.com/live_dashboard

2) python.py is more complicated – to understand how it works, remember that our website has id 2:

and that the value of the youtube_state variable (read about variables in RemoteMe) keeps the current state of YouTube stream and it is:

-1:Youtube FAIL

0:Youtube OFF

1: Youtube ON

2:Youtube STARTING

3:Youtube CLOSING

I will now discuss individual parts of the file code python.py

def onDeviceConnectionChange(deviceId,state):
    global receiveDeviceConnected
    if deviceId == 2:
        if state:
            logger.info("device receive is now ON ")
        else:
            logger.info("device receive is now OFF transmission will end in 10s ")
    receiveDeviceConnected = state


# in initialization
remoteMe.subscribeDeviceConnectionChangeEvent(onDeviceConnectionChange)

because we want to enable streaming when our website with deviceId = 2 connects – we set the function onDeviceConnectionChange will be called as any device changes the connection status with the RemoteMe platform – and in the function itself we only filter status changes for the device with id 2 (because it is the deviceId of our website), then the current state is saved to the receiveDeviceConnected global variable

variable state readout takes place in a separate thread whose code looks like this:

def youtubeThreadFunction():
    global receiveDeviceConnected
    global youtubeState
    currentOn = False
    wait=0

    while True:
        logger.info('receiveDeviceConnected {} currentOn {} wait {} youtube state : {}'.format(receiveDeviceConnected,currentOn,wait,youtubeState))
        if not currentOn and receiveDeviceConnected:
            currentOn=True
            startYoutube()
            wait=0
        elif currentOn  and not receiveDeviceConnected:
            if wait	> 10:
                wait= 0
                currentOn = False
                endYoutube()
            else:
                wait=wait+1
        elif currentOn  and youtubeState == -1:
            currentOn = False
            endYoutube()
            wait= 0
    time.sleep(1)

the function has an infinite loop that checks if the device is connected and, depending on what was the previous status, starts streaming or closes streaming 10 seconds after disconnecting the website.

Streaming enables the function

def startYoutube():
    global thread1,process
    #thread1.stop()
    onYoutube(2)
    process = subprocess.Popen(['bash', 'youtuberun.sh'], stdout=subprocess.PIPE,stderr=subprocess.PIPE)
    thread1 = threading.Thread(target = checkingThread)
    thread1.start()
    logger.info("process ID {}".format(process.pid))

which runs the youtuberun.sh script in a separate thread, and the function:

def endYoutube():
    global process
    for x in range(0, 3):
        subprocess.run(["pkill","-TERM","-P",format(process.pid)])
        logger.info("pkill -TERM -P {}".format(process.pid))
        time.sleep(0.5)

    onYoutube(0)

calls the pkill command on our thread – to end it with its “children” threads (then the webcam turns off and we don’t stream anything anymore)

in addition, both functions set youtube_state variables by calling the function:

def onYoutube(b):
    global youtubeState
    youtubeState = b
    remoteMe.getVariables().setInteger("youtube_state", b)
    if b==1:
        logger.info('Youtube ON')
    elif b==0:
        logger.info('Youtube OFF')
    elif b==-1:
        logger.info('Youtube FAIL')
    elif b==2:
        logger.info('Youtube STARTING')
    elif b==3:
        logger.info('Youtube CLOSING')
    else:
        logger.info('Youtube undefined')

the value of the youtube_state variable is read by the website (discussed below) and displays the appropriate message to the user and injects the i frame code with YouTube preview.

a function worth discussing is also the function:

def checkingThread():
    global process
    i=0

    while True:
        time.sleep(0.2)
        line = process.stderr.read(200)
        i=i+1
        if line and 'speed=' in line.decode("utf-8"):
            onYoutube(1)
            return
        if i>100:
            onYoutube(-1)
            return

it checks by scanning the script output youtuberun.sh whether the message “speed =” appeared within 40s if so it means that our ffmpeg is streaming correctly, if it doesn’t mean that something went wrong and the appropriate value of the youtube_state variable is set

In addition, python.py checks the temperature of our raspberry and sets the variable cpu_temp which is displayed on the webpage.

 

 

 

What’s happening on the website

here you will find a detailed description about websites is in Remote Me, and here about Remote Me components

and now let’s discussed script.js files because only it requires explanations:

remoteme.remoteMeConfig.deviceConnectionChange.push((deviceId, connected) => {
    if (deviceId == 1) {//rpi device
    clearTimeout(notConnected);
    if (!connected) {
        showInfoModal("Raspberry Pi Not Connected - You cannot interact ", "fas fa-unlink", "#FF0000");
    } else {
        showInfoModal("Raspberry Pi connected", "fab fa-raspberry-pi", "#00c900", 2);
        connectYoutubeVariable();
    }
}});

we check if our RPI is connected, if so we call the function

function connectYoutubeVariable() {

    remoteme = RemoteMe.getInstance();
    remoteme.getVariables().observeInteger("youtube_state", (state) => {
    let htmlYoutubeState = "";
    if (state == 0) {
        htmlYoutubeState=`<i class="fab fa-youtube" style='color:black'></i> not connected`;
    } else if (state == 1) {
        htmlYoutubeState=`<i class="fab fa-youtube" style='color:#00c900'></i>connected`;
        if (previousYoutube != 1) {
        if (previousYoutube != undefined) {
            showInfoModal("Youtube actived. Page will be reload in 10s", "fab fa-youtube", "#00c900");
            setTimeout(() => {
                location.reload(true);
            }, 10000);

    } else {
        $("#youtubeContainer").html(`<iframe width="100%" height="100%" src="https://www.youtube.com/embed/live_stream?channel=CHANELID&autoplay=1" frameborder="0" allowfullscreen></iframe>`);

        showInfoModal("Youtube actived.", "fab fa-youtube", "#00c900", 2);
    }
}

} else if (state == -1) {
    showInfoModal("Youtube connect fail", "fab fa-youtube", "#00c900");
    htmlYoutubeState=`<i class="fab fa-youtube" style='color:#00c900'></i>connected`;
} else if (state == 2) {
    showInfoModal("Youtube starting", "fab fa-youtube", "#0000FF");
    htmlYoutubeState=`<i class="fab fa-youtube" style='color:#0000FF'></i>connecting`;
} else if (state == 3) {
    showInfoModal("Youtube closing", "fab fa-youtube", "orange");
    htmlYoutubeState=`<i class="fab fa-youtube" style='color:orange'></i>closing`;
}
    previousYoutube = state;
    $('#youtubeStatediv').html(htmlYoutubeState);
    });
}

this feature notifies the user of notifications, and when YouTube is actively enabled it injects a YouTube frame into html:

$("#youtubeContainer").html(<iframe width="100%" height="100%" src="https://www.youtube.com/embed/live_stream?channel=CHANELID&autoplay=1" frameborder="0" allowfullscreen></iframe>);

however, this only happens if the active transmission status is the first received – otherwise we refresh the page after 10 seconds (for unknown reasons this solution turns out to be better than simply injecting the YouTube frame) – then the first received state is the active state (set through the page before refreshing, and because Python waits 10 seconds after disconnecting the page will not be able to turn off the transmission) and we inject the frame.

 

 

 

Problems I noticed

Sometimes (I can’t determine the exact scenario) the YouTube frame shows the recorded previous broadcast – then it helps refreshing the page, or you need to delete the recorded broadcasts directly on YouTube. In the Python stop Youtube function, the pkill command is invoked three times – sometimes the first call does not kill the thread.