Tmplab - User contributions [en]

Streaming Video Raspberry Web Interface

2015-01-18T22:02:42Z

Vincib:

== Streaming Video with a Raspberry pi, Web Interface ==

At the [[Streaming_Video_With_RaspberryPi]] page, we see how to drive a raspberry pi to save video files locally, stream them using ffmpeg & oggfwd on a secondary laptop.

This page explains the web interface vincib developped to drive the raspberry pi camera from a local machine, triggering the camera recording and saving files with their metadata.

Code at https://github.com/vincib/raspicamlive

== principles ==

* written in brutal php
* using bootstrap for beautiful interface :)
* no db, only local files

== interface menu ==

* '''harddrive management''' detect usb or hdd plugged to the PI and format / mount / umount them
* DONE '''capture management''' allow to start / stop the video with various parameters (width height framerate bitrate whitebalance), allow to save metadata in a json file in the project folder too. show a picture preview for each new .TS file.
* '''video management''' show previous projects and their capture date, their duration etc. Allow to download a .MTS of a specific sequence (project, starttime, endtime)
* DONE '''settings''' change rsync server password, poweroff the pi, restart the pi, restart the video service

Streaming Video Raspberry Web Interface

2015-01-18T00:52:51Z

Vincib: /* interface menu */

== Streaming Video with a Raspberry pi, Web Interface ==

At the [[Streaming_Video_With_RaspberryPi]] page, we see how to drive a raspberry pi to save video files locally, stream them using ffmpeg & oggfwd on a secondary laptop.

This page explains the web interface vincib developped to drive the raspberry pi camera from a local machine, triggering the camera recording and saving files with their metadata.

== principle ==

* written in brutal php
* using bootstrap for beautiful interface :)
* no db, only local files

== interface menu ==

* '''harddrive management''' detect usb or hdd plugged to the PI and format / mount / umount them
* '''capture management''' allow to start / stop the video with various parameters (width height framerate bitrate whitebalance), allow to save metadata in a json file in the project folder too. show a picture preview for each new .TS file.
* '''video management''' show previous projects and their capture date, their duration etc. Allow to download a .MTS of a specific sequence (project, starttime, endtime)
* '''settings''' change rsync server password, poweroff the pi, restart the pi, restart the video service

Streaming Video Raspberry Web Interface

2015-01-18T00:51:18Z

Vincib: New page: == Streaming Video with a Raspberry pi, Web Interface == At the Streaming_Video_With_RaspberryPi page, we see how to drive a raspberry pi to save video files locally, stream them usin...

== Streaming Video with a Raspberry pi, Web Interface ==

At the [[Streaming_Video_With_RaspberryPi]] page, we see how to drive a raspberry pi to save video files locally, stream them using ffmpeg & oggfwd on a secondary laptop.

This page explains the web interface vincib developped to drive the raspberry pi camera from a local machine, triggering the camera recording and saving files with their metadata.

== principle ==

* written in brutal php
* using bootstrap for beautiful interface :)
* no db, only local files

== interface menu ==

* '''harddrive management''' detect usb or hdd plugged to the PI and format / mount / umount them
* '''capture management''' allow to start / stop the video with various parameters (width height bitrate whitebalance), allow to save metadata in a json file in the project folder too. show a picture preview for each new .TS file.
* '''video management''' show previous projects and their capture date, their duration etc. Allow to download a .MTS of a specific sequence (project, starttime, endtime)
* '''settings''' change rsync server password, poweroff the pi, restart the pi, restart the video service

Streaming Video With RaspberryPi

2015-01-18T00:29:13Z

Vincib: /* D. Broadcast from server to icecast */

= General =

Caution: this is a Work in progress, things are being tested. The objective is to provide in the end one or more working solutions for everyone.

== Video streaming is a problem ==

The RaspberryPi camera offers an interesting solution to this problem. It is a very well integrated module of the Pi with one huge advantage: h264 encoding can be performed directly by the CPU as the camera uses the Serial Camera Interface protocol.

So theorically, solving the video problem with the Pi is easy but there are many subtle problems.

== Problems ==

'''Audio''' As we use video webstreaming mostly for conferences broadcasting, good audio quality is necessary.

'''Slides''' It would be interesting to include slides of conferences while filming.

'''File''' It is important to have a file at the end of the filming.

'''Web''' It is important to have a large viewer base, therefore a well supported format.

== Raspicam basics ==

http://elinux.org/Rpi_Camera_Module

raspivid is the basic command line used to capture video in h264.

<code>raspivid -t 3 -fps 25 -b 1000000 -w 1920 -h 1080 -o /tmp/video.h264</code>

A very simple tutorial : http://www.raspberrypi-spy.co.uk/2013/05/capturing-hd-video-with-the-pi-camera-module/

Note: when using 1920x1080, the raspicam take those pixel at the center of the captor. When using smaller definitions, it's using all the 5mpixels and extrapoling down to your requested definition. As a result, a 1280x720 video looks "unzoomed" compared to a 1920x1080, the latter having more grain in the picture too. '''tl;dr: use 1280x720 maximum''' ;)

= Solution =

== Solution 1 : OGG/VORBIS + Icecast ==

'''Basic idea'''

# Use the PI to capture video as h264, merge audio from usb and use ffmpeg to produce MPEGTS "chunks"
# Rsync the chunks to a laptop or a server (note : the audio mix should be integrated here to ensure a good audio/video synchronization)
# Assemble the chunks and pipe them in ffmpeg
# Ask ffmpeg to convert this into ogg
# Use oggfwd to push the ogg to your icecast server
# Serve m3u from the server

'''CON''' ogg does not work for everyone. It is supposed to be HTML5 compatible but icecast doesn't offer that by default.

'''PRO''' Icecast is simple, open, and handles authentification. Rsync using SSH is crypto friendly. The file is saved on the server.

=== How to stream in OGG to Icecast ===

==== A. Compile FFMPEG on pi & server (see below) ====

==== B. Start capture in a screen ====

It is advised to run this one liner in a <code>screen</code> command on the RaspberryPi

<code>[ -d /tmp/capture ] || mkdir /tmp/capture; rm -f /tmp/capture/* && cd /tmp/capture/ && \
raspivid -ih -t 0 -w 1280 -h 720 -b 1000000 -pf baseline -o - | /usr/local/bin/ffmpeg -f alsa -itsoffset 6.5 -ac 1 -i hw:1 -acodec aac -strict -2 \
-i - -vcodec copy -f segment -segment_list out.list -segment_list_flags +live -segment_list_size 5 -segment_time 4 -segment_time_delta 3 %10d.ts</code>

'''What's happening here'''

#<code>[ -d /tmp/capture ] || mkdir /tmp/capture; rm -f /tmp/capture/* && cd /tmp/capture/</code> We create a /tmp/capture folder and make sure it's empty when starting capture in it
#<code> raspivid </code> Use raspivid to capturing with following parameters:
##<code> -ih </code>(inline headers) '''DONT CHANGE''' Necessary for technical reasons, as otherwise the "chunking" doesn't work
##<code> -t 0 </code> (timeout) '''DONT CHANGE''' Necessary for technical reasons, as otherwise capture stops after 5s
##<code> -w 1080 -h 720 </code> (height) and (width) Tweak according to your needs
##<code> -b 1000000 </code> (bitrate) Tweak according to your needs (only integer numbers in bits are accepted, here <=> 1Mb)
##<code> -pf baseline </code> (h264 profile) Tweak according to your needs ( only baseline, main, or high accepted)
##<code> -o - </code> (output) '''DONT CHANGE''' Necessary in order to use the flux as Standard Output
# We pipe the content into ffmpeg with following parameters:
## ALSA Input
###<code> -f alsa </code> (format) We use <code>alsa</code> for usb audio capture
###<code> -itsoffset 6.5 </code> (time offset) '''This one is a trick''' We noticed our RPi B+ had a 6.5 seconds delay to start the audio, so this is used to resync audio. Tweak.
###<code> -ac 1 </code> (number of audio channels) We used a mono input, so <code>1</code> was the right choice. Tweak
###<code> -i hw:1 </code> (input) '''Tweak''' as your audio card adress may vary. Find more with <code>arecord -l</code>
###<code> -acodec aac </code> (audio codec) AAC works well for TS live.
###<code> -strict -2 </code> Argument mandatory for AAC format
## Video Input
###<code> -i - </code> (input) '''DONT CHANGE''' Use the Standard input
###<code> -vcodec copy</code> (video codec) '''DONT CHANGE''' Use the video codec from the RPi. Not enough CPU to do anything else.
###<code> -f segment </code> (output format) '''DONT CHANGE''' Use a "chunked" output
###<code> -segment_list out.list </code> (segment file) Defines a file containing the produced files names
###<code> -segment_list_flags +live </code> (segment file flags) Defines the way the output file caches files names.
###<code> -segment_list_size 5 </code> (segment file size)
###<code> -segment_time 4 </code> (segment time) Defines the capture base duration in seconds. Tweak.
###<code> -segment_time_delta 3 </code> (segment time delta) Defines a window to modulate chunks duration in seconds to include mandatory inline headers. Tweak.
###<code> %10d.ts </code> The format for chunks files names. %10d will start at 0000000000.ts and ffmpeg understand we want MPEGTS format for chunks
# ffmpeg saves the files 0000.ts, 0001.ts, etc. and out.list in /tmp/capture

==== C. Use rsync to infinitely synchronise chunks on server ====

'''Some important points to mention here '''

* The RaspberryPi '''MUST''' have access to a <server> using an SSH KEY for an <user>. Password access won't work for infinite rsync.
* This <server> '''CAN''' be your laptop. If so it MUST be on the same LAN as the RaspberryPi
* This <server> '''CAN''' be a datacenter machie. If so it MUST be accessible on Internet by the RaspberryPi.
* This <server> '''MUST''' have FFMPEG installed (see point D below)
* It is advised to run this one liner in a <code>screen</code> command on the RaspberryPi

<code> ssh <user>@<server> "[ -d /tmp/capture ] || mkdir /tmp/capture" && \
while true; do rsync -a --files-from=/tmp/capture/out.list /tmp/capture <user>@<server>:/tmp/capture; sleep 1; done</code>

'''What's happening here'''

#<code> ssh </code> Use SSH ...
##<code> <user>@<server> </code> ... to connect to server "server" as user "user"
##<code> "[ -d /tmp/capture ] || mkdir /tmp/capture" </code> ... and create if not exists a folder "/tmp/capture"
#<code> while true; do </code> Run an infinite loop
##<code> rsync </code> Start rsync file synchronisation
###<code> -a </code> (archive mode) Set the right parameters for transfer
###<code> --files-from=/tmp/capture/out.list </code> Use the out.list as a list of file to transfer, which avoids scanning the whole folder
###<code> /tmp/capture </code> (source) Transfer local folder content...
###<code> <user>@<server>:/tmp/capture; </code> (destination) To the server "server"
##<code> sleep 1; </code> Sleep one second
#<code> done </code> Loop end

==== D. Broadcast from server to icecast ====

* You '''MUST''' install some script on <server> to assemble / concatenate the MPEGTS chunks for you.
This PHP streamer is made for that: <code>https://raw.githubusercontent.com/albancrommer/raspistream/master/stream.php</code>
* You '''MUST''' install ffmpeg on <server> with ogg support (see below)
* You '''MUST''' install the oggfwd command line tool with <code>aptitude install oggfwd</code>
* You '''MUST''' have access to an icecast server. If you use a datacenter server, everything can run locally

<code> php /usr/local/bin/stream.php | ffmpeg -i - -r 12 -s 640x360 -vb 1000k -f ogg - | oggfwd -p -n "My RaspberryPi Stream" <stream.server.com> 8000 mySecretIceCastStreamingPassword /test </code>

'''What's happening here'''

#<code> php /usr/local/bin/stream.php </code> Start an infinite stream of assembled chunks received via rsync
#<code> | ffmpeg </code> Pipe into FFMPEG
##<code> -i - </code> (input) '''DON'T CHANGE''' Use Standard In as input
##<code> -r 12</code> number of images per second (recommended: low values for live streaming)
##<code> -s 640x360</code> width and height of the video. You need to keep the same ratio but 640x360 is good for low-bandwidth live streaming
##<code> -vb 1000k </code> video bitrate in bps. use 400 for ~512Kbps video streaming
##<code> -f ogg </code> (format) '''DON'T CHANGE''' Use ogg as output format
##<code> - </code> (output) '''DON'T CHANGE''' Output to Standard Out
#<code> | oggfwd </code> Pipe into oggfwd
##<code> -p </code> (public) Makes the stream public. Tweak
##<code> -n "My RaspberryPi Stream" </code> (name) Your stream name. Adapt
##<code> <stream.server.com> </code> (address) Your icecast server name. Adapt
##<code> 8000 </code> (port) 8000 is default for icecast. Adapt
##<code> <mySecretIceCastStreamingPassword> </code> (password) The icecast input password Adapt
##<code> /rpi01 </code> (mountpoint) The icecast "mountpoint" ie. the path for your stream

==== E. Get the m3u from icecast ====

With the default parameters provided the stream would be accessed on

<code>http://<stream.server.com>:8000/rpi01.m3u</code>

==== Sources ====

http://sirlagz.net/2013/01/07/how-to-stream-a-webcam-from-the-raspberry-pi-part-3/

=== How to get full video from the small chunks ===

After the streaming you should have chunks both on the RaspberryPi and the server, and could perform the conversion on any of them.

Except that the RaspberryPi is VERY slow and that depending on your budget / stability needs you might not have kept all the chunks on the RaspberryPi.

In other words, make the conversion on the server, be it your laptop or a datacenter server.

==== A. Clean the last file (optional) ====

As our last chunk / fragment might be invalid, it's safer to remove it using :

<code>ls /tmp/capture/*ts|tail -n 1|xargs rm </code>

'''What's happening here'''

This command retrieves a sorted list of all chunks in the capture folder, extracts the last one and deletes it.

==== B. Convert to single file (mp4, webm) ====

It is assumed you have FFMPEG installed on the machine.

It is assumed you want to make minimal changes to your original video input (size, bitrate, etc). Only essential options are provided but you can add more according to your needs, double pass conversion is not included either.

It is recommanded to use a script for files merging, as ffmpeg syntax can be a bit of a mess for that, with little option if you want to use start or end file.

This PHP script is made for that : https://raw.githubusercontent.com/albancrommer/raspistream/master/concat.php

''' Converting to MP4 '''

This operation can be fast as the MPEGTS chunks are ready for MP4

<code>php concat.php <start> <end> | ffmpeg -i - -movflags +faststart -threads 0 -profile:v high -preset slow <myfile>.mp4</code>

'''What's happening here'''

#<code> php concat.php </code> Start concatenation
##<code> <start> </code> (optional) an integer designing the first file to include
##<code> <end> </code>(optional) an integer designing the last file to include
#<code> | ffmpeg </code> Pipe into FFMPEG with following parameters
##<code> -i - </code> (input) '''DON'T CHANGE''' use stdin as input
##<code> -movflags +faststart </code> '''DON'T CHANGE''' Make the file ready for web viewing
##<code> -threads 0 </code> Require all CPU to work on the conversion. Tweak.
##<code> -profile:v high </code> Set the output quality. Tweak.
##<code> -preset slow </code> Set the encoding speed.Tweak.
##<code> <myfile>.mp4 </code> Your output file name. Adapt.

''' Converting to WEBM '''

This operation will be slower as audio and video tracks needs to use new codecs

<code>php concat.php <start> <end> | ffmpeg -i - -codec:a libvorbis -codec:v libvpx -threads 0 -quality good -cpu-used 0 -qmin 10 -qmax 42 <myfile>.webm</code>

'''What's happening here'''

#<code> php concat.php </code> Start concatenation
##<code> <start> </code> (optional) an integer designing the first file to include
##<code> <end> </code>(optional) an integer designing the last file to include
#<code> | ffmpeg </code> Pipe into FFMPEG with following parameters
##<code> -i - </code> (input) '''DON'T CHANGE''' use stdin as input
##<code> -codec:a libvorbis </code> (codec) '''DON'T CHANGE''' Define the audio codec
##<code> -codec:v libvpx </code> (codec) '''DON'T CHANGE''' Define the video codec
##<code> -threads 0 </code> Require all CPU to work on the conversion. Tweak.
##<code> -quality good </code> Set the encoding speed. Tweak
##<code> -cpu-used 1 </code> Set the encoding speed. Tweak
##<code> -qmin 10 -qmax 42 </code> Set the encoding quality. Tweak
##<code> <myfile>.webm </code> Your output file name. Adapt

==== Sources ====

https://www.virag.si/2012/01/web-video-encoding-tutorial-with-ffmpeg-0-9/
https://www.virag.si/2012/01/webm-web-video-encoding-tutorial-with-ffmpeg-0-9/

== Solution 2 : FLVSTR + PHP Streamer ==

'''Basic idea''' Octopuce company has a solution to convert live MP4 to F4V. With an USB audio card, we could mux the MP4 and AAC audio and have a standalone solution not needing any laptop.

'''CON''' authentication not included as of now (only IP address), F4V means Flash, requires an USB disk for local backup. Also, the live stream will need to have the same bitrate as the recorded one.

'''PRO''' the pi can be autonomous (no need for a laptop to encode the live stream)

First, authentication. This problem is adressed by solving encryption as well: we use an SSL socket to communicate with the server. (we could use rsync server mode too).

== Solution 3 : RTSP ==

'''Basic idea''' Use an RTSP stream with VLC and the V4L driver

'''CON''' Non commercial RTSP server are not the norm, requires VLC or Flash player, Quality with v4l is low

'''PRO''' Easy to work out

'''Sources'''

http://www.ics.com/blog/raspberry-pi-camera-module#.VJFhbyvF-b8

http://raspberrypi.stackexchange.com/questions/23182/how-to-stream-video-from-raspberry-pi-camera-and-watch-it-live

http://ffmpeg.gusari.org/viewtopic.php?f=16&t=1130

http://blog.tkjelectronics.dk/2013/06/how-to-stream-video-and-audio-from-a-raspberry-pi-with-no-latency/

== Solution 4 : HLS + RSYNC ==

'''Basic idea''' Use HLS segmentation and rsync

'''CON''' Not all web players can do HLS

'''PRO''' Almost out of the box, robust

'''Howto'''

1. Compile fresh ffmpeg on the pi

2. Run a capture : <code>raspivid -ih -pf baseline -t 0 -b 1000000 -w 1280 -h 720 -v -o - | ffmpeg -i - -f alsa -ac 1 -itsoffset 6.5 -i hw:1 -acodec aac -strict -2 -vcodec copy out.m3u8 </code>

3. Run a cron rsync to server (todo)

4. Connect a client (todo)

'''Sources'''

http://www.ffmpeg.org/ffmpeg-formats.html#hls

= FFMPEG compilation =

This installation is debian based. Some packages are included by default :

* ffmpeg : Provides a large number of the dependencies required at compilation tim
* yasm : modular assembler (good for compilation)
* pkg-config : info about installed libraries (good for compilation)
* screen : helpful for running compilation in background

== For Raspberry ==

For the Raspberry, we only need the support of h264, AAC and ALSA
<pre>
sudo -s
aptitude install screen yasl libx264-dev libasound2-dev libfdk-aac-dev ffmpeg
cd /usr/src
git clone --depth 1 git://source.ffmpeg.org/ffmpeg.git
cd ffmpeg
./configure --enable-gpl --enable-libx264 --enable-libfdk-aac
make
make install
</pre>

== For laptop or server ==

Your default debian might come with sufficent support but if you want total control, compiling is a good idea.

Remove packages and ffmpeg support if you don't need everything.

Ex: to produce ogg format, you only need
* aptitude packages libtheora-dev and libvorbis-dev
* configure options --enable-libtheora --enable-libvorbis

<pre>
sudo
aptitude update && aptitude install screen pkg-config yasm ffmpeg libass-dev libavcodec-extra libfdk-aac-dev libmp3lame-dev libopus-dev libtheora-dev libvorbis-dev libvpx-dev libx264-dev
cd /usr/src
git clone --depth 1 git://source.ffmpeg.org/ffmpeg.git
cd ffmpeg
./configure --enable-gpl --enable-libass --enable-libfdk-aac --enable-libfreetype --enable-libmp3lame --enable-libopus --enable-libtheora --enable-libvorbis --enable-libvpx --enable-libx264 --enable-nonfree --enable-x11grab
make
make install
</pre>

= References =

Here are a number of unsorted links

* http://techzany.com/2013/09/live-streaming-video-using-avconv-and-a-raspberry-pi/
* http://blog.cloudfrancois.fr/category/streaming-video.html

== FFMPEG ==

* http://ffmpeg.org/ffmpeg-all.html#segment_002c-stream_005fsegment_002c-ssegment
* https://trac.ffmpeg.org/wiki/StreamingGuide

== Node ==

* http://phoboslab.org/log/2013/09/html5-live-video-streaming-via-websockets
* https://github.com/phoboslab/jsmpeg
* https://github.com/fluent-ffmpeg/node-fluent-ffmpeg

== Raspberry PI ==

* Raspbian, debian on Raspberry pi http://www.raspbian.org/
* Chose your SD card for your PI : http://elinux.org/RPi_SD_cards

Streaming Video With RaspberryPi

2015-01-18T00:20:08Z

Vincib: /* Raspicam basics */

