JULY 2019 UPDATE: Do you have the brand-new Raspberry Pi 4? Are you using the equally brand-new Raspbian Buster operating system? If so, please see my statement.
GIANT UPDATE – SEPTEMBER 1, 2018: I have now brought the latest versions of the world's leading media engine and player to the Raspberry Pi: FFmpeg 4.0.2 and mpv 0.29.0. The raw source code for these programs was released just a few weeks ago. Many of you probably know this post used to be called "TUTORIAL: Play or Encode High-Quality Video and Audio – with FFmpeg and mpv". But I have now taken things to the next level and combined the best of two worlds – an automated script filled with plain-English annotations that explain exactly what I'm doing at every step. That way, it still serves the purpose of a learning-oriented "tutorial" while also making it extremely simple to get your system up and running as a media powerhouse. It will take less than 5 minutes to prepare my script for execution! Automating the process is not only much faster and less tedious, but it greatly simplifies my instructions and dramatically reduces the chance of making mistakes. Perhaps the biggest enhancement with this latest update is full support for all major forms of live streaming, including the HLS protocol. That means you can watch (and record) live broadcasts from sites like YouTube, Twitch, and the national news outlets of Japan, Germany, Australia and France (please see my screenshots). I have also revised and updated this entire post and all 10 appendices from top to bottom. Ever since December 2017 when I first published my findings, I've been gratified by the many people around the world who have enjoyed my customized build of FFmpeg and mpv. In fact, I was pleasantly surprised that one of the leading engineers at the Raspberry Pi Foundation personally recommended it.
- NASA.jpg (225.96 KiB) Viewed 91822 times
ORIGINAL UPDATE – JANUARY 2018: Although my tutorial has worked perfectly from the very beginning, a small but vocal minority objected to my use of the developmental "firmware" code provided by the rpi-update command. That choice was not dictated by me – it was dictated by essential GPU-related files that are missing in the Raspberry's stock firmware. Although no one reported an issue with this command, I conducted an exhaustive binary compare of the stock and developmental firmware codes – more than 4,000 files in total. Through this effort, I identified 4 tiny files that completely eliminate the need for rpi-update!
DUAL TECHNOLOGIES: FFmpeg and the mpv media player are the two most fundamental video and audio tools in the Raspberry Pi universe. This is equally true in the larger open source and Linux multiverse. On the content-creation and encoding side, nothing beats the power and flexibility of FFmpeg. And on the content-consumption side, nothing beats mpv. Simply put, if you’re a Raspberry Pi user and want to share video or audio with anyone in the world, you need FFmpeg to encode it. And if you want to enjoy high-quality video and audio with a truly capable media player, you need mpv to decode and play it. The two work hand-in-hand – FFmpeg is the "engine" that mpv uses to render video and audio. But having just any version of these programs is NOT sufficient. Instead, both programs must fully support hardware acceleration via the Raspberry’s GPU – using the MMAL API to decode, and the OpenMAX API to encode. There’s only one way to do all that and my script makes it happen.
METHOD: My script uses raw source code to build the latest versions of FFmpeg, the mpv media player, and several advanced encoders – with all necessary Raspberry-specific tweaks. Building from source code may sound complicated, but it’s the only viable way to experience multimedia nirvana on a Raspberry Pi. Anyone with a basic understanding of Linux can get my script set up and ready for execution in less than 5 minutes.
REQUIREMENTS: My script will work on any standard Raspberry Pi 3! It will fully execute and finish in only 54 minutes on the model 3B+, and only 58 minutes on the model 3B. All you need is the completely free Raspbian Stretch operating system (initially released on August 17, 2017). Advanced users should know that the stripped-down "lite" version of Raspbian will not work with my script, nor will it work for those who use the experimental desktop GL drivers (via raspi-config). The bottom line is actually very modest and simple – all you need is the current version of the Raspberry Pi's standard operating system. That's it! I don’t have a Raspberry Pi 2, but since the architecture is very similar, there’s a decent but non-guaranteed chance that my script will also work reasonably well on that device. Other versions of the Raspberry will definitely not work.
WHAT, SPECIFICALLY, WILL THIS SCRIPT GIVE ME? My script will enable your Raspberry Pi 3 to play almost any audio or video on any HDMI-capable TV or monitor – in full screen mode – at all resolutions up to 1920 x 1080. In fact, no media player does a better job than mpv at playing all these files: MP4, WebM, MKV, MOV, MPG, TS, AVI, WMV, MP3, M4A, WAV, FLAC – and many others too numerous to mention! But it goes far beyond just playing files: The advanced encoders and FFmpeg will allow you to encode audio and video into multiple formats – including MP4 videos with the most universally-playable codec pair (H.264 for the video track and AAC for the audio track). You will also be able to choose high-quality, software-based H.264 video encoding – or much faster GPU-accelerated H.264 encoding. FFmpeg is also a powerful "media engine" that will allow you to edit, manipulate, filter and convert audio and video in countless ways. Finally, my script will create freestanding Debian software packages that will allow you to quickly install or re-install everything you need on any Raspberry Pi 3 – in only one minute! That means this script is a one-time thing. Once you’ve run it, you'll be in possession of several state-of-the-art packages that can be rapidly installed at any time.
FULLY TESTED AND PROVEN TO WORK: This is not your typical script or "tutorial". If you look for information on hardware-accelerated mpv on the Raspberry Pi, you will find tantalizing bits and pieces on the Internet – most wrong, some right. But nowhere in the entire Googleverse will you find a complete procedure that actually works. All of the existing documentation is generic and utterly useless in dealing with the Raspberry’s unique CPU and GPU architecture. But I was determined to transform my Pi into a truly capable multimedia machine – so I personally struggled with this, off and on, for several weeks and experienced great frustration. That is why I decided to make this contribution to the Raspberry community instead of keeping it to myself. I tried to write everything in a clear, explicit way that does not "assume knowledge" or skip even the slightest step. I also took the time to fully test and validate my script on a clean install of Raspbian Stretch – the Raspberry Pi’s latest operating system. Of course, all operating systems are subject to change at any point in the future – but at the time of this writing, I can confidently say that every aspect of my script works perfectly!
WHY SO COMPLICATED? In a perfect world, you would simply go to the FFmpeg and mpv official websites and download "the Raspberry Pi version" – then double-click the files and relax as they automatically install. Unfortunately, no such thing exists! You will see Linux versions, but they only run on Intel and AMD-based systems – not the ARM-based architecture that the Raspberry uses. You will also find the raw "source code" for each program – but that’s of no use unless you’re a sophisticated user. And even if you are quite advanced, you’ll almost certainly get tripped-up – because there are a whole series of insanely obscure and undocumented Raspberry-specific issues that must be overcome. Or wouldn’t it be nice if you could just type "sudo apt-get install mpv" and have everything work? For reasons I explain below, that won’t work either.
DETAILS & BACKGROUND: Versions of FFmpeg and mpv are available in the Raspbian software repository. In fact, they are now the "official" encoder and media player of the Debian Stretch distribution of Linux, upon which Raspbian Stretch is based. Unfortunately, due to a perfectly legitimate desire to maintain backward compatibility with older Raspberry models, the repository – accessed via "sudo apt-get install" – only provides a generic build of mpv (and an older version of FFmpeg). As a result, mpv is unable to take advantage of hardware acceleration, and therefore does not leverage the Raspberry’s surprisingly powerful on-board GPU to play video. Instead, all video is rendered "in software" by the CPU. Because of this, videos bigger than 240p will drop frames and "stutter". The stuttering gets so bad that at 1080p, the frame rate drops to 0.5 – half a frame per second! That's 60 times too slow for standard 30 FPS video.
Some might point to OMXPlayer as a potential solution. It is, after all, the Raspberry’s only "official" media player with hardware acceleration support. But the playing options and keyboard controls offered by this aging player are severely limited. More importantly, the other leading video format – the more advanced and newer WebM (VP9) – is simply not supported by OMXPlayer. This is not trivial, given that YouTube – the world’s largest provider of video – only supports two major video formats: WebM (VP9) and MP4 (H.264). In the coming future, when the next-generation open source AV1 codec becomes widely deployed, having access to a state-of-the-art media player will be even more crucial.
The other leading potential contender – the generally well-regarded VLC media player – is only available in a more limited and older "stock" version on the Raspberry platform. Its WebM performance is poor and high-resolution MP4s are subject to frame drops. In fact, at the time of this writing, VLC 3 – the latest version – can't even be compiled to support hardware acceleration on the Raspberry.
And what if you need to encode a video in the ONLY modern format that works on every major browser and media player? That "universal" format is of course an MP4. But keep in mind that an MP4 is merely a "container" and file extension. What really matters is what’s on the "inside" – the actual codecs used to encode the video and audio. On the video side, the only universal choice is H.264 (sometimes referred to as AVC or AVC1). That can be done with the advanced "x264" codec – which is included in my script. And on the audio side, the best universal choice (and MP3 successor) is AAC – specifically, the excellent Fraunhofer implementation of AAC (Advanced Audio Codec). That is also included in my script. My builder code provides the very latest versions of these encoding technologies.
Finally, what if you wish to take advantage of hardware-accelerated H.264 encoding on the Raspberry? For those of you that run my script, you will gain access to the "h264_omx" hardware encoder. This leverages the Raspberry’s GPU to encode H.264 video, resulting in a roughly three-fold speed-up in encoding time (versus the software-based, but higher-quality, x264 codec).
---------
TESTING RESULTS & IMPORTANT TECHNICAL COMMENTARY: As the saying goes, "I ate my own dog food". That means I pretended to be a complete novice and robotically followed my own instructions without any assumed knowledge. All my testing was conducted on a standard Raspberry Pi 3B+ with a clean, brand-new installation of the standard operating system (Raspbian Stretch). My results? Everything worked extremely well! Quite frankly, I continue to be astonished by the performance of such a small and inexpensive computer. With the customized versions of FFmpeg and mpv that my script provides, the Raspberry really shines.
MODEL 3B vs 3B+: I also ran my script and duplicated my testing on the original and slightly slower Raspberry Pi 3B. I did this to guarantee that everything works on the older model as well. With MP4 videos, performance was identical and flawless. This makes sense, given that the GPU is the same on both models. However, since WebM rendering is entirely CPU-based (and because the 3B's CPU is about 14% slower than the 3B+), the frame throughput at 1080p was about 98% to 100% perfect instead of 99.6% to 100% perfect. Given the minor performance difference with WebM videos, it shows that non-CPU factors play an even bigger role when it comes to video formats not supported by the Raspberry's GPU – such as RAM speed and internal bus speed.
60 FPS VIDEO: My original tutorial, which used FFmpeg 3.4 as mpv's "engine", could easily handle 60 FPS MP4 video. However, due to the increased computational demands of FFmpeg 4, my extensive testing has shown the "internal" frame rate for 1080p MP4s is now 48 FPS instead of 60. This, however, is a better-than-even trade-off when you consider that the latest combination now fully supports 1080p live streaming – a significant capability that did not previously exist. That also explains the attributes I have given the "ytdl-format" line in mpv's configuration file. It ensures that a command line like "mpv https://www.youtube.com/watch?v=x_Akn8fUBeQ" will automatically download and play the best possible video that does not exceed mpv's capabilities (above 1080p or above 30 FPS).
WebM (VP9) VIDEO PERFORMANCE: Please see Appendix 10 – Technical Notes and Observations – for extensive commentary on this subject (space is limited on this page).
Here are my testing results – for both mpv (decoding/playing video) and FFmpeg (encoding video). All frame rates are 30 FPS:
---------
MPV: BENCHMARK RESULTS FOR MY SOURCE-BUILT VERSION ON THE RASPBERRY PI 3B+:
PLAYING HIGH-COMPLEXITY VIDEO – 1920 X 1080 – 30 FPS – FULL SCREEN – SIGNIFICANT MOTION AND INTRAFRAME DETAIL:
MP4 video (H.264 video / AAC audio): 0.0% dropped frames (100% perfect)
WebM video (VP9 video / Opus audio): 0.4% dropped frames (99.6% perfect)
PLAYING MID-COMPLEXITY VIDEO – 1920 X 1080 – 30 FPS – FULL SCREEN – LESS MOTION:
MP4 video (H.264 video / AAC audio): 0.0% dropped frames (100% perfect)
WebM video (VP9 video / Opus audio): 0.1% dropped frames (99.9% perfect)
PLAYING HIGH-COMPLEXITY VIDEO – 1280 X 720 – 30 FPS – FULL SCREEN – SIGNIFICANT MOTION AND INTRAFRAME DETAIL:
MP4 video (H.264 video / AAC audio): 0.0% dropped frames (100% perfect)
WebM video (VP9 video / Opus audio): 0.0% dropped frames (100% perfect)
---------
FFMPEG: BENCHMARK RESULTS FOR MY SOURCE-BUILT VERSION ON THE RASPBERRY PI 3B+:
ENCODING HIGH-COMPLEXITY 30 FPS VIDEO FROM A 1920 X 1080 JPEG IMAGE SEQUENCE – SIGNIFICANT MOTION AND INTRAFRAME DETAIL – HIGH QUALITY SETTINGS:
Software-Based H.264 Encoding (CPU): 2.6 FPS (11.5 times slower than real time)
Hardware-Based H.264 Encoding (GPU): 6.3 FPS (4.8 times slower than real time)
ENCODING HIGH-COMPLEXITY 30 FPS VIDEO FROM A 640 X 480 JPEG IMAGE SEQUENCE – SIGNIFICANT MOTION AND INTRAFRAME DETAIL – HIGH QUALITY SETTINGS:
Software-Based H.264 Encoding (CPU): 18 FPS (1.7 times slower than real time)
Hardware-Based H.264 Encoding (GPU): 38 FPS (1.3 times FASTER than real time)
---------
INSTRUCTIONS: Here, finally, are my instructions. The following script uses raw source code to "build" and install the latest versions of FFmpeg and mpv on your Raspberry Pi 3. It also builds 3 advanced encoders – x264 (for H.264 video), Fraunhofer AAC (for AAC audio), and LAME MP3 (for MP3 audio). My entire script will only take about 54 minutes to finish on the model 3B+ and about 58 minutes on the model 3B.
WHAT IF I HAVE A PROBLEM? Carefully re-read my requirements section. I've been surprised at the number of people in the past who skimmed over my tutorial and completely ignored my requirements section or warnings. For example, some went ahead and tried to do it with the "lite" version of Raspbian – even though I explicitly said it will NOT work with the lite version! My script only takes a few minutes to set up, but these instructions definitely require your full attention. It's not the kind of thing you can do while watching your favorite TV show!
WARNING #1: Compiling a million+ lines of source code is very intense and will push all 4 cores in your CPU to their limits for a prolonged period of time. If you do not have adequate heat dissipation, your Raspberry could overheat to above 80° Celsius (176° Fahrenheit) and will throttle-back, lock-up or crash – or even worse, it might quietly corrupt your code in random ways without you even knowing. Then you might get stuck with inexplicable behavior that will be impossible to troubleshoot. Keep in mind that the temperatures I've mentioned are not that far away from boiling water – 100° Celsius / 212° Fahrenheit – so this matter needs to be taken very seriously! [On the model 3B+, Raspbian will automatically throttle the CPU back from 1.4 GHz to 1.2 GHz if you exceed 60°. If it does that, my claimed "54 minutes" will obviously not apply.] In my experience, your Raspberry MUST have a fan if you do heavy-duty compiling. So it’s worth getting a small 40mm fan that attaches to your Raspberry’s case and sits directly above the CPU. The model 3B+ has a superior thermal design to the 3B, so I have found that a tiny fan is sufficient with the newer model. But if you run my script on a 3B, you may also want to have copper heatsinks on the 3 main chips. If your Raspberry doesn't have its own fan, you can carefully hang your Raspberry (by the rugged HDMI cable) in front of a standard house fan. That should "blow away" enough heat to keep your Raspberry cool enough to get through the compiling!
KNOW YOUR CPU's TEMPERATURE: When you're doing heavy compiling, you definitely don't want to fly blind – at least not until you have a good idea of your Raspberry's thermal behavior. So monitor your CPU temperature by doing this: Right-click the Task Bar and click Add / Remove Panel Items. Then click the Add button; scroll down and double-click "Temperature Monitor"; then click the Close button. With just a tiny 40mm fan and no heat sinks, my 3B+ never exceeds 58° Celsius!
WARNING #2: My script takes less than an hour to complete and does not require any human intervention. So you can relax and have a sandwich while your Raspberry does all the hard work! However, be aware that the script is "vulnerable" for the first 2 to 3 minutes. I designed it on purpose to download everything it needs at the beginning – so that once it gets past that point, it's completely independent of the outside world (except for the very end where it downloads youtube-dl and a brief demonstration video). Just know that during the first couple minutes, my script is obviously at the mercy of your Internet connection – and is dependent on all the remote servers being fully up and running (GitHub, RaspberryPi.org, etc.). Since my script has no control over these external factors, it's a good idea to watch it at the beginning to make sure it gets through that phase. If it doesn't, my best advice is to stop everything and delete all 3 script-related folders – Vidware_Downloads, Vidware_Build, and Vidware_Packages – and just re-boot and start all over again at a later time!
WARNING #3: There is no specific risk associated with my script – but I still wish to mention 2 basic items of common sense advice: (1) Always keep a backup copy of any data you would not want to lose and (2) Always have a second working copy of the Raspbian operating system available – or at least the means to easily make one with the aid of a separate computer. I highly recommend the SD Card Copier to make a backup of your existing system in less than 10 minutes – it's a free program that comes with Raspbian. You can access it at Raspberry Menu | Accessories | SD Card Copier.
WARNING #4: Have you already built and installed FFmpeg 3.4.1 and mpv 0.27.0 with my original tutorial? If so, my best advice is to start with a completely fresh, unused copy of the Raspbian operating system if you want to GUARANTEE that everything works perfectly (my script is 100% certified to work on an unaltered copy of Raspbian). But if you're absolutely sure that your existing system is completely functional and totally "normal" in every way – see Step 2, below, for what I mean by that – then you at least need to remove your old installations of FFmpeg and mpv (and the encoders) to prevent any potential conflict. So if that applies to you, run the these 2 simple lines in Terminal before you proceed:
sudo dpkg -r ffmpeg mpv x264-snapshot-20180125-2245 fdk-aac lame libass libvpx opus
sudo rm -r /home/pi/.config/mpv
SCRIPT ETIQUETTE: My script is "polite" and makes a backup copy of any existing file associations you've manually added, as well as any package-pinning preferences you've made (I'm sure most of you haven't pinned any packages anyway). If any of this matters to you, please see my thoroughly annotated script for the location of these backup files.
---------
STEP 1: FULLY UPDATE YOUR OPERATING SYSTEM:
Make sure no programs are running. The only open window on your system should be Terminal. Copy the following line, paste it into Terminal, and hit the Enter key:
sudo apt-get update
NOTE: When the following command asks if you want to continue, press "y" and hit Enter. If the screen goes blank after 10 minutes of keyboard inactivity, you can *CAREFULLY* tap the SHIFT key to reawaken the display:
sudo apt-get dist-upgrade
***Close Terminal
***REBOOT!!
STEP 2: IS YOUR RASPBERRY 3 TRULY NORMAL?
Before you proceed, let's make sure you really have a completely "normal", truly standard, and fully updated version of the Raspbian Stretch operating system! I am especially dubious of systems that have been "upgraded" from Raspbian Jessie to Raspbian Stretch (as opposed to a completely clean install, from scratch, on a blank SD card). This isn't just my opinion – it's the opinion of the Raspberry Pi Foundation in their official release statement. And I quote: "As this is a major version upgrade, we recommend using a clean image; these are available from the downloads page on our site as usual. Upgrading an existing Jessie image is possible, but is not guaranteed to work in every circumstance."
Now, open Terminal and interrogate your system with the following command:
lsb_release -a
You should now see the following output:
No LSB modules are available.
Distributor ID: Raspbian
Description: Raspbian GNU/Linux 9.4 (stretch)
Release: 9.4
Codename: stretch
BIG WARNING: If your results diverge even slightly from the above output, please don't bother using my script – unless of course you live in the future and the version number has since moved to 9.5 or greater. Even then, there are no guarantees – I obviously have no control over the behavior of future operating systems! Also, if it says "9.4" but does not explicitly say "stretch", please abandon this tutorial and carefully review my "requirements" section and what I just said about Jessie. Even if your results precisely match the above output, be on notice that your success is still questionable if you have merely "upgraded" from Jessie. On top of that, even if you superficially meet all the requirements I'm describing here, your success is still questionable if you've been "tinkering" with your Raspberry – modifying system files, changing fundamental system settings, or "experimenting" with other media players. If that's the background of your Raspberry – especially if you're not a total expert – it's probably a good idea to start with a completely clean install of your operating system if you want my script to run without a hitch!
I must also assume that you have not "monkeyed" with the default user name or home path. In other words, I must assume that when you launch Terminal, it automatically opens inside the standard home path – /home/pi. My script is based on very reasonable and basic assumptions, so if you've changed all that you'll need to carefully edit my entire script without making a single mistake – or better yet, just nuke your entire system and make it NORMAL!
Now, if you're truly certain your Raspberry Pi 3 is completely "normal" and meets all the above requirements, you may proceed!
STEP 3: SET YOUR RASPBERRY’S GPU MEMORY ALLOCATION TO 128 MB:
The default GPU memory setting on the Raspberry is 64 MB. Mpv requires 128 MB or it will not work – so let's change that setting:
Click the Raspberry Menu | Preferences | Raspberry Pi Configuration | Performance Tab
Change "GPU Memory" to 128
Click OK | Click No to reboot (You’ll be rebooting soon anyway – so rebooting now is not necessary.)
STEP 4: TRANSFER MY SCRIPT TO YOUR COMPUTER!
Open Terminal and run this command:
leafpad vidware
You should now see the Raspberry's standard text editor (known as leafpad). That's what you'll be pasting my script into.
Now, carefully copy my entire script – which appears below – and paste it into the empty leafpad document. Make certain you successfully copied everything and didn't accidentally leave out a few characters or lines at the top or bottom. After you've verified everything, press ctrl + s to save the file and then close leafpad. The file should automatically be called "vidware".
Now, flip back to Terminal and enter this command line – it will make my script executable:
chmod u+x vidware
STEP 5: REBOOT YOUR RASPBERRY AND RUN MY SCRIPT!
OK, the moment of truth has arrived! As long as you followed my instructions to the letter, your Raspberry will automatically create a whole bunch of free presents for you in less than one hour!
GIVE YOUR RASPBERRY A FULL MINUTE AFTER IT BOOTS UP TO FULLY "CALM DOWN" AND RELAX BEFORE YOU RUN MY SCRIPT! And this should be obvious, but I'll say it anyway: After you've given your system a fresh reboot, the only "program" running on your Raspberry should be your Terminal screen! That's it! My script is very intense and requires the full attention of your system.
To run my script, simply open Terminal and run the following command line. Please memorize it or write it down on a piece of paper. After your system has had a fresh reboot, do NOT re-launch the memory-hogging web browser to look at these instructions again!
bash vidware
-----------------------------------------------------------------
***START OF SCRIPT – DO NOT COPY THIS LINE OR THE DASHED LINES***
-----------------------------------------------------------------
#!/bin/bash
##### Vidware_Downloads: My script philosophy is to keep things clean and simple. That's why my first step is to create 3 different folders to keep the main elements of my script completely separate from each other. Before anything can be built, we first have to download 6 files in the form of "stable release tarballs". This is the raw source code my script will use to build the 6 programs. We also need 4 GPU-related files from the Raspberry Pi Foundation's official GitHub site that provide OpenGL ES and EGL support (they allow mpv to "talk" to the Raspberry's VideoCore GPU and thus facilitate hardware acceleration). Finally, we need a "waf" file that will allow us to build mpv. All of this will go inside the "Vidware_Downloads" folder – which we're creating with the mkdir command:
mkdir Vidware_Downloads
##### Vidware_Build: This is the folder where all our "building" will take place – the folder where the raw source code of 6 programs will be compiled and transformed into working software. The "primary" programs are FFmpeg and mpv. But my script also builds a mandatory library called libass – a subtitle renderer that mpv requires. It also builds an advanced H.264 video encoder (x264) and two advanced audio encoders (Fraunhofer AAC and LAME MP3):
mkdir Vidware_Build
##### Vidware_Packages: This folder will remain empty until the very end of the script. When the script is about 95% complete, all 6 programs will be fully built, installed, and "packaged". These packages are free-standing Debian installers (commonly known as .deb files). What makes these so incredibly useful is that at any time, you can use them to automatically install (or re-install) all the programs on another Raspberry or your existing Raspberry in the future – IN ONLY ONE MINUTE! No scripts or "building" required! My script will conveniently place all of them in the Vidware_Packages folder – so be sure to back them up to a safe place!
mkdir Vidware_Packages
##### I've discovered an odd quirk about checkinstall: If we don't manually create a standard usr doc path before running it, checkinstall will fail to install some of our programs. This affects the LAME MP3 encoder – but not having the path up to "doc" also affects FFmpeg (even if you don't build or install LAME). This command line takes care of that:
sudo mkdir -p /usr/share/doc/lame
##### You'll see a lot of "echo" commands in my script. Why? Because I like VISUAL SEPARATION. A simple echo command inserts a blank line in Terminal's output:
echo; echo
##### The echo command is also the tool I'm using to "print" information on the Terminal screen – such as letting the user know that we're about to download the tarballs. I also "pipe" the output of echo through the "fold" command with the "-s" option. This ensures my longer sentences are properly "word wrapped" and that my words aren't abruptly cut in half when they hit the edge of your Terminal screen:
echo "------------------------------"
echo "Now downloading the source code tarballs and other essential files for building FFmpeg, mpv, and the 3 advanced encoders. At a connection speed of 1 MB per second, it will take less than 20 seconds." | fold -s
echo "------------------------------"
echo
##### We're about to download all the files that the script needs. It may look like a lot, but the grand total is less than 18 MB! This is quite impressive when you consider that FFmpeg alone contains more than one MILLION lines of source code! Before we do the downloads, however, we need to change our current working directory to the Vidware_Downloads folder with the cd command:
cd /home/pi/Vidware_Downloads
##### This is where my script downloads the 11 files it needs. At the time of this writing – August 2018 – all URLs link to the most recent versions available. Be careful if you think you can simply update these links to get even more recent versions in the future! Other parts of my script make specific assumptions about these particular versions. So unless you fully understand all aspects of my script, you definitely don't want to do that!
wget -q --show-progress --no-use-server-timestamps https://ffmpeg.org/releases/ffmpeg-4.0.2.tar.bz2
wget -q --show-progress --no-use-server-timestamps https://github.com/mpv-player/mpv/archive/v0.29.0.tar.gz
wget -q --show-progress --no-use-server-timestamps https://github.com/libass/libass/releases/download/0.14.0/libass-0.14.0.tar.gz
wget -q --show-progress --no-use-server-timestamps https://download.videolan.org/x264/snapshots/x264-snapshot-20180831-2245-stable.tar.bz2
wget -q --show-progress --no-use-server-timestamps https://downloads.sourceforge.net/opencore-amr/fdk-aac-0.1.6.tar.gz
wget -q --show-progress --no-use-server-timestamps https://downloads.sourceforge.net/lame/lame-3.100.tar.gz
wget -q --show-progress --no-use-server-timestamps https://github.com/raspberrypi/firmware/raw/master/hardfp/opt/vc/lib/libGLESv2.so
wget -q --show-progress --no-use-server-timestamps https://github.com/raspberrypi/firmware/raw/master/hardfp/opt/vc/lib/libEGL.so
wget -q --show-progress --no-use-server-timestamps https://github.com/raspberrypi/firmware/raw/master/hardfp/opt/vc/lib/pkgconfig/glesv2.pc
wget -q --show-progress --no-use-server-timestamps https://github.com/raspberrypi/firmware/raw/master/hardfp/opt/vc/lib/pkgconfig/egl.pc
wget -q --show-progress --no-use-server-timestamps https://waf.io/waf-2.0.9
##### For backup purposes – and for mental clarity – I deliberately decided not to "wget" the files directly into their ultimate destinations. Instead, I wanted all the downloads to first be consolidated into the Vidware_Downloads folder – and then copy them over, later on, into wherever they need to be. So that's what I'm doing here. Sudo is required, by the way, because the opt parent folder (and its children) are owned by user "root", not "pi". If we didn't add the "sudo", we would get a "permission denied" error:
sudo cp libGLESv2.so /opt/vc/lib
sudo cp libEGL.so /opt/vc/lib
sudo cp glesv2.pc /opt/vc/lib/pkgconfig
sudo cp egl.pc /opt/vc/lib/pkgconfig
##### The script downloaded version 2.0.9 of waf (the version that mpv 0.29.0 expects). But mpv also expects the file to simply be named "waf", not "waf-2.0.9". That's why I'm renaming it here with the mv command. Finally, since waf is a Python script that needs to be executed in order to build mpv, I'm using the chmod command to make it executable by the user that owns the file (which in this case is the user named pi):
mv waf-2.0.9 waf
chmod u+x waf
##### This makes an exact copy of our 6 source code tarballs (for FFmpeg, mpv, etc.) and places them inside the Vidware_Build folder. Some of the tarballs end in tar.gz, while others end in tar.bz2 – hence the 2 separate lines:
cp *.gz /home/pi/Vidware_Build
cp *.bz2 /home/pi/Vidware_Build
##### We're pretty much all done with the Vidware_Downloads folder at this point – so we now need to make sure the script is performing its actions inside the Vidware_Build folder. That's why we cd into it. We then need to "unzip" the 6 source code tarballs into folders – that's what the 2 "ls" lines with the xargs command does (for technical reasons, you can't use a simple asterisk wildcard to unzip multiple tarballs in the same folder). Finally, I delete all the tarballs in the build folder with the rm command. Why? Because we already have the original copy of them in our Vidware_Downloads folder – so there's no reason to clutter things up with duplicate tarballs!
cd /home/pi/Vidware_Build
ls *.gz | xargs -n1 tar xzf
ls *.bz2 | xargs -n1 tar jxf
rm *.gz
rm *.bz2
##### I don't want to keep seeing "fdk-aac-0.1.6" as the source code folder name, for example. That's just confusing. Instead, I just want to see "aac" – because that's what it really is. It's the AAC audio encoder! That's why I'm simplifying all the source code folder names by renaming them with the mv command:
mv ffmpeg* ffmpeg
mv mpv* mpv
mv x264* x264
mv fdk* aac
mv lame* mp3
mv libass* libass
##### We can now copy over the waf file into the mpv source code folder:
cp /home/pi/Vidware_Downloads/waf /home/pi/Vidware_Build/mpv
##### This is where we install the dependencies we need to build all 6 pieces of software – via "sudo apt-get install". Read my statement in the echo line for more detail:
echo; echo
echo "------------------------------"
echo "Now downloading and installing the dependencies – essential packages from the official Raspbian repository that are needed to build the programs. At a connection speed of 1 MB per second, it will take less than 50 seconds to download. It will then take about 5 minutes for your system to install all the packages." | fold -s
echo "------------------------------"
echo
sudo apt-get install -y automake checkinstall libsdl2-dev libva-dev libluajit-5.1-dev libgles2-mesa-dev libtool libvdpau-dev libxcb-shm0-dev texinfo libfontconfig1-dev libfribidi-dev python-docutils libbluray-dev libjpeg-dev libtheora-dev libvorbis-dev libgnutls28-dev linux-headers-rpi2 libomxil-bellagio-dev xdotool libcdio-cdda-dev libcdio-paranoia-dev libdvdread-dev libdvdnav-dev libbluray-dev
##### This begins the "software building" phase of my script. We're configuring and compiling the source code for our first program – the advanced x264 video encoder. That's what people mean by "building" a program. In the "./configure" line, we're enabling and disabling various options that will customize the build in the manner necessary for everything to work. We then compile the program with the "make -j4" command – which is quite impressive given that the "j4" means that all 4 cores inside the Raspberry's CPU will be computing simultaneously! For more information on how to use the encoders with FFmpeg, please see my extremely detailed appendices. After the x264 encoder is fully built, I use the checkinstall command to both install the program and "package it up" into the extremely useful .deb installer packages I mentioned earlier. The final line – sudo ldconfig – is essential in making sure the "shared libraries" are properly recognized.
echo; echo
echo "------------------------------"
echo "Now building the x264 video encoder. This will take about 2 to 3 minutes." | fold -s
echo "------------------------------"
echo
cd /home/pi/Vidware_Build/x264
./configure --prefix=/usr --enable-shared --disable-opencl --extra-cflags="-march=armv8-a+crc -mfpu=neon-fp-armv8 -mtune=cortex-a53"
make -j4
sudo checkinstall -y --pkgname x264 --pkgversion 0.155 make install
sudo ldconfig
##### We now move on to build and install the Fraunhofer AAC audio encoder. I don't need to say much here because I already described the basic outline of the "building from source code" process in my above comments about the x264 encoder.
echo; echo; echo
echo "------------------------------"
echo "Now building the Fraunhofer AAC audio encoder. This will take about 3 to 4 minutes." | fold -s
echo "------------------------------"
echo
cd /home/pi/Vidware_Build/aac
./autogen.sh
./configure --prefix=/usr --enable-shared
make -j4
sudo checkinstall -y --pkgname fdk-aac --pkgversion 0.1.6 make install
sudo ldconfig
##### Now we build and install the LAME MP3 audio encoder:
echo; echo; echo
echo "------------------------------"
echo "Now building the LAME MP3 audio encoder. This will take about 1 minute." | fold -s
echo "------------------------------"
echo
cd /home/pi/Vidware_Build/mp3
./configure --prefix=/usr --enable-shared
make -j4
sudo checkinstall -y --pkgname mp3lame --pkgversion 3.100 make install
sudo ldconfig
##### Now we build and install the libass subtitle renderer (mpv will not work without this software library):
echo; echo; echo
echo "------------------------------"
echo "Now building the libass subtitle renderer. This will take about 1 minute." | fold -s
echo "------------------------------"
echo
cd /home/pi/Vidware_Build/libass
./configure --prefix=/usr --enable-shared
make -j4
sudo checkinstall -y --pkgname libass --pkgversion 0.14.0 make install
sudo ldconfig
##### Now we build and install FFmpeg! This is the very powerful media "engine" at the center of everything we're doing. The last 3 "--enable" lines under "./configure" enable FFmpeg to access the 3 advanced encoders – x264, Fraunhofer AAC, and LAME MP3. Compiling a million+ lines of code is INTENSE and could easily overheat your CPU. Your Raspberry must therefore have its own small fan or an external fan blowing on it. Please see the explicit warnings on this subject in my instructions!
echo; echo; echo
echo "------------------------------"
echo "Now preparing to build FFmpeg. This will take about 2 minutes." | fold -s
echo "------------------------------"
echo
cd /home/pi/Vidware_Build/ffmpeg
./configure \
--prefix=/usr \
--enable-gpl \
--enable-nonfree \
--enable-static \
--enable-libtheora \
--enable-libvorbis \
--enable-omx \
--enable-omx-rpi \
--enable-mmal \
--enable-libxcb \
--enable-libfreetype \
--enable-libass \
--enable-gnutls \
--disable-opencl \
--enable-libcdio \
--enable-libbluray \
--extra-cflags="-march=armv8-a+crc -mfpu=neon-fp-armv8 -mtune=cortex-a53" \
--enable-libx264 \
--enable-libfdk-aac \
--enable-libmp3lame
echo; echo; echo
echo "------------------------------"
echo "Now building FFmpeg. This will take about 24 minutes on the Raspberry 3B+ (and 2 or 3 minutes longer on the 3B)." | fold -s
echo "------------------------------"
echo
make -j4
echo; echo; echo
echo "------------------------------"
echo "Now installing FFmpeg. This will take about 7 minutes." | fold -s
echo "------------------------------"
echo
sudo checkinstall -y --pkgname ffmpeg --pkgversion 4.0.2 make install
sudo ldconfig
##### Now we build and install mpv. Unlike the prior builds which were fairly straightforward, I'll add a few extra comments here – because I had to do quite a bit of arcane tweaking to successfully "port" mpv to the Raspberry platform with full GPU-based hardware acceleration.
echo; echo; echo
echo "------------------------------"
echo "Now preparing to build mpv. This will take about 1 minute." | fold -s
echo "------------------------------"
echo
cd /home/pi/Vidware_Build/mpv
##### In this section, I'm using the sed command to manipulate mpv's raw source code before we build it. The first edit specifically targets line 767 of mpv's wscript file. The wscript file contains the "building instructions" for mpv. There are more than 1,100 lines of code in the file, but only 18 of them are directly related to the Raspberry. The line I'm editing makes reference to a generic OpenGL ES "linkflag". With the sed command, I'm doing a "search & replace" so that it will now make reference to the Broadcom-specific version of the linkflag (Broadcom is the manufacturer of the Raspberry's VideoCore GPU). Beginning with the next line, I delete an entire stanza (13 lines) of audio-related source code and then replace it with 20 lines of modified and expanded code. Specifically, it affects how mpv interacts with the ALSA framework. Without this change, mpv would throw various audio-related "[ao/alsa]" errors. Hat tip: My ALSA source code patch combines the ideas of mpv contributor "orbea" and user "yumkam" on mpv's official GitHub site. And then we have the final sed line – it serves absolutely no purpose other than to give a bit of credit to yours truly!
sed -i_BACKUP '767s|GLESv2|brcmGLESv2|g' /home/pi/Vidware_Build/mpv/wscript
sed -i_BACKUP '939,951d' /home/pi/Vidware_Build/mpv/audio/out/ao_alsa.c
sed -i '939i\
\
\
static int get_space(struct ao *ao)\
{\
int err;\
struct priv *p = ao->priv;\
\
snd_pcm_state_t state = snd_pcm_state(p->alsa);\
snd_pcm_sframes_t space = state == SND_PCM_STATE_SETUP || state == SND_PCM_STATE_PAUSED\
? p->buffersize : snd_pcm_avail(p->alsa);\
if (space < 0) {\
if (space == -EPIPE) { // EOF\
err = snd_pcm_prepare(p->alsa);\
CHECK_ALSA_ERROR("pcm recover error");\
return p->buffersize;\
}\
\
MP_ERR(ao, "Error received from snd_pcm_avail (%ld, %s)!\\n",\
space, snd_strerror(space));\
\
// request a reload of the AO if device is not present,\
// then error out.\
\
' /home/pi/Vidware_Build/mpv/audio/out/ao_alsa.c
sed -i_BACKUP '143s|built on|built by the RPi_Mike script on|g' /home/pi/Vidware_Build/mpv/player/main.c
##### The next 3 lines temporarily define the proper paths for 3 "environmental variables". Without these, mpv will not compile.
export LIBRARY_PATH=/opt/vc/lib
export PKG_CONFIG_PATH=/opt/vc/lib/pkgconfig
export CPATH=/opt/vc/include
##### This next section is fairly straightforward. This is where we build and install mpv! The only noteworthy point is that instead of using the "make" system to do our building like all the other programs in this script, we're using the "waf" system. That simply reflects the preferences of the mpv developers.
./waf configure --prefix=/usr --enable-rpi --enable-cdda --enable-dvdread --enable-dvdnav --enable-libbluray
echo; echo; echo
echo "------------------------------"
echo "Now building mpv. This will take about 2 minutes." | fold -s
echo "------------------------------"
echo
./waf build -j4
echo; echo; echo
echo "------------------------------"
echo "Now installing mpv. This will take about 1 minute." | fold -s
echo "------------------------------"
echo
sudo checkinstall -y --pkgname mpv --pkgversion 0.29.0 ./waf install
sudo ldconfig
##### This is where we create mpv's configuration file that controls how mpv behaves with ALL video and audio. Please see the full version of Appendix 1 for details; also see the testing section for commentary on the "ytdl-format" line. NOTE: The "alsa-buffer-time" completes the fix to the ALSA issue I described earlier. It defines an audio buffer time of 800,000 microseconds (8/10 of a second). Through extensive testing, I found that this was the final step needed to get mpv and ALSA to play nice together.
mkdir -p /home/pi/.config/mpv
echo "--fullscreen
rpi-background=yes
screenshot-format=png
ytdl-format=bestvideo[height<=?1080][fps<=?30][vcodec!=?vp9]+bestaudio/best
--alsa-buffer-time=800000" > /home/pi/.config/mpv/mpv.conf
##### I didn't want users of my script to have to go through the 10-step "Open With" process in File Manager – over and over again – to associate every common type of video and audio file with mpv. So to save everyone a lot of time and eliminate this error-prone task, my script does it automatically! The first line demonstrates proper "etiquette" – before it creates the new associations, it first backs up your original mimeapps.list file (just in case you'd like to review or re-add your initial file associations). I then associate the following video and audio file types with mpv: MP4, WebM, MKV, TS, MOV, AVI, WMV, MPG, WAV, MP3, M4A, and FLAC.
cp /home/pi/.config/mimeapps.list /home/pi/.config/mimeapps.list_BACKUP &> /dev/null
echo "[Added Associations]
video/mp4=mpv.desktop;
video/webm=mpv.desktop;
video/x-matroska=mpv.desktop;
video/mp2t=mpv.desktop;
video/quicktime=mpv.desktop;
video/x-msvideo=mpv.desktop;
video/x-ms-wmv=mpv.desktop;
video/mpeg=mpv.desktop;
audio/x-wav=mpv.desktop;
audio/mpeg=mpv.desktop;
audio/mp4=mpv.desktop;
audio/flac=mpv.desktop;
text/plain=leafpad.desktop;
[Default Applications]
video/mp4=mpv.desktop
video/webm=mpv.desktop
video/x-matroska=mpv.desktop
video/mp2t=mpv.desktop
video/quicktime=mpv.desktop
video/x-msvideo=mpv.desktop
video/x-ms-wmv=mpv.desktop
video/mpeg=mpv.desktop
audio/x-wav=mpv.desktop
audio/mpeg=mpv.desktop
audio/mp4=mpv.desktop
audio/flac=mpv.desktop
text/plain=leafpad.desktop
[Removed Associations]" > /home/pi/.config/mimeapps.list
##### Raspbian places its overall file association "system" in 2 separate locations. The items above act as a kind of pointer to the item below. The two work hand-in-hand. The following stanza generates a special kind of file known as a "desktop" file that ends with the ".desktop" extension – but also has an "alias" (in this case, "MPV") and an executable line that tells it what to do. My complicated use of bash -c and xdotool is the result of hours of testing – to guarantee that you never lose keyboard control of mpv, due to other windows stealing "focus" from mpv's Terminal window. You see, mpv relies upon an active Terminal window "behind the screen" to detect the keyboard inputs which allow you to control the video or audio being played. Of course, if you actively do things to lose keyboard control – like hitting alt + tab or randomly clicking the screen with your mouse – there's nothing I can do about that!
echo "[Desktop Entry]
Type=Application
Name=MPV
Exec=lxterminal -t mpv_control -e bash -c \"sleep 0.25; xdotool search --name mpv_control windowactivate; mpv %f\"
NoDisplay=true
Icon=mpv" > /home/pi/.local/share/applications/mpv.desktop
##### This section "pins" the advanced versions of the programs my script just built. Without doing this, anytime you run a standard system update via "sudo apt-get upgrade" or "sudo apt-get dist-upgrade", the Raspbian package manager might wrongly think the newly-built programs are old and therefore need to be "upgraded". They might then be overwritten with the older, more primitive versions that exist in the Raspbian repository! Pinning them, in effect, says to your system's packager manager: "Don't touch these programs – leave them alone!" As per standard etiquette, I first back up your preferences file – on the remote chance you've been pinning other packages. Hat tip to "rpdom" for his pinning suggestion.
sudo cp /etc/apt/preferences /etc/apt/preferences_BACKUP &> /dev/null
echo "Package: ffmpeg
Pin: version 4.0.2-1
Pin-Priority: 1001
Package: mpv
Pin: version 0.29.0-1
Pin-Priority: 1001
Package: x264
Pin: version 0.155-1
Pin-Priority: 1001
Package: fdk-aac
Pin: version 0.1.6-1
Pin-Priority: 1001
Package: mp3lame
Pin: version 3.100-1
Pin-Priority: 1001
Package: libass
Pin: version 0.14.0-1
Pin-Priority: 1001" | sudo cp /dev/stdin /etc/apt/preferences
sudo chmod 644 /etc/apt/preferences
##### In some ways, this next section just might be the coolest part of the entire script. That's because it takes the TRILLIONS of computations the script just performed – distilled into 6 tiny packages – and neatly places them in the Vidware_Packages folder. They contain everything you need to reconstitute all the programs on any Raspberry 3B or 3B+ IN ONLY 1 MINUTE! So when the script is all done and the demonstration video has played, be sure to back up the 6 .deb files to a safe location.
echo; echo; echo
echo "------------------------------"
echo "Almost finished! The Debian package files are now in the Vidware_Packages folder. You can use them at any time in the future to install all the programs my script just built! Now downloading youtube-dl and a brief 1080p demonstration video from YouTube. All of this should take less than 2 minutes. After the looped video starts playing, feel free to press the q key to quit." | fold -s
echo "------------------------------"
echo
find /home/pi/Vidware_Build -name '*.deb' -exec mv -t /home/pi/Vidware_Packages {} +
##### This final section does 3 simple things: First, it downloads and installs the latest version of youtube-dl. If you already have it on your system, it will upgrade it (if necessary). If you don't have it, it will make sure you that you do. At that point, youtube-dl will download a very brief 1080p demonstration video from YouTube. And then comes the final act – mpv will play the video several times in a loop! Press q to quit at any time.
sudo pip install --upgrade youtube_dl
echo; echo
cd /home/pi
youtube-dl -f 137+140 --no-mtime -o Neutron_Stars_Colliding_1080p.mp4 https://www.youtube.com/watch?v=x_Akn8fUBeQ
echo; echo
mpv -version
echo
mpv --loop=9 Neutron_Stars_Colliding_1080p.mp4
---------------------------------------------------------------
***END OF SCRIPT – DO NOT COPY THIS LINE OR THE DASHED LINES***
---------------------------------------------------------------
---------
APPENDIX 1: MOST ESSENTIAL MPV KEYBOARD CONTROLS & OPTIONS:
f key: Toggle the video between full screen and actual size
space bar: Toggle the video (or audio) between pause and play
left and right arrow keys: Rewind and fast-forward by 6 seconds
up and down arrow keys: Rewind and fast-forward by 1 minute
9 and 0 keys: Lower and raise the volume
o key: Make the on-screen display briefly appear to show time remaining, etc.
[ and ] keys: Speed up or slow down the video
q key: Quit out of the video (or audio)
WARNING: I had to greatly abbreviate this appendix to free up room on this page. See below for how to access the FULL versions of all of my appendices!
---------
WOULD YOU LIKE TO DOWNLOAD AND RETAIN HIGH-QUALITY VIDEOS FROM HUNDREDS OF WEBSITES WITH YOUTUBE-DL? OR DO YOU WANT TO PLAY ONLINE VIDEOS AUTOMATICALLY WITHOUT ANY MANUAL DOWNLOADING? OR MAYBE YOU WANT TO STREAM LIVE BROADCASTS FROM AROUND THE WORLD. PERHAPS YOU WOULD YOU LIKE TO ENCODE MP4 VIDEOS WITH FFMPEG? OR DO YOU WANT TO INSTALL EVERY PROGRAM MY SCRIPT BUILT ON ANOTHER RASPBERRY IN JUST A FEW MINUTES? OR MAYBE YOU'RE LOOKING FOR TROUBLESHOOTING TIPS? EACH POST IS LIMITED TO 60,000 CHARACTERS, SO I HAD TO FREE UP SPACE ON THIS PAGE BY REMOVING MOST OF APPENDIX 1 AND ALL OF APPENDICES 2, 3, 4, 5, 6, 7, 8, 9 AND 10. FORTUNATELY, ALL OF THE APPENDICES CAN NOW BE FOUND AT THIS SEPARATE POST (WHICH IS STILL PART OF THE SAME THREAD):
APPENDICES: Build FFmpeg and mpv – Automatically in 54 Minutes!
---------
KEYWORDS: Raspberry Pi 3, RPi3, Pi3, 3B, 3B+, RPi, FFmpeg, mpv, tutorial, 1080p, MP4, H.264, AAC, WebM, VP9, Opus, x264, LAME, MP3, Fraunhofer, GPU, VideoCore, MMAL, OpenMAX, OMX, video, audio, encoding, decoding, compiling, source code, hardware acceleration