= General =

Caution: this is a Work in progress, things are being tested. The objective is to provide in the end one or more working solutions for everyone.

== Video streaming is a problem ==

The RaspberryPi camera offers an interesting solution to this problem. It is a very well integrated module of the Pi with one huge advantage: h264 encoding can be performed directly by the CPU as the camera uses the Serial Camera Interface protocol.

So theorically, solving the video problem with the Pi is easy but there are many subtle problems.

== Problems ==

'''Audio''' As we use video webstreaming mostly for conferences broadcasting, good audio quality is necessary.

'''Slides''' It would be interesting to include slides of conferences while filming.

'''File''' It is important to have a file at the end of the filming.

'''Web''' It is important to have a large viewer base, therefore a well supported format.

== Raspicam basics ==

http://elinux.org/Rpi_Camera_Module

raspivid is the basic command line used to capture video in h264.

<code>raspivid -t 3 -fps 25 -b 1000000 -w 1920 -h 1080 -o /tmp/video.h264</code>

A very simple tutorial : http://www.raspberrypi-spy.co.uk/2013/05/capturing-hd-video-with-the-pi-camera-module/

Note: when using 1920x1080, the raspicam take those pixel at the center of the captor. When using smaller definitions, it's using all the 5mpixels and extrapoling down to your requested definition. As a result, a 1280x720 video looks "unzoomed" compared to a 1920x1080, the latter having more grain in the picture too. '''tl;dr: use 1280x720 maximum''' ;)

= Solution =

== Solution 1 : OGG/VORBIS + Icecast ==

'''Basic idea'''

# Use the PI to capture video as h264, merge audio from usb and use ffmpeg to produce MPEGTS "chunks"
# Rsync the chunks to a laptop or a server (note : the audio mix should be integrated here to ensure a good audio/video synchronization)
# Assemble the chunks and pipe them in ffmpeg
# Ask ffmpeg to convert this into ogg
# Use oggfwd to push the ogg to your icecast server
# Serve m3u from the server

'''CON''' ogg does not work for everyone. It is supposed to be HTML5 compatible but icecast doesn't offer that by default.

'''PRO''' Icecast is simple, open, and handles authentification. Rsync using SSH is crypto friendly. The file is saved on the server.

=== How to stream in OGG to Icecast ===

==== A. Compile FFMPEG on pi & server (see below) ====

==== B. Start capture in a screen ====

It is advised to run this one liner in a <code>screen</code> command on the RaspberryPi

<code>[ -d /tmp/capture ] || mkdir /tmp/capture; rm -f /tmp/capture/* && cd /tmp/capture/ && \
raspivid -ih -t 0 -w 1280 -h 720 -b 1000000 -pf baseline -o - | /usr/local/bin/ffmpeg -f alsa -itsoffset 6.5 -ac 1 -i hw:1 -acodec aac -strict -2 \
-i - -vcodec copy -f segment -segment_list out.list -segment_list_flags +live -segment_list_size 5 -segment_time 4 -segment_time_delta 3 %10d.ts</code>

'''What's happening here'''

#<code>[ -d /tmp/capture ] || mkdir /tmp/capture; rm -f /tmp/capture/* && cd /tmp/capture/</code> We create a /tmp/capture folder and make sure it's empty when starting capture in it
#<code> raspivid </code> Use raspivid to capturing with following parameters:
##<code> -ih </code>(inline headers) '''DONT CHANGE''' Necessary for technical reasons, as otherwise the "chunking" doesn't work
##<code> -t 0 </code> (timeout) '''DONT CHANGE''' Necessary for technical reasons, as otherwise capture stops after 5s
##<code> -w 1080 -h 720 </code> (height) and (width) Tweak according to your needs
##<code> -b 1000000 </code> (bitrate) Tweak according to your needs (only integer numbers in bits are accepted, here <=> 1Mb)
##<code> -pf baseline </code> (h264 profile) Tweak according to your needs ( only baseline, main, or high accepted)
##<code> -o - </code> (output) '''DONT CHANGE''' Necessary in order to use the flux as Standard Output
# We pipe the content into ffmpeg with following parameters:
## ALSA Input
###<code> -f alsa </code> (format) We use <code>alsa</code> for usb audio capture
###<code> -itsoffset 6.5 </code> (time offset) '''This one is a trick''' We noticed our RPi B+ had a 6.5 seconds delay to start the audio, so this is used to resync audio. Tweak.
###<code> -ac 1 </code> (number of audio channels) We used a mono input, so <code>1</code> was the right choice. Tweak
###<code> -i hw:1 </code> (input) '''Tweak''' as your audio card adress may vary. Find more with <code>arecord -l</code>
###<code> -acodec aac </code> (audio codec) AAC works well for TS live.
###<code> -strict -2 </code> Argument mandatory for AAC format
## Video Input
###<code> -i - </code> (input) '''DONT CHANGE''' Use the Standard input
###<code> -vcodec copy</code> (video codec) '''DONT CHANGE''' Use the video codec from the RPi. Not enough CPU to do anything else.
###<code> -f segment </code> (output format) '''DONT CHANGE''' Use a "chunked" output
###<code> -segment_list out.list </code> (segment file) Defines a file containing the produced files names
###<code> -segment_list_flags +live </code> (segment file flags) Defines the way the output file caches files names.
###<code> -segment_list_size 5 </code> (segment file size)
###<code> -segment_time 4 </code> (segment time) Defines the capture base duration in seconds. Tweak.
###<code> -segment_time_delta 3 </code> (segment time delta) Defines a window to modulate chunks duration in seconds to include mandatory inline headers. Tweak.
###<code> %10d.ts </code> The format for chunks files names. %10d will start at 0000000000.ts and ffmpeg understand we want MPEGTS format for chunks
# ffmpeg saves the files 0000.ts, 0001.ts, etc. and out.list in /tmp/capture

==== C. Use rsync to infinitely synchronise chunks on server ====

'''Some important points to mention here '''

* The RaspberryPi '''MUST''' have access to a <server> using an SSH KEY for an <user>. Password access won't work for infinite rsync.
* This <server> '''CAN''' be your laptop. If so it MUST be on the same LAN as the RaspberryPi
* This <server> '''CAN''' be a datacenter machie. If so it MUST be accessible on Internet by the RaspberryPi.
* This <server> '''MUST''' have FFMPEG installed (see point D below)
* It is advised to run this one liner in a <code>screen</code> command on the RaspberryPi

<code> ssh <user>@<server> "[ -d /tmp/capture ] || mkdir /tmp/capture" && \
while true; do rsync -a --files-from=/tmp/capture/out.list /tmp/capture <user>@<server>:/tmp/capture; sleep 1; done</code>

'''What's happening here'''

#<code> ssh </code> Use SSH ...
##<code> <user>@<server> </code> ... to connect to server "server" as user "user"
##<code> "[ -d /tmp/capture ] || mkdir /tmp/capture" </code> ... and create if not exists a folder "/tmp/capture"
#<code> while true; do </code> Run an infinite loop
##<code> rsync </code> Start rsync file synchronisation
###<code> -a </code> (archive mode) Set the right parameters for transfer
###<code> --files-from=/tmp/capture/out.list </code> Use the out.list as a list of file to transfer, which avoids scanning the whole folder
###<code> /tmp/capture </code> (source) Transfer local folder content...
###<code> <user>@<server>:/tmp/capture; </code> (destination) To the server "server"
##<code> sleep 1; </code> Sleep one second
#<code> done </code> Loop end

==== D. Broadcast from server to icecast ====

* You '''MUST''' install some script on <server> to assemble / concatenate the MPEGTS chunks for you.
This PHP streamer is made for that: <code>https://raw.githubusercontent.com/albancrommer/raspistream/master/stream.php</code>
* You '''MUST''' install ffmpeg on <server> with ogg support (see below)
* You '''MUST''' install the oggfwd command line tool with <code>aptitude install oggfwd</code>
* You '''MUST''' have access to an icecast server. If you use a datacenter server, everything can run locally

<code> php /usr/local/bin/stream.php | ffmpeg -i - -f ogg - | oggfwd -p -n "My RaspberryPi Stream" <stream.server.com> 8000 mySecretIceCastStreamingPassword /test </code>

'''What's happening here'''

#<code> php /usr/local/bin/stream.php </code> Start an infinite stream of assembled chunks received via rsync
#<code> | ffmpeg </code> Pipe into FFMPEG
##<code> -i - </code> (input) '''DON'T CHANGE''' Use Standard In as input
##<code> -f ogg </code> (format) '''DON'T CHANGE''' Use ogg as output format
##<code> - </code> (output) '''DON'T CHANGE''' Output to Standard Out
#<code> | oggfwd </code> Pipe into oggfwd
##<code> -p </code> (public) Makes the stream public. Tweak
##<code> -n "My RaspberryPi Stream" </code> (name) Your stream name. Adapt
##<code> <stream.server.com> </code> (address) Your icecast server name. Adapt
##<code> 8000 </code> (port) 8000 is default for icecast. Adapt
##<code> <mySecretIceCastStreamingPassword> </code> (password) The icecast input password Adapt
##<code> /rpi01 </code> (mountpoint) The icecast "mountpoint" ie. the path for your stream

==== E. Get the m3u from icecast ====

With the default parameters provided the stream would be accessed on

<code>http://<stream.server.com>:8000/rpi01.m3u</code>

==== Sources ====

http://sirlagz.net/2013/01/07/how-to-stream-a-webcam-from-the-raspberry-pi-part-3/

=== How to get full video from the small chunks ===

After the streaming you should have chunks both on the RaspberryPi and the server, and could perform the conversion on any of them.

Except that the RaspberryPi is VERY slow and that depending on your budget / stability needs you might not have kept all the chunks on the RaspberryPi.

In other words, make the conversion on the server, be it your laptop or a datacenter server.

==== A. Clean the last file (optional) ====

As our last chunk / fragment might be invalid, it's safer to remove it using :

<code>ls /tmp/capture/*ts|tail -n 1|xargs rm </code>

'''What's happening here'''

This command retrieves a sorted list of all chunks in the capture folder, extracts the last one and deletes it.

==== B. Convert to single file (mp4, webm) ====

It is assumed you have FFMPEG installed on the machine.

It is assumed you want to make minimal changes to your original video input (size, bitrate, etc). Only essential options are provided but you can add more according to your needs, double pass conversion is not included either.

It is recommanded to use a script for files merging, as ffmpeg syntax can be a bit of a mess for that, with little option if you want to use start or end file.

This PHP script is made for that : https://raw.githubusercontent.com/albancrommer/raspistream/master/concat.php

''' Converting to MP4 '''

This operation can be fast as the MPEGTS chunks are ready for MP4

<code>php concat.php <start> <end> | ffmpeg -i - -movflags +faststart -threads 0 -profile:v high -preset slow <myfile>.mp4</code>

'''What's happening here'''

#<code> php concat.php </code> Start concatenation
##<code> <start> </code> (optional) an integer designing the first file to include
##<code> <end> </code>(optional) an integer designing the last file to include
#<code> | ffmpeg </code> Pipe into FFMPEG with following parameters
##<code> -i - </code> (input) '''DON'T CHANGE''' use stdin as input
##<code> -movflags +faststart </code> '''DON'T CHANGE''' Make the file ready for web viewing
##<code> -threads 0 </code> Require all CPU to work on the conversion. Tweak.
##<code> -profile:v high </code> Set the output quality. Tweak.
##<code> -preset slow </code> Set the encoding speed.Tweak.
##<code> <myfile>.mp4 </code> Your output file name. Adapt.

''' Converting to WEBM '''

This operation will be slower as audio and video tracks needs to use new codecs

<code>php concat.php <start> <end> | ffmpeg -i - -codec:a libvorbis -codec:v libvpx -threads 0 -quality good -cpu-used 0 -qmin 10 -qmax 42 <myfile>.webm</code>

'''What's happening here'''

#<code> php concat.php </code> Start concatenation
##<code> <start> </code> (optional) an integer designing the first file to include
##<code> <end> </code>(optional) an integer designing the last file to include
#<code> | ffmpeg </code> Pipe into FFMPEG with following parameters
##<code> -i - </code> (input) '''DON'T CHANGE''' use stdin as input
##<code> -codec:a libvorbis </code> (codec) '''DON'T CHANGE''' Define the audio codec
##<code> -codec:v libvpx </code> (codec) '''DON'T CHANGE''' Define the video codec
##<code> -threads 0 </code> Require all CPU to work on the conversion. Tweak.
##<code> -quality good </code> Set the encoding speed. Tweak
##<code> -cpu-used 1 </code> Set the encoding speed. Tweak
##<code> -qmin 10 -qmax 42 </code> Set the encoding quality. Tweak
##<code> <myfile>.webm </code> Your output file name. Adapt

==== Sources ====

https://www.virag.si/2012/01/web-video-encoding-tutorial-with-ffmpeg-0-9/
https://www.virag.si/2012/01/webm-web-video-encoding-tutorial-with-ffmpeg-0-9/

== Solution 2 : FLVSTR + PHP Streamer ==

'''Basic idea''' Octopuce company has a solution to convert live MP4 to F4V. With an USB audio card, we could mux the MP4 and AAC audio and have a standalone solution not needing any laptop.

'''CON''' authentication not included as of now (only IP address), F4V means Flash, requires an USB disk for local backup. Also, the live stream will need to have the same bitrate as the recorded one.

'''PRO''' the pi can be autonomous (no need for a laptop to encode the live stream)

First, authentication. This problem is adressed by solving encryption as well: we use an SSL socket to communicate with the server. (we could use rsync server mode too).

== Solution 3 : RTSP ==

'''Basic idea''' Use an RTSP stream with VLC and the V4L driver

'''CON''' Non commercial RTSP server are not the norm, requires VLC or Flash player, Quality with v4l is low

'''PRO''' Easy to work out

'''Sources'''

http://www.ics.com/blog/raspberry-pi-camera-module#.VJFhbyvF-b8

http://raspberrypi.stackexchange.com/questions/23182/how-to-stream-video-from-raspberry-pi-camera-and-watch-it-live

http://ffmpeg.gusari.org/viewtopic.php?f=16&t=1130

http://blog.tkjelectronics.dk/2013/06/how-to-stream-video-and-audio-from-a-raspberry-pi-with-no-latency/

== Solution 4 : HLS + RSYNC ==

'''Basic idea''' Use HLS segmentation and rsync

'''CON''' Not all web players can do HLS

'''PRO''' Almost out of the box, robust

'''Howto'''

1. Compile fresh ffmpeg on the pi

2. Run a capture : <code>raspivid -ih -pf baseline -t 0 -b 1000000 -w 1280 -h 720 -v -o - | ffmpeg -i - -f alsa -ac 1 -itsoffset 6.5 -i hw:1 -acodec aac -strict -2 -vcodec copy out.m3u8 </code>

3. Run a cron rsync to server (todo)

4. Connect a client (todo)

'''Sources'''

http://www.ffmpeg.org/ffmpeg-formats.html#hls

= FFMPEG compilation =

This installation is debian based. Some packages are included by default :

* ffmpeg : Provides a large number of the dependencies required at compilation tim
* yasm : modular assembler (good for compilation)
* pkg-config : info about installed libraries (good for compilation)
* screen : helpful for running compilation in background

== For Raspberry ==

For the Raspberry, we only need the support of h264, AAC and ALSA
<pre>
sudo -s
aptitude install screen yasl libx264-dev libasound2-dev libfdk-aac-dev ffmpeg
cd /usr/src
git clone --depth 1 git://source.ffmpeg.org/ffmpeg.git
cd ffmpeg
./configure --enable-gpl --enable-libx264 --enable-libfdk-aac
make
make install
</pre>

== For laptop or server ==

Your default debian might come with sufficent support but if you want total control, compiling is a good idea.

Remove packages and ffmpeg support if you don't need everything.

Ex: to produce ogg format, you only need
* aptitude packages libtheora-dev and libvorbis-dev
* configure options --enable-libtheora --enable-libvorbis

<pre>
sudo
aptitude update && aptitude install screen pkg-config yasm ffmpeg libass-dev libavcodec-extra libfdk-aac-dev libmp3lame-dev libopus-dev libtheora-dev libvorbis-dev libvpx-dev libx264-dev
cd /usr/src
git clone --depth 1 git://source.ffmpeg.org/ffmpeg.git
cd ffmpeg
./configure --enable-gpl --enable-libass --enable-libfdk-aac --enable-libfreetype --enable-libmp3lame --enable-libopus --enable-libtheora --enable-libvorbis --enable-libvpx --enable-libx264 --enable-nonfree --enable-x11grab
make
make install
</pre>

= References =

Here are a number of unsorted links

* http://techzany.com/2013/09/live-streaming-video-using-avconv-and-a-raspberry-pi/
* http://blog.cloudfrancois.fr/category/streaming-video.html

== FFMPEG ==

* http://ffmpeg.org/ffmpeg-all.html#segment_002c-stream_005fsegment_002c-ssegment
* https://trac.ffmpeg.org/wiki/StreamingGuide

== Node ==

* http://phoboslab.org/log/2013/09/html5-live-video-streaming-via-websockets
* https://github.com/phoboslab/jsmpeg
* https://github.com/fluent-ffmpeg/node-fluent-ffmpeg

== Raspberry PI ==

* Raspbian, debian on Raspberry pi http://www.raspbian.org/
* Chose your SD card for your PI : http://elinux.org/RPi_SD_cards

Streaming Video With RaspberryPi

2015-01-17T23:42:27Z

Vincib: /* Solution 2 : FLVSTR + PHP Streamer */

= General =

Caution: this is a Work in progress, things are being tested. The objective is to provide in the end one or more working solutions for everyone.

== Video streaming is a problem ==

The RaspberryPi camera offers an interesting solution to this problem. It is a very well integrated module of the Pi with one huge advantage: h264 encoding can be performed directly by the CPU as the camera uses the Serial Camera Interface protocol.

So theorically, solving the video problem with the Pi is easy but there are many subtle problems.

== Problems ==

'''Audio''' As we use video webstreaming mostly for conferences broadcasting, good audio quality is necessary.

'''Slides''' It would be interesting to include slides of conferences while filming.

'''File''' It is important to have a file at the end of the filming.

'''Web''' It is important to have a large viewer base, therefore a well supported format.

== Raspicam basics ==

http://elinux.org/Rpi_Camera_Module

raspivid is the basic command line used to capture video in h264.

<code>raspivid -t 3 -fps 25 -b 1000000 -w 1920 -h 1080 -o /tmp/video.h264</code>

A very simple tutorial : http://www.raspberrypi-spy.co.uk/2013/05/capturing-hd-video-with-the-pi-camera-module/

= Solution =

== Solution 1 : OGG/VORBIS + Icecast ==

'''Basic idea'''

# Use the PI to capture video as h264, merge audio from usb and use ffmpeg to produce MPEGTS "chunks"
# Rsync the chunks to a laptop or a server (note : the audio mix should be integrated here to ensure a good audio/video synchronization)
# Assemble the chunks and pipe them in ffmpeg
# Ask ffmpeg to convert this into ogg
# Use oggfwd to push the ogg to your icecast server
# Serve m3u from the server

'''CON''' ogg does not work for everyone. It is supposed to be HTML5 compatible but icecast doesn't offer that by default.

'''PRO''' Icecast is simple, open, and handles authentification. Rsync using SSH is crypto friendly. The file is saved on the server.

=== How to stream in OGG to Icecast ===

==== A. Compile FFMPEG on pi & server (see below) ====

==== B. Start capture in a screen ====

It is advised to run this one liner in a <code>screen</code> command on the RaspberryPi

<code>[ -d /tmp/capture ] || mkdir /tmp/capture; rm -f /tmp/capture/* && cd /tmp/capture/ && \
raspivid -ih -t 0 -w 1280 -h 720 -b 1000000 -pf baseline -o - | /usr/local/bin/ffmpeg -f alsa -itsoffset 6.5 -ac 1 -i hw:1 -acodec aac -strict -2 \
-i - -vcodec copy -f segment -segment_list out.list -segment_list_flags +live -segment_list_size 5 -segment_time 4 -segment_time_delta 3 %10d.ts</code>

'''What's happening here'''

#<code>[ -d /tmp/capture ] || mkdir /tmp/capture; rm -f /tmp/capture/* && cd /tmp/capture/</code> We create a /tmp/capture folder and make sure it's empty when starting capture in it
#<code> raspivid </code> Use raspivid to capturing with following parameters:
##<code> -ih </code>(inline headers) '''DONT CHANGE''' Necessary for technical reasons, as otherwise the "chunking" doesn't work
##<code> -t 0 </code> (timeout) '''DONT CHANGE''' Necessary for technical reasons, as otherwise capture stops after 5s
##<code> -w 1080 -h 720 </code> (height) and (width) Tweak according to your needs
##<code> -b 1000000 </code> (bitrate) Tweak according to your needs (only integer numbers in bits are accepted, here <=> 1Mb)
##<code> -pf baseline </code> (h264 profile) Tweak according to your needs ( only baseline, main, or high accepted)
##<code> -o - </code> (output) '''DONT CHANGE''' Necessary in order to use the flux as Standard Output
# We pipe the content into ffmpeg with following parameters:
## ALSA Input
###<code> -f alsa </code> (format) We use <code>alsa</code> for usb audio capture
###<code> -itsoffset 6.5 </code> (time offset) '''This one is a trick''' We noticed our RPi B+ had a 6.5 seconds delay to start the audio, so this is used to resync audio. Tweak.
###<code> -ac 1 </code> (number of audio channels) We used a mono input, so <code>1</code> was the right choice. Tweak
###<code> -i hw:1 </code> (input) '''Tweak''' as your audio card adress may vary. Find more with <code>arecord -l</code>
###<code> -acodec aac </code> (audio codec) AAC works well for TS live.
###<code> -strict -2 </code> Argument mandatory for AAC format
## Video Input
###<code> -i - </code> (input) '''DONT CHANGE''' Use the Standard input
###<code> -vcodec copy</code> (video codec) '''DONT CHANGE''' Use the video codec from the RPi. Not enough CPU to do anything else.
###<code> -f segment </code> (output format) '''DONT CHANGE''' Use a "chunked" output
###<code> -segment_list out.list </code> (segment file) Defines a file containing the produced files names
###<code> -segment_list_flags +live </code> (segment file flags) Defines the way the output file caches files names.
###<code> -segment_list_size 5 </code> (segment file size)
###<code> -segment_time 4 </code> (segment time) Defines the capture base duration in seconds. Tweak.
###<code> -segment_time_delta 3 </code> (segment time delta) Defines a window to modulate chunks duration in seconds to include mandatory inline headers. Tweak.
###<code> %10d.ts </code> The format for chunks files names. %10d will start at 0000000000.ts and ffmpeg understand we want MPEGTS format for chunks
# ffmpeg saves the files 0000.ts, 0001.ts, etc. and out.list in /tmp/capture

==== C. Use rsync to infinitely synchronise chunks on server ====

'''Some important points to mention here '''

* The RaspberryPi '''MUST''' have access to a <server> using an SSH KEY for an <user>. Password access won't work for infinite rsync.
* This <server> '''CAN''' be your laptop. If so it MUST be on the same LAN as the RaspberryPi
* This <server> '''CAN''' be a datacenter machie. If so it MUST be accessible on Internet by the RaspberryPi.
* This <server> '''MUST''' have FFMPEG installed (see point D below)
* It is advised to run this one liner in a <code>screen</code> command on the RaspberryPi

<code> ssh <user>@<server> "[ -d /tmp/capture ] || mkdir /tmp/capture" && \
while true; do rsync -a --files-from=/tmp/capture/out.list /tmp/capture <user>@<server>:/tmp/capture; sleep 1; done</code>

'''What's happening here'''

#<code> ssh </code> Use SSH ...
##<code> <user>@<server> </code> ... to connect to server "server" as user "user"
##<code> "[ -d /tmp/capture ] || mkdir /tmp/capture" </code> ... and create if not exists a folder "/tmp/capture"
#<code> while true; do </code> Run an infinite loop
##<code> rsync </code> Start rsync file synchronisation
###<code> -a </code> (archive mode) Set the right parameters for transfer
###<code> --files-from=/tmp/capture/out.list </code> Use the out.list as a list of file to transfer, which avoids scanning the whole folder
###<code> /tmp/capture </code> (source) Transfer local folder content...
###<code> <user>@<server>:/tmp/capture; </code> (destination) To the server "server"
##<code> sleep 1; </code> Sleep one second
#<code> done </code> Loop end

==== D. Broadcast from server to icecast ====

* You '''MUST''' install some script on <server> to assemble / concatenate the MPEGTS chunks for you.
This PHP streamer is made for that: <code>https://raw.githubusercontent.com/albancrommer/raspistream/master/stream.php</code>
* You '''MUST''' install ffmpeg on <server> with ogg support (see below)
* You '''MUST''' install the oggfwd command line tool with <code>aptitude install oggfwd</code>
* You '''MUST''' have access to an icecast server. If you use a datacenter server, everything can run locally

<code> php /usr/local/bin/stream.php | ffmpeg -i - -f ogg - | oggfwd -p -n "My RaspberryPi Stream" <stream.server.com> 8000 mySecretIceCastStreamingPassword /test </code>

'''What's happening here'''

#<code> php /usr/local/bin/stream.php </code> Start an infinite stream of assembled chunks received via rsync
#<code> | ffmpeg </code> Pipe into FFMPEG
##<code> -i - </code> (input) '''DON'T CHANGE''' Use Standard In as input
##<code> -f ogg </code> (format) '''DON'T CHANGE''' Use ogg as output format
##<code> - </code> (output) '''DON'T CHANGE''' Output to Standard Out
#<code> | oggfwd </code> Pipe into oggfwd
##<code> -p </code> (public) Makes the stream public. Tweak
##<code> -n "My RaspberryPi Stream" </code> (name) Your stream name. Adapt
##<code> <stream.server.com> </code> (address) Your icecast server name. Adapt
##<code> 8000 </code> (port) 8000 is default for icecast. Adapt
##<code> <mySecretIceCastStreamingPassword> </code> (password) The icecast input password Adapt
##<code> /rpi01 </code> (mountpoint) The icecast "mountpoint" ie. the path for your stream

==== E. Get the m3u from icecast ====

With the default parameters provided the stream would be accessed on

<code>http://<stream.server.com>:8000/rpi01.m3u</code>

==== Sources ====

http://sirlagz.net/2013/01/07/how-to-stream-a-webcam-from-the-raspberry-pi-part-3/

=== How to get full video from the small chunks ===

After the streaming you should have chunks both on the RaspberryPi and the server, and could perform the conversion on any of them.

Except that the RaspberryPi is VERY slow and that depending on your budget / stability needs you might not have kept all the chunks on the RaspberryPi.

In other words, make the conversion on the server, be it your laptop or a datacenter server.

==== A. Clean the last file (optional) ====

As our last chunk / fragment might be invalid, it's safer to remove it using :

<code>ls /tmp/capture/*ts|tail -n 1|xargs rm </code>

'''What's happening here'''

This command retrieves a sorted list of all chunks in the capture folder, extracts the last one and deletes it.

==== B. Convert to single file (mp4, webm) ====

It is assumed you have FFMPEG installed on the machine.

It is assumed you want to make minimal changes to your original video input (size, bitrate, etc). Only essential options are provided but you can add more according to your needs, double pass conversion is not included either.

It is recommanded to use a script for files merging, as ffmpeg syntax can be a bit of a mess for that, with little option if you want to use start or end file.

This PHP script is made for that : https://raw.githubusercontent.com/albancrommer/raspistream/master/concat.php

''' Converting to MP4 '''

This operation can be fast as the MPEGTS chunks are ready for MP4

<code>php concat.php <start> <end> | ffmpeg -i - -movflags +faststart -threads 0 -profile:v high -preset slow <myfile>.mp4</code>

'''What's happening here'''

#<code> php concat.php </code> Start concatenation
##<code> <start> </code> (optional) an integer designing the first file to include
##<code> <end> </code>(optional) an integer designing the last file to include
#<code> | ffmpeg </code> Pipe into FFMPEG with following parameters
##<code> -i - </code> (input) '''DON'T CHANGE''' use stdin as input
##<code> -movflags +faststart </code> '''DON'T CHANGE''' Make the file ready for web viewing
##<code> -threads 0 </code> Require all CPU to work on the conversion. Tweak.
##<code> -profile:v high </code> Set the output quality. Tweak.
##<code> -preset slow </code> Set the encoding speed.Tweak.
##<code> <myfile>.mp4 </code> Your output file name. Adapt.

''' Converting to WEBM '''

This operation will be slower as audio and video tracks needs to use new codecs

<code>php concat.php <start> <end> | ffmpeg -i - -codec:a libvorbis -codec:v libvpx -threads 0 -quality good -cpu-used 0 -qmin 10 -qmax 42 <myfile>.webm</code>

'''What's happening here'''

#<code> php concat.php </code> Start concatenation
##<code> <start> </code> (optional) an integer designing the first file to include
##<code> <end> </code>(optional) an integer designing the last file to include
#<code> | ffmpeg </code> Pipe into FFMPEG with following parameters
##<code> -i - </code> (input) '''DON'T CHANGE''' use stdin as input
##<code> -codec:a libvorbis </code> (codec) '''DON'T CHANGE''' Define the audio codec
##<code> -codec:v libvpx </code> (codec) '''DON'T CHANGE''' Define the video codec
##<code> -threads 0 </code> Require all CPU to work on the conversion. Tweak.
##<code> -quality good </code> Set the encoding speed. Tweak
##<code> -cpu-used 1 </code> Set the encoding speed. Tweak
##<code> -qmin 10 -qmax 42 </code> Set the encoding quality. Tweak
##<code> <myfile>.webm </code> Your output file name. Adapt

==== Sources ====

https://www.virag.si/2012/01/web-video-encoding-tutorial-with-ffmpeg-0-9/
https://www.virag.si/2012/01/webm-web-video-encoding-tutorial-with-ffmpeg-0-9/

== Solution 2 : FLVSTR + PHP Streamer ==

'''Basic idea''' Octopuce company has a solution to convert live MP4 to F4V. With an USB audio card, we could mux the MP4 and AAC audio and have a standalone solution not needing any laptop.

'''CON''' authentication not included as of now (only IP address), F4V means Flash, requires an USB disk for local backup. Also, the live stream will need to have the same bitrate as the recorded one.

'''PRO''' the pi can be autonomous (no need for a laptop to encode the live stream)

First, authentication. This problem is adressed by solving encryption as well: we use an SSL socket to communicate with the server. (we could use rsync server mode too).

== Solution 3 : RTSP ==

'''Basic idea''' Use an RTSP stream with VLC and the V4L driver

'''CON''' Non commercial RTSP server are not the norm, requires VLC or Flash player, Quality with v4l is low

'''PRO''' Easy to work out

'''Sources'''

http://www.ics.com/blog/raspberry-pi-camera-module#.VJFhbyvF-b8

http://raspberrypi.stackexchange.com/questions/23182/how-to-stream-video-from-raspberry-pi-camera-and-watch-it-live

http://ffmpeg.gusari.org/viewtopic.php?f=16&t=1130

http://blog.tkjelectronics.dk/2013/06/how-to-stream-video-and-audio-from-a-raspberry-pi-with-no-latency/

== Solution 4 : HLS + RSYNC ==

'''Basic idea''' Use HLS segmentation and rsync

'''CON''' Not all web players can do HLS

'''PRO''' Almost out of the box, robust

'''Howto'''

1. Compile fresh ffmpeg on the pi

2. Run a capture : <code>raspivid -ih -pf baseline -t 0 -b 1000000 -w 1280 -h 720 -v -o - | ffmpeg -i - -f alsa -ac 1 -itsoffset 6.5 -i hw:1 -acodec aac -strict -2 -vcodec copy out.m3u8 </code>

3. Run a cron rsync to server (todo)

4. Connect a client (todo)

'''Sources'''

http://www.ffmpeg.org/ffmpeg-formats.html#hls

= FFMPEG compilation =

This installation is debian based. Some packages are included by default :

* ffmpeg : Provides a large number of the dependencies required at compilation tim
* yasm : modular assembler (good for compilation)
* pkg-config : info about installed libraries (good for compilation)
* screen : helpful for running compilation in background

== For Raspberry ==

For the Raspberry, we only need the support of h264, AAC and ALSA
<pre>
sudo -s
aptitude install screen yasl libx264-dev libasound2-dev libfdk-aac-dev ffmpeg
cd /usr/src
git clone --depth 1 git://source.ffmpeg.org/ffmpeg.git
cd ffmpeg
./configure --enable-gpl --enable-libx264 --enable-libfdk-aac
make
make install
</pre>

== For laptop or server ==

Your default debian might come with sufficent support but if you want total control, compiling is a good idea.

Remove packages and ffmpeg support if you don't need everything.

Ex: to produce ogg format, you only need
* aptitude packages libtheora-dev and libvorbis-dev
* configure options --enable-libtheora --enable-libvorbis

<pre>
sudo
aptitude update && aptitude install screen pkg-config yasm ffmpeg libass-dev libavcodec-extra libfdk-aac-dev libmp3lame-dev libopus-dev libtheora-dev libvorbis-dev libvpx-dev libx264-dev
cd /usr/src
git clone --depth 1 git://source.ffmpeg.org/ffmpeg.git
cd ffmpeg
./configure --enable-gpl --enable-libass --enable-libfdk-aac --enable-libfreetype --enable-libmp3lame --enable-libopus --enable-libtheora --enable-libvorbis --enable-libvpx --enable-libx264 --enable-nonfree --enable-x11grab
make
make install
</pre>

= References =

Here are a number of unsorted links

* http://techzany.com/2013/09/live-streaming-video-using-avconv-and-a-raspberry-pi/
* http://blog.cloudfrancois.fr/category/streaming-video.html

== FFMPEG ==

* http://ffmpeg.org/ffmpeg-all.html#segment_002c-stream_005fsegment_002c-ssegment
* https://trac.ffmpeg.org/wiki/StreamingGuide

== Node ==

* http://phoboslab.org/log/2013/09/html5-live-video-streaming-via-websockets
* https://github.com/phoboslab/jsmpeg
* https://github.com/fluent-ffmpeg/node-fluent-ffmpeg

== Raspberry PI ==

* Raspbian, debian on Raspberry pi http://www.raspbian.org/
* Chose your SD card for your PI : http://elinux.org/RPi_SD_cards

Streaming Video With RaspberryPi

2015-01-17T23:38:15Z

Vincib: /* Solution 1 : OGG/VORBIS + Icecast */

= General =

Caution: this is a Work in progress, things are being tested. The objective is to provide in the end one or more working solutions for everyone.

== Video streaming is a problem ==

The RaspberryPi camera offers an interesting solution to this problem. It is a very well integrated module of the Pi with one huge advantage: h264 encoding can be performed directly by the CPU as the camera uses the Serial Camera Interface protocol.

So theorically, solving the video problem with the Pi is easy but there are many subtle problems.

== Problems ==

'''Audio''' As we use video webstreaming mostly for conferences broadcasting, good audio quality is necessary.

'''Slides''' It would be interesting to include slides of conferences while filming.

'''File''' It is important to have a file at the end of the filming.

'''Web''' It is important to have a large viewer base, therefore a well supported format.

== Raspicam basics ==

http://elinux.org/Rpi_Camera_Module

raspivid is the basic command line used to capture video in h264.

<code>raspivid -t 3 -fps 25 -b 1000000 -w 1920 -h 1080 -o /tmp/video.h264</code>

A very simple tutorial : http://www.raspberrypi-spy.co.uk/2013/05/capturing-hd-video-with-the-pi-camera-module/

= Solution =

== Solution 1 : OGG/VORBIS + Icecast ==

'''Basic idea'''

# Use the PI to capture video as h264, merge audio from usb and use ffmpeg to produce MPEGTS "chunks"
# Rsync the chunks to a laptop or a server (note : the audio mix should be integrated here to ensure a good audio/video synchronization)
# Assemble the chunks and pipe them in ffmpeg
# Ask ffmpeg to convert this into ogg
# Use oggfwd to push the ogg to your icecast server
# Serve m3u from the server

'''CON''' ogg does not work for everyone. It is supposed to be HTML5 compatible but icecast doesn't offer that by default.

'''PRO''' Icecast is simple, open, and handles authentification. Rsync using SSH is crypto friendly. The file is saved on the server.

=== How to stream in OGG to Icecast ===

==== A. Compile FFMPEG on pi & server (see below) ====

==== B. Start capture in a screen ====

It is advised to run this one liner in a <code>screen</code> command on the RaspberryPi

<code>[ -d /tmp/capture ] || mkdir /tmp/capture; rm -f /tmp/capture/* && cd /tmp/capture/ && \
raspivid -ih -t 0 -w 1280 -h 720 -b 1000000 -pf baseline -o - | /usr/local/bin/ffmpeg -f alsa -itsoffset 6.5 -ac 1 -i hw:1 -acodec aac -strict -2 \
-i - -vcodec copy -f segment -segment_list out.list -segment_list_flags +live -segment_list_size 5 -segment_time 4 -segment_time_delta 3 %10d.ts</code>

'''What's happening here'''

#<code>[ -d /tmp/capture ] || mkdir /tmp/capture; rm -f /tmp/capture/* && cd /tmp/capture/</code> We create a /tmp/capture folder and make sure it's empty when starting capture in it
#<code> raspivid </code> Use raspivid to capturing with following parameters:
##<code> -ih </code>(inline headers) '''DONT CHANGE''' Necessary for technical reasons, as otherwise the "chunking" doesn't work
##<code> -t 0 </code> (timeout) '''DONT CHANGE''' Necessary for technical reasons, as otherwise capture stops after 5s
##<code> -w 1080 -h 720 </code> (height) and (width) Tweak according to your needs
##<code> -b 1000000 </code> (bitrate) Tweak according to your needs (only integer numbers in bits are accepted, here <=> 1Mb)
##<code> -pf baseline </code> (h264 profile) Tweak according to your needs ( only baseline, main, or high accepted)
##<code> -o - </code> (output) '''DONT CHANGE''' Necessary in order to use the flux as Standard Output
# We pipe the content into ffmpeg with following parameters:
## ALSA Input
###<code> -f alsa </code> (format) We use <code>alsa</code> for usb audio capture
###<code> -itsoffset 6.5 </code> (time offset) '''This one is a trick''' We noticed our RPi B+ had a 6.5 seconds delay to start the audio, so this is used to resync audio. Tweak.
###<code> -ac 1 </code> (number of audio channels) We used a mono input, so <code>1</code> was the right choice. Tweak
###<code> -i hw:1 </code> (input) '''Tweak''' as your audio card adress may vary. Find more with <code>arecord -l</code>
###<code> -acodec aac </code> (audio codec) AAC works well for TS live.
###<code> -strict -2 </code> Argument mandatory for AAC format
## Video Input
###<code> -i - </code> (input) '''DONT CHANGE''' Use the Standard input
###<code> -vcodec copy</code> (video codec) '''DONT CHANGE''' Use the video codec from the RPi. Not enough CPU to do anything else.
###<code> -f segment </code> (output format) '''DONT CHANGE''' Use a "chunked" output
###<code> -segment_list out.list </code> (segment file) Defines a file containing the produced files names
###<code> -segment_list_flags +live </code> (segment file flags) Defines the way the output file caches files names.
###<code> -segment_list_size 5 </code> (segment file size)
###<code> -segment_time 4 </code> (segment time) Defines the capture base duration in seconds. Tweak.
###<code> -segment_time_delta 3 </code> (segment time delta) Defines a window to modulate chunks duration in seconds to include mandatory inline headers. Tweak.
###<code> %10d.ts </code> The format for chunks files names. %10d will start at 0000000000.ts and ffmpeg understand we want MPEGTS format for chunks
# ffmpeg saves the files 0000.ts, 0001.ts, etc. and out.list in /tmp/capture

==== C. Use rsync to infinitely synchronise chunks on server ====

'''Some important points to mention here '''

* The RaspberryPi '''MUST''' have access to a <server> using an SSH KEY for an <user>. Password access won't work for infinite rsync.
* This <server> '''CAN''' be your laptop. If so it MUST be on the same LAN as the RaspberryPi
* This <server> '''CAN''' be a datacenter machie. If so it MUST be accessible on Internet by the RaspberryPi.
* This <server> '''MUST''' have FFMPEG installed (see point D below)
* It is advised to run this one liner in a <code>screen</code> command on the RaspberryPi

<code> ssh <user>@<server> "[ -d /tmp/capture ] || mkdir /tmp/capture" && \
while true; do rsync -a --files-from=/tmp/capture/out.list /tmp/capture <user>@<server>:/tmp/capture; sleep 1; done</code>

'''What's happening here'''

#<code> ssh </code> Use SSH ...
##<code> <user>@<server> </code> ... to connect to server "server" as user "user"
##<code> "[ -d /tmp/capture ] || mkdir /tmp/capture" </code> ... and create if not exists a folder "/tmp/capture"
#<code> while true; do </code> Run an infinite loop
##<code> rsync </code> Start rsync file synchronisation
###<code> -a </code> (archive mode) Set the right parameters for transfer
###<code> --files-from=/tmp/capture/out.list </code> Use the out.list as a list of file to transfer, which avoids scanning the whole folder
###<code> /tmp/capture </code> (source) Transfer local folder content...
###<code> <user>@<server>:/tmp/capture; </code> (destination) To the server "server"
##<code> sleep 1; </code> Sleep one second
#<code> done </code> Loop end

==== D. Broadcast from server to icecast ====

* You '''MUST''' install some script on <server> to assemble / concatenate the MPEGTS chunks for you.
This PHP streamer is made for that: <code>https://raw.githubusercontent.com/albancrommer/raspistream/master/stream.php</code>
* You '''MUST''' install ffmpeg on <server> with ogg support (see below)
* You '''MUST''' install the oggfwd command line tool with <code>aptitude install oggfwd</code>
* You '''MUST''' have access to an icecast server. If you use a datacenter server, everything can run locally

<code> php /usr/local/bin/stream.php | ffmpeg -i - -f ogg - | oggfwd -p -n "My RaspberryPi Stream" <stream.server.com> 8000 mySecretIceCastStreamingPassword /test </code>

'''What's happening here'''

#<code> php /usr/local/bin/stream.php </code> Start an infinite stream of assembled chunks received via rsync
#<code> | ffmpeg </code> Pipe into FFMPEG
##<code> -i - </code> (input) '''DON'T CHANGE''' Use Standard In as input
##<code> -f ogg </code> (format) '''DON'T CHANGE''' Use ogg as output format
##<code> - </code> (output) '''DON'T CHANGE''' Output to Standard Out
#<code> | oggfwd </code> Pipe into oggfwd
##<code> -p </code> (public) Makes the stream public. Tweak
##<code> -n "My RaspberryPi Stream" </code> (name) Your stream name. Adapt
##<code> <stream.server.com> </code> (address) Your icecast server name. Adapt
##<code> 8000 </code> (port) 8000 is default for icecast. Adapt
##<code> <mySecretIceCastStreamingPassword> </code> (password) The icecast input password Adapt
##<code> /rpi01 </code> (mountpoint) The icecast "mountpoint" ie. the path for your stream

==== E. Get the m3u from icecast ====

With the default parameters provided the stream would be accessed on

<code>http://<stream.server.com>:8000/rpi01.m3u</code>

==== Sources ====

http://sirlagz.net/2013/01/07/how-to-stream-a-webcam-from-the-raspberry-pi-part-3/

=== How to get full video from the small chunks ===

After the streaming you should have chunks both on the RaspberryPi and the server, and could perform the conversion on any of them.

Except that the RaspberryPi is VERY slow and that depending on your budget / stability needs you might not have kept all the chunks on the RaspberryPi.

In other words, make the conversion on the server, be it your laptop or a datacenter server.

==== A. Clean the last file (optional) ====

As our last chunk / fragment might be invalid, it's safer to remove it using :

<code>ls /tmp/capture/*ts|tail -n 1|xargs rm </code>

'''What's happening here'''

This command retrieves a sorted list of all chunks in the capture folder, extracts the last one and deletes it.

==== B. Convert to single file (mp4, webm) ====

It is assumed you have FFMPEG installed on the machine.

It is assumed you want to make minimal changes to your original video input (size, bitrate, etc). Only essential options are provided but you can add more according to your needs, double pass conversion is not included either.

It is recommanded to use a script for files merging, as ffmpeg syntax can be a bit of a mess for that, with little option if you want to use start or end file.

This PHP script is made for that : https://raw.githubusercontent.com/albancrommer/raspistream/master/concat.php

''' Converting to MP4 '''

This operation can be fast as the MPEGTS chunks are ready for MP4

<code>php concat.php <start> <end> | ffmpeg -i - -movflags +faststart -threads 0 -profile:v high -preset slow <myfile>.mp4</code>

'''What's happening here'''

#<code> php concat.php </code> Start concatenation
##<code> <start> </code> (optional) an integer designing the first file to include
##<code> <end> </code>(optional) an integer designing the last file to include
#<code> | ffmpeg </code> Pipe into FFMPEG with following parameters
##<code> -i - </code> (input) '''DON'T CHANGE''' use stdin as input
##<code> -movflags +faststart </code> '''DON'T CHANGE''' Make the file ready for web viewing
##<code> -threads 0 </code> Require all CPU to work on the conversion. Tweak.
##<code> -profile:v high </code> Set the output quality. Tweak.
##<code> -preset slow </code> Set the encoding speed.Tweak.
##<code> <myfile>.mp4 </code> Your output file name. Adapt.

''' Converting to WEBM '''

This operation will be slower as audio and video tracks needs to use new codecs

<code>php concat.php <start> <end> | ffmpeg -i - -codec:a libvorbis -codec:v libvpx -threads 0 -quality good -cpu-used 0 -qmin 10 -qmax 42 <myfile>.webm</code>

'''What's happening here'''

#<code> php concat.php </code> Start concatenation
##<code> <start> </code> (optional) an integer designing the first file to include
##<code> <end> </code>(optional) an integer designing the last file to include
#<code> | ffmpeg </code> Pipe into FFMPEG with following parameters
##<code> -i - </code> (input) '''DON'T CHANGE''' use stdin as input
##<code> -codec:a libvorbis </code> (codec) '''DON'T CHANGE''' Define the audio codec
##<code> -codec:v libvpx </code> (codec) '''DON'T CHANGE''' Define the video codec
##<code> -threads 0 </code> Require all CPU to work on the conversion. Tweak.
##<code> -quality good </code> Set the encoding speed. Tweak
##<code> -cpu-used 1 </code> Set the encoding speed. Tweak
##<code> -qmin 10 -qmax 42 </code> Set the encoding quality. Tweak
##<code> <myfile>.webm </code> Your output file name. Adapt

==== Sources ====

https://www.virag.si/2012/01/web-video-encoding-tutorial-with-ffmpeg-0-9/
https://www.virag.si/2012/01/webm-web-video-encoding-tutorial-with-ffmpeg-0-9/

== Solution 2 : FLVSTR + PHP Streamer ==

'''Basic idea''' the Octopuce company has a solution to convert live MP4 to F4V. With an USB audio card, we could mux the MP4 and AAC audio and have a standalone solution.

'''CON''' authentification is hard, F4V means Flash, requires an USB disk for local backup

'''PRO''' the pi can be autonomous

First, authentification. This problem is adressed by solving encryption as well: we use an SSL socket to communicate with the server.

== Solution 3 : RTSP ==

'''Basic idea''' Use an RTSP stream with VLC and the V4L driver

'''CON''' Non commercial RTSP server are not the norm, requires VLC or Flash player, Quality with v4l is low

'''PRO''' Easy to work out

'''Sources'''

http://www.ics.com/blog/raspberry-pi-camera-module#.VJFhbyvF-b8

http://raspberrypi.stackexchange.com/questions/23182/how-to-stream-video-from-raspberry-pi-camera-and-watch-it-live

http://ffmpeg.gusari.org/viewtopic.php?f=16&t=1130

http://blog.tkjelectronics.dk/2013/06/how-to-stream-video-and-audio-from-a-raspberry-pi-with-no-latency/

== Solution 4 : HLS + RSYNC ==

'''Basic idea''' Use HLS segmentation and rsync

'''CON''' Not all web players can do HLS

'''PRO''' Almost out of the box, robust

'''Howto'''

1. Compile fresh ffmpeg on the pi

2. Run a capture : <code>raspivid -ih -pf baseline -t 0 -b 1000000 -w 1280 -h 720 -v -o - | ffmpeg -i - -f alsa -ac 1 -itsoffset 6.5 -i hw:1 -acodec aac -strict -2 -vcodec copy out.m3u8 </code>

3. Run a cron rsync to server (todo)

4. Connect a client (todo)

'''Sources'''

http://www.ffmpeg.org/ffmpeg-formats.html#hls

= FFMPEG compilation =

This installation is debian based. Some packages are included by default :

* ffmpeg : Provides a large number of the dependencies required at compilation tim
* yasm : modular assembler (good for compilation)
* pkg-config : info about installed libraries (good for compilation)
* screen : helpful for running compilation in background

== For Raspberry ==

For the Raspberry, we only need the support of h264, AAC and ALSA
<pre>
sudo -s
aptitude install screen yasl libx264-dev libasound2-dev libfdk-aac-dev ffmpeg
cd /usr/src
git clone --depth 1 git://source.ffmpeg.org/ffmpeg.git
cd ffmpeg
./configure --enable-gpl --enable-libx264 --enable-libfdk-aac
make
make install
</pre>

== For laptop or server ==

Your default debian might come with sufficent support but if you want total control, compiling is a good idea.

Remove packages and ffmpeg support if you don't need everything.

Ex: to produce ogg format, you only need
* aptitude packages libtheora-dev and libvorbis-dev
* configure options --enable-libtheora --enable-libvorbis

<pre>
sudo
aptitude update && aptitude install screen pkg-config yasm ffmpeg libass-dev libavcodec-extra libfdk-aac-dev libmp3lame-dev libopus-dev libtheora-dev libvorbis-dev libvpx-dev libx264-dev
cd /usr/src
git clone --depth 1 git://source.ffmpeg.org/ffmpeg.git
cd ffmpeg
./configure --enable-gpl --enable-libass --enable-libfdk-aac --enable-libfreetype --enable-libmp3lame --enable-libopus --enable-libtheora --enable-libvorbis --enable-libvpx --enable-libx264 --enable-nonfree --enable-x11grab
make
make install
</pre>

= References =

Here are a number of unsorted links

* http://techzany.com/2013/09/live-streaming-video-using-avconv-and-a-raspberry-pi/
* http://blog.cloudfrancois.fr/category/streaming-video.html

== FFMPEG ==

* http://ffmpeg.org/ffmpeg-all.html#segment_002c-stream_005fsegment_002c-ssegment
* https://trac.ffmpeg.org/wiki/StreamingGuide

== Node ==

* http://phoboslab.org/log/2013/09/html5-live-video-streaming-via-websockets
* https://github.com/phoboslab/jsmpeg
* https://github.com/fluent-ffmpeg/node-fluent-ffmpeg

== Raspberry PI ==

* Raspbian, debian on Raspberry pi http://www.raspbian.org/
* Chose your SD card for your PI : http://elinux.org/RPi_SD_cards

Streaming Video With RaspberryPi

2015-01-17T23:37:33Z

Vincib: /* References */

= General =

Caution: this is a Work in progress, things are being tested. The objective is to provide in the end one or more working solutions for everyone.

== Video streaming is a problem ==

The RaspberryPi camera offers an interesting solution to this problem. It is a very well integrated module of the Pi with one huge advantage: h264 encoding can be performed directly by the CPU as the camera uses the Serial Camera Interface protocol.

So theorically, solving the video problem with the Pi is easy but there are many subtle problems.

== Problems ==

'''Audio''' As we use video webstreaming mostly for conferences broadcasting, good audio quality is necessary.

'''Slides''' It would be interesting to include slides of conferences while filming.

'''File''' It is important to have a file at the end of the filming.

'''Web''' It is important to have a large viewer base, therefore a well supported format.

== Raspicam basics ==

http://elinux.org/Rpi_Camera_Module

raspivid is the basic command line used to capture video in h264.

<code>raspivid -t 3 -fps 25 -b 1000000 -w 1920 -h 1080 -o /tmp/video.h264</code>

A very simple tutorial : http://www.raspberrypi-spy.co.uk/2013/05/capturing-hd-video-with-the-pi-camera-module/

= Solution =

== Solution 1 : OGG/VORBIS + Icecast ==

'''Basic idea'''

# Use the PI to capture video as h264, merge audio from usb and use ffmpeg to produce MPEGTS "chunks"
# Rsync the chunks to a laptop or a server (note : the audio mix can be done on the laptop)
# Assemble the chunks and pipe them in ffmpeg
# Ask ffmpeg to convert this into ogg
# Use oggfwd to push the ogg to your icecast server
# Serve m3u from the server

'''CON''' ogg does not work for everyone. It is supposed to be HTML5 compatible but icecast doesn't offer that by default.

'''PRO''' Icecast is simple, open, and handles authentification. Rsync using SSH is crypto friendly. The file is saved on the server.

=== How to stream in OGG to Icecast ===

==== A. Compile FFMPEG on pi & server (see below) ====

==== B. Start capture in a screen ====

It is advised to run this one liner in a <code>screen</code> command on the RaspberryPi

<code>[ -d /tmp/capture ] || mkdir /tmp/capture; rm -f /tmp/capture/* && cd /tmp/capture/ && \
raspivid -ih -t 0 -w 1280 -h 720 -b 1000000 -pf baseline -o - | /usr/local/bin/ffmpeg -f alsa -itsoffset 6.5 -ac 1 -i hw:1 -acodec aac -strict -2 \
-i - -vcodec copy -f segment -segment_list out.list -segment_list_flags +live -segment_list_size 5 -segment_time 4 -segment_time_delta 3 %10d.ts</code>

'''What's happening here'''

#<code>[ -d /tmp/capture ] || mkdir /tmp/capture; rm -f /tmp/capture/* && cd /tmp/capture/</code> We create a /tmp/capture folder and make sure it's empty when starting capture in it
#<code> raspivid </code> Use raspivid to capturing with following parameters:
##<code> -ih </code>(inline headers) '''DONT CHANGE''' Necessary for technical reasons, as otherwise the "chunking" doesn't work
##<code> -t 0 </code> (timeout) '''DONT CHANGE''' Necessary for technical reasons, as otherwise capture stops after 5s
##<code> -w 1080 -h 720 </code> (height) and (width) Tweak according to your needs
##<code> -b 1000000 </code> (bitrate) Tweak according to your needs (only integer numbers in bits are accepted, here <=> 1Mb)
##<code> -pf baseline </code> (h264 profile) Tweak according to your needs ( only baseline, main, or high accepted)
##<code> -o - </code> (output) '''DONT CHANGE''' Necessary in order to use the flux as Standard Output
# We pipe the content into ffmpeg with following parameters:
## ALSA Input
###<code> -f alsa </code> (format) We use <code>alsa</code> for usb audio capture
###<code> -itsoffset 6.5 </code> (time offset) '''This one is a trick''' We noticed our RPi B+ had a 6.5 seconds delay to start the audio, so this is used to resync audio. Tweak.
###<code> -ac 1 </code> (number of audio channels) We used a mono input, so <code>1</code> was the right choice. Tweak
###<code> -i hw:1 </code> (input) '''Tweak''' as your audio card adress may vary. Find more with <code>arecord -l</code>
###<code> -acodec aac </code> (audio codec) AAC works well for TS live.
###<code> -strict -2 </code> Argument mandatory for AAC format
## Video Input
###<code> -i - </code> (input) '''DONT CHANGE''' Use the Standard input
###<code> -vcodec copy</code> (video codec) '''DONT CHANGE''' Use the video codec from the RPi. Not enough CPU to do anything else.
###<code> -f segment </code> (output format) '''DONT CHANGE''' Use a "chunked" output
###<code> -segment_list out.list </code> (segment file) Defines a file containing the produced files names
###<code> -segment_list_flags +live </code> (segment file flags) Defines the way the output file caches files names.
###<code> -segment_list_size 5 </code> (segment file size)
###<code> -segment_time 4 </code> (segment time) Defines the capture base duration in seconds. Tweak.
###<code> -segment_time_delta 3 </code> (segment time delta) Defines a window to modulate chunks duration in seconds to include mandatory inline headers. Tweak.
###<code> %10d.ts </code> The format for chunks files names. %10d will start at 0000000000.ts and ffmpeg understand we want MPEGTS format for chunks
# ffmpeg saves the files 0000.ts, 0001.ts, etc. and out.list in /tmp/capture

==== C. Use rsync to infinitely synchronise chunks on server ====

'''Some important points to mention here '''

* The RaspberryPi '''MUST''' have access to a <server> using an SSH KEY for an <user>. Password access won't work for infinite rsync.
* This <server> '''CAN''' be your laptop. If so it MUST be on the same LAN as the RaspberryPi
* This <server> '''CAN''' be a datacenter machie. If so it MUST be accessible on Internet by the RaspberryPi.
* This <server> '''MUST''' have FFMPEG installed (see point D below)
* It is advised to run this one liner in a <code>screen</code> command on the RaspberryPi

<code> ssh <user>@<server> "[ -d /tmp/capture ] || mkdir /tmp/capture" && \
while true; do rsync -a --files-from=/tmp/capture/out.list /tmp/capture <user>@<server>:/tmp/capture; sleep 1; done</code>

'''What's happening here'''

#<code> ssh </code> Use SSH ...
##<code> <user>@<server> </code> ... to connect to server "server" as user "user"
##<code> "[ -d /tmp/capture ] || mkdir /tmp/capture" </code> ... and create if not exists a folder "/tmp/capture"
#<code> while true; do </code> Run an infinite loop
##<code> rsync </code> Start rsync file synchronisation
###<code> -a </code> (archive mode) Set the right parameters for transfer
###<code> --files-from=/tmp/capture/out.list </code> Use the out.list as a list of file to transfer, which avoids scanning the whole folder
###<code> /tmp/capture </code> (source) Transfer local folder content...
###<code> <user>@<server>:/tmp/capture; </code> (destination) To the server "server"
##<code> sleep 1; </code> Sleep one second
#<code> done </code> Loop end

==== D. Broadcast from server to icecast ====

* You '''MUST''' install some script on <server> to assemble / concatenate the MPEGTS chunks for you.
This PHP streamer is made for that: <code>https://raw.githubusercontent.com/albancrommer/raspistream/master/stream.php</code>
* You '''MUST''' install ffmpeg on <server> with ogg support (see below)
* You '''MUST''' install the oggfwd command line tool with <code>aptitude install oggfwd</code>
* You '''MUST''' have access to an icecast server. If you use a datacenter server, everything can run locally

<code> php /usr/local/bin/stream.php | ffmpeg -i - -f ogg - | oggfwd -p -n "My RaspberryPi Stream" <stream.server.com> 8000 mySecretIceCastStreamingPassword /test </code>

'''What's happening here'''

#<code> php /usr/local/bin/stream.php </code> Start an infinite stream of assembled chunks received via rsync
#<code> | ffmpeg </code> Pipe into FFMPEG
##<code> -i - </code> (input) '''DON'T CHANGE''' Use Standard In as input
##<code> -f ogg </code> (format) '''DON'T CHANGE''' Use ogg as output format
##<code> - </code> (output) '''DON'T CHANGE''' Output to Standard Out
#<code> | oggfwd </code> Pipe into oggfwd
##<code> -p </code> (public) Makes the stream public. Tweak
##<code> -n "My RaspberryPi Stream" </code> (name) Your stream name. Adapt
##<code> <stream.server.com> </code> (address) Your icecast server name. Adapt
##<code> 8000 </code> (port) 8000 is default for icecast. Adapt
##<code> <mySecretIceCastStreamingPassword> </code> (password) The icecast input password Adapt
##<code> /rpi01 </code> (mountpoint) The icecast "mountpoint" ie. the path for your stream

==== E. Get the m3u from icecast ====

With the default parameters provided the stream would be accessed on

<code>http://<stream.server.com>:8000/rpi01.m3u</code>

==== Sources ====

http://sirlagz.net/2013/01/07/how-to-stream-a-webcam-from-the-raspberry-pi-part-3/

=== How to get full video from the small chunks ===

After the streaming you should have chunks both on the RaspberryPi and the server, and could perform the conversion on any of them.

Except that the RaspberryPi is VERY slow and that depending on your budget / stability needs you might not have kept all the chunks on the RaspberryPi.

In other words, make the conversion on the server, be it your laptop or a datacenter server.

==== A. Clean the last file (optional) ====

As our last chunk / fragment might be invalid, it's safer to remove it using :

<code>ls /tmp/capture/*ts|tail -n 1|xargs rm </code>

'''What's happening here'''

This command retrieves a sorted list of all chunks in the capture folder, extracts the last one and deletes it.

==== B. Convert to single file (mp4, webm) ====

It is assumed you have FFMPEG installed on the machine.

It is assumed you want to make minimal changes to your original video input (size, bitrate, etc). Only essential options are provided but you can add more according to your needs, double pass conversion is not included either.

It is recommanded to use a script for files merging, as ffmpeg syntax can be a bit of a mess for that, with little option if you want to use start or end file.

This PHP script is made for that : https://raw.githubusercontent.com/albancrommer/raspistream/master/concat.php

''' Converting to MP4 '''

This operation can be fast as the MPEGTS chunks are ready for MP4

<code>php concat.php <start> <end> | ffmpeg -i - -movflags +faststart -threads 0 -profile:v high -preset slow <myfile>.mp4</code>

'''What's happening here'''

#<code> php concat.php </code> Start concatenation
##<code> <start> </code> (optional) an integer designing the first file to include
##<code> <end> </code>(optional) an integer designing the last file to include
#<code> | ffmpeg </code> Pipe into FFMPEG with following parameters
##<code> -i - </code> (input) '''DON'T CHANGE''' use stdin as input
##<code> -movflags +faststart </code> '''DON'T CHANGE''' Make the file ready for web viewing
##<code> -threads 0 </code> Require all CPU to work on the conversion. Tweak.
##<code> -profile:v high </code> Set the output quality. Tweak.
##<code> -preset slow </code> Set the encoding speed.Tweak.
##<code> <myfile>.mp4 </code> Your output file name. Adapt.

''' Converting to WEBM '''

This operation will be slower as audio and video tracks needs to use new codecs

<code>php concat.php <start> <end> | ffmpeg -i - -codec:a libvorbis -codec:v libvpx -threads 0 -quality good -cpu-used 0 -qmin 10 -qmax 42 <myfile>.webm</code>

'''What's happening here'''

#<code> php concat.php </code> Start concatenation
##<code> <start> </code> (optional) an integer designing the first file to include
##<code> <end> </code>(optional) an integer designing the last file to include
#<code> | ffmpeg </code> Pipe into FFMPEG with following parameters
##<code> -i - </code> (input) '''DON'T CHANGE''' use stdin as input
##<code> -codec:a libvorbis </code> (codec) '''DON'T CHANGE''' Define the audio codec
##<code> -codec:v libvpx </code> (codec) '''DON'T CHANGE''' Define the video codec
##<code> -threads 0 </code> Require all CPU to work on the conversion. Tweak.
##<code> -quality good </code> Set the encoding speed. Tweak
##<code> -cpu-used 1 </code> Set the encoding speed. Tweak
##<code> -qmin 10 -qmax 42 </code> Set the encoding quality. Tweak
##<code> <myfile>.webm </code> Your output file name. Adapt

==== Sources ====

https://www.virag.si/2012/01/web-video-encoding-tutorial-with-ffmpeg-0-9/
https://www.virag.si/2012/01/webm-web-video-encoding-tutorial-with-ffmpeg-0-9/

== Solution 2 : FLVSTR + PHP Streamer ==

'''Basic idea''' the Octopuce company has a solution to convert live MP4 to F4V. With an USB audio card, we could mux the MP4 and AAC audio and have a standalone solution.

'''CON''' authentification is hard, F4V means Flash, requires an USB disk for local backup

'''PRO''' the pi can be autonomous

First, authentification. This problem is adressed by solving encryption as well: we use an SSL socket to communicate with the server.

== Solution 3 : RTSP ==

'''Basic idea''' Use an RTSP stream with VLC and the V4L driver

'''CON''' Non commercial RTSP server are not the norm, requires VLC or Flash player, Quality with v4l is low

'''PRO''' Easy to work out

'''Sources'''

http://www.ics.com/blog/raspberry-pi-camera-module#.VJFhbyvF-b8

http://raspberrypi.stackexchange.com/questions/23182/how-to-stream-video-from-raspberry-pi-camera-and-watch-it-live

http://ffmpeg.gusari.org/viewtopic.php?f=16&t=1130

http://blog.tkjelectronics.dk/2013/06/how-to-stream-video-and-audio-from-a-raspberry-pi-with-no-latency/

== Solution 4 : HLS + RSYNC ==

'''Basic idea''' Use HLS segmentation and rsync

'''CON''' Not all web players can do HLS

'''PRO''' Almost out of the box, robust

'''Howto'''

1. Compile fresh ffmpeg on the pi

2. Run a capture : <code>raspivid -ih -pf baseline -t 0 -b 1000000 -w 1280 -h 720 -v -o - | ffmpeg -i - -f alsa -ac 1 -itsoffset 6.5 -i hw:1 -acodec aac -strict -2 -vcodec copy out.m3u8 </code>

3. Run a cron rsync to server (todo)

4. Connect a client (todo)

'''Sources'''

http://www.ffmpeg.org/ffmpeg-formats.html#hls

= FFMPEG compilation =

This installation is debian based. Some packages are included by default :

* ffmpeg : Provides a large number of the dependencies required at compilation tim
* yasm : modular assembler (good for compilation)
* pkg-config : info about installed libraries (good for compilation)
* screen : helpful for running compilation in background

== For Raspberry ==

For the Raspberry, we only need the support of h264, AAC and ALSA
<pre>
sudo -s
aptitude install screen yasl libx264-dev libasound2-dev libfdk-aac-dev ffmpeg
cd /usr/src
git clone --depth 1 git://source.ffmpeg.org/ffmpeg.git
cd ffmpeg
./configure --enable-gpl --enable-libx264 --enable-libfdk-aac
make
make install
</pre>

== For laptop or server ==

Your default debian might come with sufficent support but if you want total control, compiling is a good idea.

Remove packages and ffmpeg support if you don't need everything.

Ex: to produce ogg format, you only need
* aptitude packages libtheora-dev and libvorbis-dev
* configure options --enable-libtheora --enable-libvorbis

<pre>
sudo
aptitude update && aptitude install screen pkg-config yasm ffmpeg libass-dev libavcodec-extra libfdk-aac-dev libmp3lame-dev libopus-dev libtheora-dev libvorbis-dev libvpx-dev libx264-dev
cd /usr/src
git clone --depth 1 git://source.ffmpeg.org/ffmpeg.git
cd ffmpeg
./configure --enable-gpl --enable-libass --enable-libfdk-aac --enable-libfreetype --enable-libmp3lame --enable-libopus --enable-libtheora --enable-libvorbis --enable-libvpx --enable-libx264 --enable-nonfree --enable-x11grab
make
make install
</pre>

= References =

Here are a number of unsorted links

* http://techzany.com/2013/09/live-streaming-video-using-avconv-and-a-raspberry-pi/
* http://blog.cloudfrancois.fr/category/streaming-video.html

== FFMPEG ==

* http://ffmpeg.org/ffmpeg-all.html#segment_002c-stream_005fsegment_002c-ssegment
* https://trac.ffmpeg.org/wiki/StreamingGuide

== Node ==

* http://phoboslab.org/log/2013/09/html5-live-video-streaming-via-websockets
* https://github.com/phoboslab/jsmpeg
* https://github.com/fluent-ffmpeg/node-fluent-ffmpeg

== Raspberry PI ==

* Raspbian, debian on Raspberry pi http://www.raspbian.org/
* Chose your SD card for your PI : http://elinux.org/RPi_SD_cards

Streaming Video With RaspberryPi

2015-01-17T23:31:09Z

Vincib: /* Solution 4 : HLS + RSYNC */

= General =

Caution: this is a Work in progress, things are being tested. The objective is to provide in the end one or more working solutions for everyone.

== Video streaming is a problem ==

The RaspberryPi camera offers an interesting solution to this problem. It is a very well integrated module of the Pi with one huge advantage: h264 encoding can be performed directly by the CPU as the camera uses the Serial Camera Interface protocol.

So theorically, solving the video problem with the Pi is easy but there are many subtle problems.

== Problems ==

'''Audio''' As we use video webstreaming mostly for conferences broadcasting, good audio quality is necessary.

'''Slides''' It would be interesting to include slides of conferences while filming.

'''File''' It is important to have a file at the end of the filming.

'''Web''' It is important to have a large viewer base, therefore a well supported format.

== Raspicam basics ==

http://elinux.org/Rpi_Camera_Module

raspivid is the basic command line used to capture video in h264.

<code>raspivid -t 3 -fps 25 -b 1000000 -w 1920 -h 1080 -o /tmp/video.h264</code>

A very simple tutorial : http://www.raspberrypi-spy.co.uk/2013/05/capturing-hd-video-with-the-pi-camera-module/

= Solution =

== Solution 1 : OGG/VORBIS + Icecast ==

'''Basic idea'''

# Use the PI to capture video as h264, merge audio from usb and use ffmpeg to produce MPEGTS "chunks"
# Rsync the chunks to a laptop or a server (note : the audio mix can be done on the laptop)
# Assemble the chunks and pipe them in ffmpeg
# Ask ffmpeg to convert this into ogg
# Use oggfwd to push the ogg to your icecast server
# Serve m3u from the server

'''CON''' ogg does not work for everyone. It is supposed to be HTML5 compatible but icecast doesn't offer that by default.

'''PRO''' Icecast is simple, open, and handles authentification. Rsync using SSH is crypto friendly. The file is saved on the server.

=== How to stream in OGG to Icecast ===

==== A. Compile FFMPEG on pi & server (see below) ====

==== B. Start capture in a screen ====

It is advised to run this one liner in a <code>screen</code> command on the RaspberryPi

<code>[ -d /tmp/capture ] || mkdir /tmp/capture; rm -f /tmp/capture/* && cd /tmp/capture/ && \
raspivid -ih -t 0 -w 1280 -h 720 -b 1000000 -pf baseline -o - | /usr/local/bin/ffmpeg -f alsa -itsoffset 6.5 -ac 1 -i hw:1 -acodec aac -strict -2 \
-i - -vcodec copy -f segment -segment_list out.list -segment_list_flags +live -segment_list_size 5 -segment_time 4 -segment_time_delta 3 %10d.ts</code>

'''What's happening here'''

#<code>[ -d /tmp/capture ] || mkdir /tmp/capture; rm -f /tmp/capture/* && cd /tmp/capture/</code> We create a /tmp/capture folder and make sure it's empty when starting capture in it
#<code> raspivid </code> Use raspivid to capturing with following parameters:
##<code> -ih </code>(inline headers) '''DONT CHANGE''' Necessary for technical reasons, as otherwise the "chunking" doesn't work
##<code> -t 0 </code> (timeout) '''DONT CHANGE''' Necessary for technical reasons, as otherwise capture stops after 5s
##<code> -w 1080 -h 720 </code> (height) and (width) Tweak according to your needs
##<code> -b 1000000 </code> (bitrate) Tweak according to your needs (only integer numbers in bits are accepted, here <=> 1Mb)
##<code> -pf baseline </code> (h264 profile) Tweak according to your needs ( only baseline, main, or high accepted)
##<code> -o - </code> (output) '''DONT CHANGE''' Necessary in order to use the flux as Standard Output
# We pipe the content into ffmpeg with following parameters:
## ALSA Input
###<code> -f alsa </code> (format) We use <code>alsa</code> for usb audio capture
###<code> -itsoffset 6.5 </code> (time offset) '''This one is a trick''' We noticed our RPi B+ had a 6.5 seconds delay to start the audio, so this is used to resync audio. Tweak.
###<code> -ac 1 </code> (number of audio channels) We used a mono input, so <code>1</code> was the right choice. Tweak
###<code> -i hw:1 </code> (input) '''Tweak''' as your audio card adress may vary. Find more with <code>arecord -l</code>
###<code> -acodec aac </code> (audio codec) AAC works well for TS live.
###<code> -strict -2 </code> Argument mandatory for AAC format
## Video Input
###<code> -i - </code> (input) '''DONT CHANGE''' Use the Standard input
###<code> -vcodec copy</code> (video codec) '''DONT CHANGE''' Use the video codec from the RPi. Not enough CPU to do anything else.
###<code> -f segment </code> (output format) '''DONT CHANGE''' Use a "chunked" output
###<code> -segment_list out.list </code> (segment file) Defines a file containing the produced files names
###<code> -segment_list_flags +live </code> (segment file flags) Defines the way the output file caches files names.
###<code> -segment_list_size 5 </code> (segment file size)
###<code> -segment_time 4 </code> (segment time) Defines the capture base duration in seconds. Tweak.
###<code> -segment_time_delta 3 </code> (segment time delta) Defines a window to modulate chunks duration in seconds to include mandatory inline headers. Tweak.
###<code> %10d.ts </code> The format for chunks files names. %10d will start at 0000000000.ts and ffmpeg understand we want MPEGTS format for chunks
# ffmpeg saves the files 0000.ts, 0001.ts, etc. and out.list in /tmp/capture

==== C. Use rsync to infinitely synchronise chunks on server ====

'''Some important points to mention here '''

* The RaspberryPi '''MUST''' have access to a <server> using an SSH KEY for an <user>. Password access won't work for infinite rsync.
* This <server> '''CAN''' be your laptop. If so it MUST be on the same LAN as the RaspberryPi
* This <server> '''CAN''' be a datacenter machie. If so it MUST be accessible on Internet by the RaspberryPi.
* This <server> '''MUST''' have FFMPEG installed (see point D below)
* It is advised to run this one liner in a <code>screen</code> command on the RaspberryPi

<code> ssh <user>@<server> "[ -d /tmp/capture ] || mkdir /tmp/capture" && \
while true; do rsync -a --files-from=/tmp/capture/out.list /tmp/capture <user>@<server>:/tmp/capture; sleep 1; done</code>

'''What's happening here'''

#<code> ssh </code> Use SSH ...
##<code> <user>@<server> </code> ... to connect to server "server" as user "user"
##<code> "[ -d /tmp/capture ] || mkdir /tmp/capture" </code> ... and create if not exists a folder "/tmp/capture"
#<code> while true; do </code> Run an infinite loop
##<code> rsync </code> Start rsync file synchronisation
###<code> -a </code> (archive mode) Set the right parameters for transfer
###<code> --files-from=/tmp/capture/out.list </code> Use the out.list as a list of file to transfer, which avoids scanning the whole folder
###<code> /tmp/capture </code> (source) Transfer local folder content...
###<code> <user>@<server>:/tmp/capture; </code> (destination) To the server "server"
##<code> sleep 1; </code> Sleep one second
#<code> done </code> Loop end

==== D. Broadcast from server to icecast ====

* You '''MUST''' install some script on <server> to assemble / concatenate the MPEGTS chunks for you.
This PHP streamer is made for that: <code>https://raw.githubusercontent.com/albancrommer/raspistream/master/stream.php</code>
* You '''MUST''' install ffmpeg on <server> with ogg support (see below)
* You '''MUST''' install the oggfwd command line tool with <code>aptitude install oggfwd</code>
* You '''MUST''' have access to an icecast server. If you use a datacenter server, everything can run locally

<code> php /usr/local/bin/stream.php | ffmpeg -i - -f ogg - | oggfwd -p -n "My RaspberryPi Stream" <stream.server.com> 8000 mySecretIceCastStreamingPassword /test </code>

'''What's happening here'''

#<code> php /usr/local/bin/stream.php </code> Start an infinite stream of assembled chunks received via rsync
#<code> | ffmpeg </code> Pipe into FFMPEG
##<code> -i - </code> (input) '''DON'T CHANGE''' Use Standard In as input
##<code> -f ogg </code> (format) '''DON'T CHANGE''' Use ogg as output format
##<code> - </code> (output) '''DON'T CHANGE''' Output to Standard Out
#<code> | oggfwd </code> Pipe into oggfwd
##<code> -p </code> (public) Makes the stream public. Tweak
##<code> -n "My RaspberryPi Stream" </code> (name) Your stream name. Adapt
##<code> <stream.server.com> </code> (address) Your icecast server name. Adapt
##<code> 8000 </code> (port) 8000 is default for icecast. Adapt
##<code> <mySecretIceCastStreamingPassword> </code> (password) The icecast input password Adapt
##<code> /rpi01 </code> (mountpoint) The icecast "mountpoint" ie. the path for your stream

==== E. Get the m3u from icecast ====

With the default parameters provided the stream would be accessed on

<code>http://<stream.server.com>:8000/rpi01.m3u</code>

==== Sources ====

http://sirlagz.net/2013/01/07/how-to-stream-a-webcam-from-the-raspberry-pi-part-3/

=== How to get full video from the small chunks ===

After the streaming you should have chunks both on the RaspberryPi and the server, and could perform the conversion on any of them.

Except that the RaspberryPi is VERY slow and that depending on your budget / stability needs you might not have kept all the chunks on the RaspberryPi.

In other words, make the conversion on the server, be it your laptop or a datacenter server.

==== A. Clean the last file (optional) ====

As our last chunk / fragment might be invalid, it's safer to remove it using :

<code>ls /tmp/capture/*ts|tail -n 1|xargs rm </code>

'''What's happening here'''

This command retrieves a sorted list of all chunks in the capture folder, extracts the last one and deletes it.

==== B. Convert to single file (mp4, webm) ====

It is assumed you have FFMPEG installed on the machine.

It is assumed you want to make minimal changes to your original video input (size, bitrate, etc). Only essential options are provided but you can add more according to your needs, double pass conversion is not included either.

It is recommanded to use a script for files merging, as ffmpeg syntax can be a bit of a mess for that, with little option if you want to use start or end file.

This PHP script is made for that : https://raw.githubusercontent.com/albancrommer/raspistream/master/concat.php

''' Converting to MP4 '''

This operation can be fast as the MPEGTS chunks are ready for MP4

<code>php concat.php <start> <end> | ffmpeg -i - -movflags +faststart -threads 0 -profile:v high -preset slow <myfile>.mp4</code>

'''What's happening here'''

#<code> php concat.php </code> Start concatenation
##<code> <start> </code> (optional) an integer designing the first file to include
##<code> <end> </code>(optional) an integer designing the last file to include
#<code> | ffmpeg </code> Pipe into FFMPEG with following parameters
##<code> -i - </code> (input) '''DON'T CHANGE''' use stdin as input
##<code> -movflags +faststart </code> '''DON'T CHANGE''' Make the file ready for web viewing
##<code> -threads 0 </code> Require all CPU to work on the conversion. Tweak.
##<code> -profile:v high </code> Set the output quality. Tweak.
##<code> -preset slow </code> Set the encoding speed.Tweak.
##<code> <myfile>.mp4 </code> Your output file name. Adapt.

''' Converting to WEBM '''

This operation will be slower as audio and video tracks needs to use new codecs

<code>php concat.php <start> <end> | ffmpeg -i - -codec:a libvorbis -codec:v libvpx -threads 0 -quality good -cpu-used 0 -qmin 10 -qmax 42 <myfile>.webm</code>

'''What's happening here'''

#<code> php concat.php </code> Start concatenation
##<code> <start> </code> (optional) an integer designing the first file to include
##<code> <end> </code>(optional) an integer designing the last file to include
#<code> | ffmpeg </code> Pipe into FFMPEG with following parameters
##<code> -i - </code> (input) '''DON'T CHANGE''' use stdin as input
##<code> -codec:a libvorbis </code> (codec) '''DON'T CHANGE''' Define the audio codec
##<code> -codec:v libvpx </code> (codec) '''DON'T CHANGE''' Define the video codec
##<code> -threads 0 </code> Require all CPU to work on the conversion. Tweak.
##<code> -quality good </code> Set the encoding speed. Tweak
##<code> -cpu-used 1 </code> Set the encoding speed. Tweak
##<code> -qmin 10 -qmax 42 </code> Set the encoding quality. Tweak
##<code> <myfile>.webm </code> Your output file name. Adapt

==== Sources ====

https://www.virag.si/2012/01/web-video-encoding-tutorial-with-ffmpeg-0-9/
https://www.virag.si/2012/01/webm-web-video-encoding-tutorial-with-ffmpeg-0-9/

== Solution 2 : FLVSTR + PHP Streamer ==

'''Basic idea''' the Octopuce company has a solution to convert live MP4 to F4V. With an USB audio card, we could mux the MP4 and AAC audio and have a standalone solution.

'''CON''' authentification is hard, F4V means Flash, requires an USB disk for local backup

'''PRO''' the pi can be autonomous

First, authentification. This problem is adressed by solving encryption as well: we use an SSL socket to communicate with the server.

== Solution 3 : RTSP ==

'''Basic idea''' Use an RTSP stream with VLC and the V4L driver

'''CON''' Non commercial RTSP server are not the norm, requires VLC or Flash player, Quality with v4l is low

'''PRO''' Easy to work out

'''Sources'''

http://www.ics.com/blog/raspberry-pi-camera-module#.VJFhbyvF-b8

http://raspberrypi.stackexchange.com/questions/23182/how-to-stream-video-from-raspberry-pi-camera-and-watch-it-live

http://ffmpeg.gusari.org/viewtopic.php?f=16&t=1130

http://blog.tkjelectronics.dk/2013/06/how-to-stream-video-and-audio-from-a-raspberry-pi-with-no-latency/

== Solution 4 : HLS + RSYNC ==

'''Basic idea''' Use HLS segmentation and rsync

'''CON''' Not all web players can do HLS

'''PRO''' Almost out of the box, robust

'''Howto'''

1. Compile fresh ffmpeg on the pi

2. Run a capture : <code>raspivid -ih -pf baseline -t 0 -b 1000000 -w 1280 -h 720 -v -o - | ffmpeg -i - -f alsa -ac 1 -itsoffset 6.5 -i hw:1 -acodec aac -strict -2 -vcodec copy out.m3u8 </code>

3. Run a cron rsync to server (todo)

4. Connect a client (todo)

'''Sources'''

http://www.ffmpeg.org/ffmpeg-formats.html#hls

= FFMPEG compilation =

This installation is debian based. Some packages are included by default :

* ffmpeg : Provides a large number of the dependencies required at compilation tim
* yasm : modular assembler (good for compilation)
* pkg-config : info about installed libraries (good for compilation)
* screen : helpful for running compilation in background

== For Raspberry ==

For the Raspberry, we only need the support of h264, AAC and ALSA
<pre>
sudo -s
aptitude install screen yasl libx264-dev libasound2-dev libfdk-aac-dev ffmpeg
cd /usr/src
git clone --depth 1 git://source.ffmpeg.org/ffmpeg.git
cd ffmpeg
./configure --enable-gpl --enable-libx264 --enable-libfdk-aac
make
make install
</pre>

== For laptop or server ==

Your default debian might come with sufficent support but if you want total control, compiling is a good idea.

Remove packages and ffmpeg support if you don't need everything.

Ex: to produce ogg format, you only need
* aptitude packages libtheora-dev and libvorbis-dev
* configure options --enable-libtheora --enable-libvorbis

<pre>
sudo
aptitude update && aptitude install screen pkg-config yasm ffmpeg libass-dev libavcodec-extra libfdk-aac-dev libmp3lame-dev libopus-dev libtheora-dev libvorbis-dev libvpx-dev libx264-dev
cd /usr/src
git clone --depth 1 git://source.ffmpeg.org/ffmpeg.git
cd ffmpeg
./configure --enable-gpl --enable-libass --enable-libfdk-aac --enable-libfreetype --enable-libmp3lame --enable-libopus --enable-libtheora --enable-libvorbis --enable-libvpx --enable-libx264 --enable-nonfree --enable-x11grab
make
make install
</pre>

= References =

Here are a number of unsorted links

http://techzany.com/2013/09/live-streaming-video-using-avconv-and-a-raspberry-pi/

== FFMPEG ==

* http://ffmpeg.org/ffmpeg-all.html#segment_002c-stream_005fsegment_002c-ssegment
* https://trac.ffmpeg.org/wiki/StreamingGuide

== Node ==

* http://phoboslab.org/log/2013/09/html5-live-video-streaming-via-websockets
* https://github.com/phoboslab/jsmpeg
* https://github.com/fluent-ffmpeg/node-fluent-ffmpeg

== Raspberry PI ==

* Raspbian, debian on Raspberry pi http://www.raspbian.org/
* Chose your SD card for your PI : http://elinux.org/RPi_SD_cards

Streaming Video With RaspberryPi

2015-01-17T23:27:13Z

Vincib: /* References */

= General =

Caution: this is a Work in progress, things are being tested. The objective is to provide in the end one or more working solutions for everyone.

== Video streaming is a problem ==

The RaspberryPi camera offers an interesting solution to this problem. It is a very well integrated module of the Pi with one huge advantage: h264 encoding can be performed directly by the CPU as the camera uses the Serial Camera Interface protocol.

So theorically, solving the video problem with the Pi is easy but there are many subtle problems.

== Problems ==

'''Audio''' As we use video webstreaming mostly for conferences broadcasting, good audio quality is necessary.

'''Slides''' It would be interesting to include slides of conferences while filming.

'''File''' It is important to have a file at the end of the filming.

'''Web''' It is important to have a large viewer base, therefore a well supported format.

== Raspicam basics ==

http://elinux.org/Rpi_Camera_Module

raspivid is the basic command line used to capture video in h264.

<code>raspivid -t 3 -fps 25 -b 1000000 -w 1920 -h 1080 -o /tmp/video.h264</code>

A very simple tutorial : http://www.raspberrypi-spy.co.uk/2013/05/capturing-hd-video-with-the-pi-camera-module/

= Solution =

== Solution 1 : OGG/VORBIS + Icecast ==

'''Basic idea'''

# Use the PI to capture video as h264, merge audio from usb and use ffmpeg to produce MPEGTS "chunks"
# Rsync the chunks to a laptop or a server (note : the audio mix can be done on the laptop)
# Assemble the chunks and pipe them in ffmpeg
# Ask ffmpeg to convert this into ogg
# Use oggfwd to push the ogg to your icecast server
# Serve m3u from the server

'''CON''' ogg does not work for everyone. It is supposed to be HTML5 compatible but icecast doesn't offer that by default.

'''PRO''' Icecast is simple, open, and handles authentification. Rsync using SSH is crypto friendly. The file is saved on the server.

=== How to stream in OGG to Icecast ===

==== A. Compile FFMPEG on pi & server (see below) ====

==== B. Start capture in a screen ====

It is advised to run this one liner in a <code>screen</code> command on the RaspberryPi

<code>[ -d /tmp/capture ] || mkdir /tmp/capture; rm -f /tmp/capture/* && cd /tmp/capture/ && \
raspivid -ih -t 0 -w 1280 -h 720 -b 1000000 -pf baseline -o - | /usr/local/bin/ffmpeg -f alsa -itsoffset 6.5 -ac 1 -i hw:1 -acodec aac -strict -2 \
-i - -vcodec copy -f segment -segment_list out.list -segment_list_flags +live -segment_list_size 5 -segment_time 4 -segment_time_delta 3 %10d.ts</code>

'''What's happening here'''

#<code>[ -d /tmp/capture ] || mkdir /tmp/capture; rm -f /tmp/capture/* && cd /tmp/capture/</code> We create a /tmp/capture folder and make sure it's empty when starting capture in it
#<code> raspivid </code> Use raspivid to capturing with following parameters:
##<code> -ih </code>(inline headers) '''DONT CHANGE''' Necessary for technical reasons, as otherwise the "chunking" doesn't work
##<code> -t 0 </code> (timeout) '''DONT CHANGE''' Necessary for technical reasons, as otherwise capture stops after 5s
##<code> -w 1080 -h 720 </code> (height) and (width) Tweak according to your needs
##<code> -b 1000000 </code> (bitrate) Tweak according to your needs (only integer numbers in bits are accepted, here <=> 1Mb)
##<code> -pf baseline </code> (h264 profile) Tweak according to your needs ( only baseline, main, or high accepted)
##<code> -o - </code> (output) '''DONT CHANGE''' Necessary in order to use the flux as Standard Output
# We pipe the content into ffmpeg with following parameters:
## ALSA Input
###<code> -f alsa </code> (format) We use <code>alsa</code> for usb audio capture
###<code> -itsoffset 6.5 </code> (time offset) '''This one is a trick''' We noticed our RPi B+ had a 6.5 seconds delay to start the audio, so this is used to resync audio. Tweak.
###<code> -ac 1 </code> (number of audio channels) We used a mono input, so <code>1</code> was the right choice. Tweak
###<code> -i hw:1 </code> (input) '''Tweak''' as your audio card adress may vary. Find more with <code>arecord -l</code>
###<code> -acodec aac </code> (audio codec) AAC works well for TS live.
###<code> -strict -2 </code> Argument mandatory for AAC format
## Video Input
###<code> -i - </code> (input) '''DONT CHANGE''' Use the Standard input
###<code> -vcodec copy</code> (video codec) '''DONT CHANGE''' Use the video codec from the RPi. Not enough CPU to do anything else.
###<code> -f segment </code> (output format) '''DONT CHANGE''' Use a "chunked" output
###<code> -segment_list out.list </code> (segment file) Defines a file containing the produced files names
###<code> -segment_list_flags +live </code> (segment file flags) Defines the way the output file caches files names.
###<code> -segment_list_size 5 </code> (segment file size)
###<code> -segment_time 4 </code> (segment time) Defines the capture base duration in seconds. Tweak.
###<code> -segment_time_delta 3 </code> (segment time delta) Defines a window to modulate chunks duration in seconds to include mandatory inline headers. Tweak.
###<code> %10d.ts </code> The format for chunks files names. %10d will start at 0000000000.ts and ffmpeg understand we want MPEGTS format for chunks
# ffmpeg saves the files 0000.ts, 0001.ts, etc. and out.list in /tmp/capture

==== C. Use rsync to infinitely synchronise chunks on server ====

'''Some important points to mention here '''

* The RaspberryPi '''MUST''' have access to a <server> using an SSH KEY for an <user>. Password access won't work for infinite rsync.
* This <server> '''CAN''' be your laptop. If so it MUST be on the same LAN as the RaspberryPi
* This <server> '''CAN''' be a datacenter machie. If so it MUST be accessible on Internet by the RaspberryPi.
* This <server> '''MUST''' have FFMPEG installed (see point D below)
* It is advised to run this one liner in a <code>screen</code> command on the RaspberryPi

<code> ssh <user>@<server> "[ -d /tmp/capture ] || mkdir /tmp/capture" && \
while true; do rsync -a --files-from=/tmp/capture/out.list /tmp/capture <user>@<server>:/tmp/capture; sleep 1; done</code>

'''What's happening here'''

#<code> ssh </code> Use SSH ...
##<code> <user>@<server> </code> ... to connect to server "server" as user "user"
##<code> "[ -d /tmp/capture ] || mkdir /tmp/capture" </code> ... and create if not exists a folder "/tmp/capture"
#<code> while true; do </code> Run an infinite loop
##<code> rsync </code> Start rsync file synchronisation
###<code> -a </code> (archive mode) Set the right parameters for transfer
###<code> --files-from=/tmp/capture/out.list </code> Use the out.list as a list of file to transfer, which avoids scanning the whole folder
###<code> /tmp/capture </code> (source) Transfer local folder content...
###<code> <user>@<server>:/tmp/capture; </code> (destination) To the server "server"
##<code> sleep 1; </code> Sleep one second
#<code> done </code> Loop end

==== D. Broadcast from server to icecast ====

* You '''MUST''' install some script on <server> to assemble / concatenate the MPEGTS chunks for you.
This PHP streamer is made for that: <code>https://raw.githubusercontent.com/albancrommer/raspistream/master/stream.php</code>
* You '''MUST''' install ffmpeg on <server> with ogg support (see below)
* You '''MUST''' install the oggfwd command line tool with <code>aptitude install oggfwd</code>
* You '''MUST''' have access to an icecast server. If you use a datacenter server, everything can run locally

<code> php /usr/local/bin/stream.php | ffmpeg -i - -f ogg - | oggfwd -p -n "My RaspberryPi Stream" <stream.server.com> 8000 mySecretIceCastStreamingPassword /test </code>

'''What's happening here'''

#<code> php /usr/local/bin/stream.php </code> Start an infinite stream of assembled chunks received via rsync
#<code> | ffmpeg </code> Pipe into FFMPEG
##<code> -i - </code> (input) '''DON'T CHANGE''' Use Standard In as input
##<code> -f ogg </code> (format) '''DON'T CHANGE''' Use ogg as output format
##<code> - </code> (output) '''DON'T CHANGE''' Output to Standard Out
#<code> | oggfwd </code> Pipe into oggfwd
##<code> -p </code> (public) Makes the stream public. Tweak
##<code> -n "My RaspberryPi Stream" </code> (name) Your stream name. Adapt
##<code> <stream.server.com> </code> (address) Your icecast server name. Adapt
##<code> 8000 </code> (port) 8000 is default for icecast. Adapt
##<code> <mySecretIceCastStreamingPassword> </code> (password) The icecast input password Adapt
##<code> /rpi01 </code> (mountpoint) The icecast "mountpoint" ie. the path for your stream

==== E. Get the m3u from icecast ====

With the default parameters provided the stream would be accessed on

<code>http://<stream.server.com>:8000/rpi01.m3u</code>

==== Sources ====

http://sirlagz.net/2013/01/07/how-to-stream-a-webcam-from-the-raspberry-pi-part-3/

=== How to get full video from the small chunks ===

After the streaming you should have chunks both on the RaspberryPi and the server, and could perform the conversion on any of them.

Except that the RaspberryPi is VERY slow and that depending on your budget / stability needs you might not have kept all the chunks on the RaspberryPi.

In other words, make the conversion on the server, be it your laptop or a datacenter server.

==== A. Clean the last file (optional) ====

As our last chunk / fragment might be invalid, it's safer to remove it using :

<code>ls /tmp/capture/*ts|tail -n 1|xargs rm </code>

'''What's happening here'''

This command retrieves a sorted list of all chunks in the capture folder, extracts the last one and deletes it.

==== B. Convert to single file (mp4, webm) ====

It is assumed you have FFMPEG installed on the machine.

It is assumed you want to make minimal changes to your original video input (size, bitrate, etc). Only essential options are provided but you can add more according to your needs, double pass conversion is not included either.

It is recommanded to use a script for files merging, as ffmpeg syntax can be a bit of a mess for that, with little option if you want to use start or end file.

This PHP script is made for that : https://raw.githubusercontent.com/albancrommer/raspistream/master/concat.php

''' Converting to MP4 '''

This operation can be fast as the MPEGTS chunks are ready for MP4

<code>php concat.php <start> <end> | ffmpeg -i - -movflags +faststart -threads 0 -profile:v high -preset slow <myfile>.mp4</code>

'''What's happening here'''

#<code> php concat.php </code> Start concatenation
##<code> <start> </code> (optional) an integer designing the first file to include
##<code> <end> </code>(optional) an integer designing the last file to include
#<code> | ffmpeg </code> Pipe into FFMPEG with following parameters
##<code> -i - </code> (input) '''DON'T CHANGE''' use stdin as input
##<code> -movflags +faststart </code> '''DON'T CHANGE''' Make the file ready for web viewing
##<code> -threads 0 </code> Require all CPU to work on the conversion. Tweak.
##<code> -profile:v high </code> Set the output quality. Tweak.
##<code> -preset slow </code> Set the encoding speed.Tweak.
##<code> <myfile>.mp4 </code> Your output file name. Adapt.

''' Converting to WEBM '''

This operation will be slower as audio and video tracks needs to use new codecs

<code>php concat.php <start> <end> | ffmpeg -i - -codec:a libvorbis -codec:v libvpx -threads 0 -quality good -cpu-used 0 -qmin 10 -qmax 42 <myfile>.webm</code>

'''What's happening here'''

#<code> php concat.php </code> Start concatenation
##<code> <start> </code> (optional) an integer designing the first file to include
##<code> <end> </code>(optional) an integer designing the last file to include
#<code> | ffmpeg </code> Pipe into FFMPEG with following parameters
##<code> -i - </code> (input) '''DON'T CHANGE''' use stdin as input
##<code> -codec:a libvorbis </code> (codec) '''DON'T CHANGE''' Define the audio codec
##<code> -codec:v libvpx </code> (codec) '''DON'T CHANGE''' Define the video codec
##<code> -threads 0 </code> Require all CPU to work on the conversion. Tweak.
##<code> -quality good </code> Set the encoding speed. Tweak
##<code> -cpu-used 1 </code> Set the encoding speed. Tweak
##<code> -qmin 10 -qmax 42 </code> Set the encoding quality. Tweak
##<code> <myfile>.webm </code> Your output file name. Adapt

==== Sources ====

https://www.virag.si/2012/01/web-video-encoding-tutorial-with-ffmpeg-0-9/
https://www.virag.si/2012/01/webm-web-video-encoding-tutorial-with-ffmpeg-0-9/

== Solution 2 : FLVSTR + PHP Streamer ==

'''Basic idea''' the Octopuce company has a solution to convert live MP4 to F4V. With an USB audio card, we could mux the MP4 and AAC audio and have a standalone solution.

'''CON''' authentification is hard, F4V means Flash, requires an USB disk for local backup

'''PRO''' the pi can be autonomous

First, authentification. This problem is adressed by solving encryption as well: we use an SSL socket to communicate with the server.

== Solution 3 : RTSP ==

'''Basic idea''' Use an RTSP stream with VLC and the V4L driver

'''CON''' Non commercial RTSP server are not the norm, requires VLC or Flash player, Quality with v4l is low

'''PRO''' Easy to work out

'''Sources'''

http://www.ics.com/blog/raspberry-pi-camera-module#.VJFhbyvF-b8

http://raspberrypi.stackexchange.com/questions/23182/how-to-stream-video-from-raspberry-pi-camera-and-watch-it-live

http://ffmpeg.gusari.org/viewtopic.php?f=16&t=1130

http://blog.tkjelectronics.dk/2013/06/how-to-stream-video-and-audio-from-a-raspberry-pi-with-no-latency/

== Solution 4 : HLS + RSYNC ==

'''Basic idea''' Use HLS segmentation and rsync

'''CON''' Not all web players can do HLS

'''PRO''' Almost out of the box, robust

'''Howto'''

1. Compile fresh ffmpeg on the pi

2. Run a capture : <code>raspivid -ih -pf baseline -t 0 -b 1000000 -w 1080 -h 720 -v -o - | ffmpeg -i - -f alsa -ac 1 -itsoffset 6.5 -i hw:1 -acodec aac -strict -2 -vcodec copy out.m3u8 </code>

3. Run a cron rsync to server (todo)

4. Connect a client (todo)

'''Sources'''

http://www.ffmpeg.org/ffmpeg-formats.html#hls

= FFMPEG compilation =

This installation is debian based. Some packages are included by default :

* ffmpeg : Provides a large number of the dependencies required at compilation tim
* yasm : modular assembler (good for compilation)
* pkg-config : info about installed libraries (good for compilation)
* screen : helpful for running compilation in background

== For Raspberry ==

For the Raspberry, we only need the support of h264, AAC and ALSA
<pre>
sudo -s
aptitude install screen yasl libx264-dev libasound2-dev libfdk-aac-dev ffmpeg
cd /usr/src
git clone --depth 1 git://source.ffmpeg.org/ffmpeg.git
cd ffmpeg
./configure --enable-gpl --enable-libx264 --enable-libfdk-aac
make
make install
</pre>

== For laptop or server ==

Your default debian might come with sufficent support but if you want total control, compiling is a good idea.

Remove packages and ffmpeg support if you don't need everything.

Ex: to produce ogg format, you only need
* aptitude packages libtheora-dev and libvorbis-dev
* configure options --enable-libtheora --enable-libvorbis

<pre>
sudo
aptitude update && aptitude install screen pkg-config yasm ffmpeg libass-dev libavcodec-extra libfdk-aac-dev libmp3lame-dev libopus-dev libtheora-dev libvorbis-dev libvpx-dev libx264-dev
cd /usr/src
git clone --depth 1 git://source.ffmpeg.org/ffmpeg.git
cd ffmpeg
./configure --enable-gpl --enable-libass --enable-libfdk-aac --enable-libfreetype --enable-libmp3lame --enable-libopus --enable-libtheora --enable-libvorbis --enable-libvpx --enable-libx264 --enable-nonfree --enable-x11grab
make
make install
</pre>

= References =

Here are a number of unsorted links

http://techzany.com/2013/09/live-streaming-video-using-avconv-and-a-raspberry-pi/

== FFMPEG ==

* http://ffmpeg.org/ffmpeg-all.html#segment_002c-stream_005fsegment_002c-ssegment
* https://trac.ffmpeg.org/wiki/StreamingGuide

== Node ==

* http://phoboslab.org/log/2013/09/html5-live-video-streaming-via-websockets
* https://github.com/phoboslab/jsmpeg
* https://github.com/fluent-ffmpeg/node-fluent-ffmpeg

== Raspberry PI ==

* Raspbian, debian on Raspberry pi http://www.raspbian.org/
* Chose your SD card for your PI : http://elinux.org/RPi_SD_cards

Streaming Video With RaspberryPi

2015-01-17T23:25:07Z

Vincib: /* Solution 4 : HLS + RSYNC */

= General =

Caution: this is a Work in progress, things are being tested. The objective is to provide in the end one or more working solutions for everyone.

== Video streaming is a problem ==

The RaspberryPi camera offers an interesting solution to this problem. It is a very well integrated module of the Pi with one huge advantage: h264 encoding can be performed directly by the CPU as the camera uses the Serial Camera Interface protocol.

So theorically, solving the video problem with the Pi is easy but there are many subtle problems.

== Problems ==

'''Audio''' As we use video webstreaming mostly for conferences broadcasting, good audio quality is necessary.

'''Slides''' It would be interesting to include slides of conferences while filming.

'''File''' It is important to have a file at the end of the filming.

'''Web''' It is important to have a large viewer base, therefore a well supported format.

== Raspicam basics ==

http://elinux.org/Rpi_Camera_Module

raspivid is the basic command line used to capture video in h264.

<code>raspivid -t 3 -fps 25 -b 1000000 -w 1920 -h 1080 -o /tmp/video.h264</code>

A very simple tutorial : http://www.raspberrypi-spy.co.uk/2013/05/capturing-hd-video-with-the-pi-camera-module/

= Solution =

== Solution 1 : OGG/VORBIS + Icecast ==

'''Basic idea'''

# Use the PI to capture video as h264, merge audio from usb and use ffmpeg to produce MPEGTS "chunks"
# Rsync the chunks to a laptop or a server (note : the audio mix can be done on the laptop)
# Assemble the chunks and pipe them in ffmpeg
# Ask ffmpeg to convert this into ogg
# Use oggfwd to push the ogg to your icecast server
# Serve m3u from the server

'''CON''' ogg does not work for everyone. It is supposed to be HTML5 compatible but icecast doesn't offer that by default.

'''PRO''' Icecast is simple, open, and handles authentification. Rsync using SSH is crypto friendly. The file is saved on the server.

=== How to stream in OGG to Icecast ===

==== A. Compile FFMPEG on pi & server (see below) ====

==== B. Start capture in a screen ====

It is advised to run this one liner in a <code>screen</code> command on the RaspberryPi

<code>[ -d /tmp/capture ] || mkdir /tmp/capture; rm -f /tmp/capture/* && cd /tmp/capture/ && \
raspivid -ih -t 0 -w 1280 -h 720 -b 1000000 -pf baseline -o - | /usr/local/bin/ffmpeg -f alsa -itsoffset 6.5 -ac 1 -i hw:1 -acodec aac -strict -2 \
-i - -vcodec copy -f segment -segment_list out.list -segment_list_flags +live -segment_list_size 5 -segment_time 4 -segment_time_delta 3 %10d.ts</code>

'''What's happening here'''

#<code>[ -d /tmp/capture ] || mkdir /tmp/capture; rm -f /tmp/capture/* && cd /tmp/capture/</code> We create a /tmp/capture folder and make sure it's empty when starting capture in it
#<code> raspivid </code> Use raspivid to capturing with following parameters:
##<code> -ih </code>(inline headers) '''DONT CHANGE''' Necessary for technical reasons, as otherwise the "chunking" doesn't work
##<code> -t 0 </code> (timeout) '''DONT CHANGE''' Necessary for technical reasons, as otherwise capture stops after 5s
##<code> -w 1080 -h 720 </code> (height) and (width) Tweak according to your needs
##<code> -b 1000000 </code> (bitrate) Tweak according to your needs (only integer numbers in bits are accepted, here <=> 1Mb)
##<code> -pf baseline </code> (h264 profile) Tweak according to your needs ( only baseline, main, or high accepted)
##<code> -o - </code> (output) '''DONT CHANGE''' Necessary in order to use the flux as Standard Output
# We pipe the content into ffmpeg with following parameters:
## ALSA Input
###<code> -f alsa </code> (format) We use <code>alsa</code> for usb audio capture
###<code> -itsoffset 6.5 </code> (time offset) '''This one is a trick''' We noticed our RPi B+ had a 6.5 seconds delay to start the audio, so this is used to resync audio. Tweak.
###<code> -ac 1 </code> (number of audio channels) We used a mono input, so <code>1</code> was the right choice. Tweak
###<code> -i hw:1 </code> (input) '''Tweak''' as your audio card adress may vary. Find more with <code>arecord -l</code>
###<code> -acodec aac </code> (audio codec) AAC works well for TS live.
###<code> -strict -2 </code> Argument mandatory for AAC format
## Video Input
###<code> -i - </code> (input) '''DONT CHANGE''' Use the Standard input
###<code> -vcodec copy</code> (video codec) '''DONT CHANGE''' Use the video codec from the RPi. Not enough CPU to do anything else.
###<code> -f segment </code> (output format) '''DONT CHANGE''' Use a "chunked" output
###<code> -segment_list out.list </code> (segment file) Defines a file containing the produced files names
###<code> -segment_list_flags +live </code> (segment file flags) Defines the way the output file caches files names.
###<code> -segment_list_size 5 </code> (segment file size)
###<code> -segment_time 4 </code> (segment time) Defines the capture base duration in seconds. Tweak.
###<code> -segment_time_delta 3 </code> (segment time delta) Defines a window to modulate chunks duration in seconds to include mandatory inline headers. Tweak.
###<code> %10d.ts </code> The format for chunks files names. %10d will start at 0000000000.ts and ffmpeg understand we want MPEGTS format for chunks
# ffmpeg saves the files 0000.ts, 0001.ts, etc. and out.list in /tmp/capture

==== C. Use rsync to infinitely synchronise chunks on server ====

'''Some important points to mention here '''

* The RaspberryPi '''MUST''' have access to a <server> using an SSH KEY for an <user>. Password access won't work for infinite rsync.
* This <server> '''CAN''' be your laptop. If so it MUST be on the same LAN as the RaspberryPi
* This <server> '''CAN''' be a datacenter machie. If so it MUST be accessible on Internet by the RaspberryPi.
* This <server> '''MUST''' have FFMPEG installed (see point D below)
* It is advised to run this one liner in a <code>screen</code> command on the RaspberryPi

<code> ssh <user>@<server> "[ -d /tmp/capture ] || mkdir /tmp/capture" && \
while true; do rsync -a --files-from=/tmp/capture/out.list /tmp/capture <user>@<server>:/tmp/capture; sleep 1; done</code>

'''What's happening here'''

#<code> ssh </code> Use SSH ...
##<code> <user>@<server> </code> ... to connect to server "server" as user "user"
##<code> "[ -d /tmp/capture ] || mkdir /tmp/capture" </code> ... and create if not exists a folder "/tmp/capture"
#<code> while true; do </code> Run an infinite loop
##<code> rsync </code> Start rsync file synchronisation
###<code> -a </code> (archive mode) Set the right parameters for transfer
###<code> --files-from=/tmp/capture/out.list </code> Use the out.list as a list of file to transfer, which avoids scanning the whole folder
###<code> /tmp/capture </code> (source) Transfer local folder content...
###<code> <user>@<server>:/tmp/capture; </code> (destination) To the server "server"
##<code> sleep 1; </code> Sleep one second
#<code> done </code> Loop end

==== D. Broadcast from server to icecast ====

* You '''MUST''' install some script on <server> to assemble / concatenate the MPEGTS chunks for you.
This PHP streamer is made for that: <code>https://raw.githubusercontent.com/albancrommer/raspistream/master/stream.php</code>
* You '''MUST''' install ffmpeg on <server> with ogg support (see below)
* You '''MUST''' install the oggfwd command line tool with <code>aptitude install oggfwd</code>
* You '''MUST''' have access to an icecast server. If you use a datacenter server, everything can run locally

<code> php /usr/local/bin/stream.php | ffmpeg -i - -f ogg - | oggfwd -p -n "My RaspberryPi Stream" <stream.server.com> 8000 mySecretIceCastStreamingPassword /test </code>

'''What's happening here'''

#<code> php /usr/local/bin/stream.php </code> Start an infinite stream of assembled chunks received via rsync
#<code> | ffmpeg </code> Pipe into FFMPEG
##<code> -i - </code> (input) '''DON'T CHANGE''' Use Standard In as input
##<code> -f ogg </code> (format) '''DON'T CHANGE''' Use ogg as output format
##<code> - </code> (output) '''DON'T CHANGE''' Output to Standard Out
#<code> | oggfwd </code> Pipe into oggfwd
##<code> -p </code> (public) Makes the stream public. Tweak
##<code> -n "My RaspberryPi Stream" </code> (name) Your stream name. Adapt
##<code> <stream.server.com> </code> (address) Your icecast server name. Adapt
##<code> 8000 </code> (port) 8000 is default for icecast. Adapt
##<code> <mySecretIceCastStreamingPassword> </code> (password) The icecast input password Adapt
##<code> /rpi01 </code> (mountpoint) The icecast "mountpoint" ie. the path for your stream

==== E. Get the m3u from icecast ====

With the default parameters provided the stream would be accessed on

<code>http://<stream.server.com>:8000/rpi01.m3u</code>

==== Sources ====

http://sirlagz.net/2013/01/07/how-to-stream-a-webcam-from-the-raspberry-pi-part-3/

=== How to get full video from the small chunks ===

After the streaming you should have chunks both on the RaspberryPi and the server, and could perform the conversion on any of them.

Except that the RaspberryPi is VERY slow and that depending on your budget / stability needs you might not have kept all the chunks on the RaspberryPi.

In other words, make the conversion on the server, be it your laptop or a datacenter server.

==== A. Clean the last file (optional) ====

As our last chunk / fragment might be invalid, it's safer to remove it using :

<code>ls /tmp/capture/*ts|tail -n 1|xargs rm </code>

'''What's happening here'''

This command retrieves a sorted list of all chunks in the capture folder, extracts the last one and deletes it.

==== B. Convert to single file (mp4, webm) ====

It is assumed you have FFMPEG installed on the machine.

It is assumed you want to make minimal changes to your original video input (size, bitrate, etc). Only essential options are provided but you can add more according to your needs, double pass conversion is not included either.

It is recommanded to use a script for files merging, as ffmpeg syntax can be a bit of a mess for that, with little option if you want to use start or end file.

This PHP script is made for that : https://raw.githubusercontent.com/albancrommer/raspistream/master/concat.php

''' Converting to MP4 '''

This operation can be fast as the MPEGTS chunks are ready for MP4

<code>php concat.php <start> <end> | ffmpeg -i - -movflags +faststart -threads 0 -profile:v high -preset slow <myfile>.mp4</code>

'''What's happening here'''

#<code> php concat.php </code> Start concatenation
##<code> <start> </code> (optional) an integer designing the first file to include
##<code> <end> </code>(optional) an integer designing the last file to include
#<code> | ffmpeg </code> Pipe into FFMPEG with following parameters
##<code> -i - </code> (input) '''DON'T CHANGE''' use stdin as input
##<code> -movflags +faststart </code> '''DON'T CHANGE''' Make the file ready for web viewing
##<code> -threads 0 </code> Require all CPU to work on the conversion. Tweak.
##<code> -profile:v high </code> Set the output quality. Tweak.
##<code> -preset slow </code> Set the encoding speed.Tweak.
##<code> <myfile>.mp4 </code> Your output file name. Adapt.

''' Converting to WEBM '''

This operation will be slower as audio and video tracks needs to use new codecs

<code>php concat.php <start> <end> | ffmpeg -i - -codec:a libvorbis -codec:v libvpx -threads 0 -quality good -cpu-used 0 -qmin 10 -qmax 42 <myfile>.webm</code>

'''What's happening here'''

#<code> php concat.php </code> Start concatenation
##<code> <start> </code> (optional) an integer designing the first file to include
##<code> <end> </code>(optional) an integer designing the last file to include
#<code> | ffmpeg </code> Pipe into FFMPEG with following parameters
##<code> -i - </code> (input) '''DON'T CHANGE''' use stdin as input
##<code> -codec:a libvorbis </code> (codec) '''DON'T CHANGE''' Define the audio codec
##<code> -codec:v libvpx </code> (codec) '''DON'T CHANGE''' Define the video codec
##<code> -threads 0 </code> Require all CPU to work on the conversion. Tweak.
##<code> -quality good </code> Set the encoding speed. Tweak
##<code> -cpu-used 1 </code> Set the encoding speed. Tweak
##<code> -qmin 10 -qmax 42 </code> Set the encoding quality. Tweak
##<code> <myfile>.webm </code> Your output file name. Adapt

==== Sources ====

https://www.virag.si/2012/01/web-video-encoding-tutorial-with-ffmpeg-0-9/
https://www.virag.si/2012/01/webm-web-video-encoding-tutorial-with-ffmpeg-0-9/

== Solution 2 : FLVSTR + PHP Streamer ==

'''Basic idea''' the Octopuce company has a solution to convert live MP4 to F4V. With an USB audio card, we could mux the MP4 and AAC audio and have a standalone solution.

'''CON''' authentification is hard, F4V means Flash, requires an USB disk for local backup

'''PRO''' the pi can be autonomous

First, authentification. This problem is adressed by solving encryption as well: we use an SSL socket to communicate with the server.

== Solution 3 : RTSP ==

'''Basic idea''' Use an RTSP stream with VLC and the V4L driver

'''CON''' Non commercial RTSP server are not the norm, requires VLC or Flash player, Quality with v4l is low

'''PRO''' Easy to work out

'''Sources'''

http://www.ics.com/blog/raspberry-pi-camera-module#.VJFhbyvF-b8

http://raspberrypi.stackexchange.com/questions/23182/how-to-stream-video-from-raspberry-pi-camera-and-watch-it-live

http://ffmpeg.gusari.org/viewtopic.php?f=16&t=1130

http://blog.tkjelectronics.dk/2013/06/how-to-stream-video-and-audio-from-a-raspberry-pi-with-no-latency/

== Solution 4 : HLS + RSYNC ==

'''Basic idea''' Use HLS segmentation and rsync

'''CON''' Not all web players can do HLS

'''PRO''' Almost out of the box, robust

'''Howto'''

1. Compile fresh ffmpeg on the pi

2. Run a capture : <code>raspivid -ih -pf baseline -t 0 -b 1000000 -w 1080 -h 720 -v -o - | ffmpeg -i - -f alsa -ac 1 -itsoffset 6.5 -i hw:1 -acodec aac -strict -2 -vcodec copy out.m3u8 </code>

3. Run a cron rsync to server (todo)

4. Connect a client (todo)

'''Sources'''

http://www.ffmpeg.org/ffmpeg-formats.html#hls

= FFMPEG compilation =

This installation is debian based. Some packages are included by default :

* ffmpeg : Provides a large number of the dependencies required at compilation tim
* yasm : modular assembler (good for compilation)
* pkg-config : info about installed libraries (good for compilation)
* screen : helpful for running compilation in background

== For Raspberry ==

For the Raspberry, we only need the support of h264, AAC and ALSA
<pre>
sudo -s
aptitude install screen yasl libx264-dev libasound2-dev libfdk-aac-dev ffmpeg
cd /usr/src
git clone --depth 1 git://source.ffmpeg.org/ffmpeg.git
cd ffmpeg
./configure --enable-gpl --enable-libx264 --enable-libfdk-aac
make
make install
</pre>

== For laptop or server ==

Your default debian might come with sufficent support but if you want total control, compiling is a good idea.

Remove packages and ffmpeg support if you don't need everything.

Ex: to produce ogg format, you only need
* aptitude packages libtheora-dev and libvorbis-dev
* configure options --enable-libtheora --enable-libvorbis

<pre>
sudo
aptitude update && aptitude install screen pkg-config yasm ffmpeg libass-dev libavcodec-extra libfdk-aac-dev libmp3lame-dev libopus-dev libtheora-dev libvorbis-dev libvpx-dev libx264-dev
cd /usr/src
git clone --depth 1 git://source.ffmpeg.org/ffmpeg.git
cd ffmpeg
./configure --enable-gpl --enable-libass --enable-libfdk-aac --enable-libfreetype --enable-libmp3lame --enable-libopus --enable-libtheora --enable-libvorbis --enable-libvpx --enable-libx264 --enable-nonfree --enable-x11grab
make
make install
</pre>

= References =

Here are a number of unsorted links

http://techzany.com/2013/09/live-streaming-video-using-avconv-and-a-raspberry-pi/

== FFMPEG ==

http://ffmpeg.org/ffmpeg-all.html#segment_002c-stream_005fsegment_002c-ssegment

https://trac.ffmpeg.org/wiki/StreamingGuide

== Node ==

http://phoboslab.org/log/2013/09/html5-live-video-streaming-via-websockets

https://github.com/phoboslab/jsmpeg

https://github.com/fluent-ffmpeg/node-fluent-ffmpeg

User:Vincib

2015-01-17T23:18:06Z

Vincib: New page: Hi, I'm vincib, aka Benjamin Sonntag, cofounder of La Quadrature du Net, cto of Octopuce, hosting, linux, free software, hacktivist. Here I try to document & do video streaming with cocoa...

Hi, I'm vincib, aka Benjamin Sonntag, cofounder of La Quadrature du Net, cto of Octopuce, hosting, linux, free software, hacktivist.

Here I try to document & do video streaming with cocoadaemon.