Welcome on Planet VideoLAN. This page gathers the blogs and feeds of VideoLAN's developers and contributors. As such, it doesn't necessarly represent the opinion of all the developers, the VideoLAN project, ...
So, after a few crazy weeks, I was taken a bit by RealLife©®, and we've had 3 weeks without report. And this one is late.
The report will be a bit more summarized that usual, and more dense in information, for obvious reasons.
We've added support for codecs with colors in 12bit-depth, in YUV 4:2:0, 4:2:2 and 4:4:4. Of course, nothing can display that yet, but it can happen in some HEVC samples. It will be dithered down before displaying.
A new protocol to control and distribute satellite signals on a LAN called SAT>IP was implemented in a new access module.
There was a lot of work and rework on our adaptive support, notably to change timings and drain, but also to start supporting HLS using mp4 fragments.
Some work on URL and URI was done to support more cases and improve test coverage. 2 new functions called
vlc_uri_compose() were introduced.
At the same time, modifications on the HTTP redirections were merged.
On Windows, we merged the VP9 hardware decoding, using the DxVA APIs.
This code requires very recent video cards to be usable.
Finally, an important work was done to merge the access and stream-filter behavior and semantics. The 2 type of modules still exist, but a large part of the code is now common.
This allows now block-based stream filters.
To achieve this, we now have introduced the
Finally, we added support for MP4 chapters in Unicode, and we fixed some Qt sizing issues with Qt5, a DLL loading potential security issue for Win32, MP4 subtitles size, a WMV integer overflow, a crash in smem, the Qt right-click menu on the playlist, SFTP browsing, and the audio fingerprinter. We also improved the HTTP/2 stack, our TS demuxer when dealing with scrambled content, and a few other minor things I forgot.
On Android, we've pushed 2.0.3, 2.0.4 and 2.0.5 to fix the most important issues and regressions reported.
However, we also added a few features notably:
And we also added, in the main branch, some modifications about preferences, and adding new ones.
This important change introduced quite a bit of cleaning of the code and of the project. :D
On WinRT, we've prepared a MediaCenter Mode for the Xbox 1.
We fixed numerous interface issues and crashes, that were reported in 2.0.1.
A few fixes where pushed also to address issues happening with specific themes or specific resolutions in responsive mode.
That's all for those weeks! There is probably a bit more I forgot about, but you should have the important parts.
See you soon!
10 days ago, we released VLC for Android 2.0.
After a long period of development, we're finally at a release that supports more features than the old 0.9.x versions and the 1.7.x versions.
And last week, we released the new VLC for Windows 10, numbered 2.0 too.
It is a continuation of the work we did for WinRT, the kickstarter, focused on Windows 8.1, Windows Phone 8.1 and Windows RT.
The new application should supersede the old one.
In the last 2 weeks, we improved the ChromeCast support, notably to work on transmitting the pause status and the title between the device and VLC, and we also changed the interface to scan for devices, since it was a bit confusing.
We added support for some uncompressed video format inside MKV, for the AlbumArtist meta-tag inside mp4 and we now support more MicroDVD subtitles styles.
Our new Kwallet module was transitioned from using libKwallet to DBus. This will be better to support both Qt4 and Qt5 applications with libVLC, because those versions are not ABI compatible.
The core gained a new stream FIFO API, with functions like
This change, in addition to the new chained_demux implementation in the core, removes the need for stream_Demux (now removed).
We also improved the security when loading of DLLs on Windows.
And for Android, AudioTrack DTS pass-through was implemented.
Finally, numerous fixes were pushed, notably for Direct3D11, our contribs, some in the core, youtube playback regressions, the Mac OS interface, crashes for MMDevice device, and for the MediaCodec decoders. And more that I forget...
As I said, we released 2.0, and we also pushed 2.0.1 and 2.0.2 to fix the most important crashes reported.
On iOS, we pushed the promised update and we had a few refactoring, notably on the network login view.
That's all for those weeks! Not too bad
See you soon!
This beta is the first version targeting Windows 10 and running on the Universal Windows Platform, aka UWP.
Like the classic VLC, it supports a very large number of formats, but it also has a medialibrary triaging audio and video media, a full player with subtitles, audio/video synchronisation, an audio mini-player and a network shares browser! We also support Cortana, Live Tiles, Pining and Continuum!
The only important missing feature is DVD/Bluray playback and TV tuners that are not yet possible through the UWP APIs.
And of course, it's completely open source, available under the GPLv2.0 license!
You should try it now!
We have a medialibrary, with video management:
and a video player with subtitles, subtitles download, chapters, audio/video sync:
We even support a PiP mode to browse your library while playing a video:
We have, of course, audio management, sorted by albums,
and you can get detailed information about artists.
If you live in a cave, you might prefer our Dark Theme:
The accent color is, of course, modifiable and it will change the VLC cone color too!
We support DLNA/UPnP, Windows Shares, FTP(S), SFTP, NFS protocols to discover and browse your local servers or NAS.
We support some Windows 10 specific features, like Cortana (supported in English and French), Live Tiles, Artists and Album pining to the start menu, Drag & Drop, and Continuum, if you have a Lumia 950 or Lumia 950XL
Under the hood, we use some technologies exclusive to Windows 10, like some DirectX 11.1 features for video and low-latency audio. This should give you enhanced battery life and allow smooth 4K playback.
This release works now on:
but also, when a few remaining issues are fixed:
And, in a few weeks, we will update the application to also support:
NotaBene 0: This application is NOT replacing the desktop application.
NotaBene 1: This application is a new entry on the store compared to the 2 WinRT applications, because Microsoft could not offer a simple upgrade path.
NotaBene 2: Please report bugs!
NotaBene 3: the Xbox one version should be out this summer, when the store is open to 3rd party UWP applications; the Windows 8.1/Windows Phone 8.1 version should come during the next month, if all goes as expected.
Here is a photo of the application running on the Xbox 1:
And a gif on the Hololens:
Today, I was debugging an strange issue in LAVA while trying to boot a board.
I was under the impression that the board was not receiving all the u-boot commands that LAVA was sending.
The serial connection is accessible on the network by ser2net.
I discovered that ser2net can log inputs, outputs or both to a file:
TRACEFILE:trace1:/var/log/ser2net.2000.log 2000:telnet:0:/dev/ttyUSB0:9600 tr=trace1
ser2net will print both inputs and outputs characters to /var/log/ser2net.2000.log.
Going back to my issue, the logfile was:
sseetteennvv aauuttoollooaadd nnoo sseettenv initrd_high '0xffffffff'
When the characters are doubled, it means that ser2net has sent and received that character. That's what I was expected as the board is supposed to echo all characters.
However, the characters are suddenly no longer doubled: the board is not echoing. This does explain why the board was not booting.
The question remains: why is the serial line breaking after a random number of characters.
VLC for Android 2.0 is a major update to VLC for Android, that adds numerous features, notably:
support for new releases of Android, network shares browsing and playback, video playlists, subtitles downloader, pop-up video view and support for multiwindows, an optional history panel, favorite network shares and URLs, and a merge between the Android TV and Android packages.
We also offer faster decoding, using our new asynchronous hardware decoder and we've updated most of our codecs and formats support.
So here is an overview of the new features.
The first good news is that we have decreased the number of dangerous permissions that VLC was using. The only permission that is now considered as dangerous is the access to media files, which is expected for a media player.
On top of that, we support the Android N runtime permissions:
And we still support Android 2.2!
One of the most requested features, since the creation of the application, was the playback of network shares and local servers in VLC. It's mostly done
We support DLNA/UPnP, Windows Shares, FTP(S), SFTP, NFS protocols to discover and browse your local servers or your NAS. And we also detect associated subtitles over the network!
If you want to download subtitles directly from OpenSubtitles, without going to the website, it's now directly integrated in the application:
As we've done for audio, we support basic video playlists.
Another often requested feature, was the popup-video view, mostly for tablets.
It's now implemented and we do support Samsung MultiWindow and LG Dual Window extensions to allow 2 applications on the same screen.
The history feature that was present in the 0.9.x days is also back, but can be disabled.
You can see now all the features in our menu!
We've improved the options of the video player and we simplified the landscape/portrait modes
The Android TV interface has been improved and was merged to the same package as the normal Android one."
Therefore, if your device form-factor is more suited to the TV look or you just prefer it, you can select it in the preferences.
Here is the audio player on the TV:
Finally, we've done a lot of work to support Right-To-Left and Complex Text Layout subtitles. As you can see here with Malayalam:
We also improved the interface to support RTL layouts.
Thanks a lot for the support, hoping that you will love this release.
Like our previous week, most of the work was focused on stabilizing features and bug fixing. Therefore, the changelog will be quite short too. :D
A new type of module was introduced, named
demux filter; they are used to filter or intercept demuxer controls commands and demuxing.
The first use case of this type of module is the ChromeCast demux filter, to show the correct playback time when using the ChromeCast, that we merged this week too.
The 2 SPDIF modules, ac3 and dts have been merged into a single one.
On Android, we've done the same kind of bugfixing as last week, and we have released 2.0.0 RC4 and pushed it on the store.
Not many issues are remaining for the release, now.
On WinRT, we are also in the bugfixing phase, with a lot of commits to make sure the application does not crash too much.
Indeed, we're closing to an open beta release, but the number of crashes was still too high, especially when using the application for a long time.
We also fixed the background audio support on Windows 10 Mobile phones; and reworked the thumbnailer.
The application should be opened in beta to everyone soon.
The iOS application got a few fixes, notably for remote playlists and XDCAM support and we're pushing an update named 2.7.8 this week.
That's it for this week, stay tuned!
After an intense previous week, most of the work was focused on stabilizing features and bug fixing. Therefore, the changelog will be quite short. :D
In the core, we pushed multiple fixes for preparsing and input slaves and we added tests for those features. We also fixed issues in the media discoverer code.
On the modules side, we notably had fixes in the bluray, the oss, the adaptive streaming, the OS X video output and the UPnP modules.
Finally, we added an OpenGL provider for Windows, in order to add back the support for OpenGL visualisations, like projectM.
Same story on Android, we focused on fixing issues, to prepare the release 2.0.
We pushed RC2 and RC3 on the store to fix crashes reported by the first set of devices where the application was pushed.
We redesigned a bit the speed setting, as requested in our Google+ group.
On WinRT, the focus was also on bug fixing and preparing a release. The more important bugs were on Cortana integration and metadata management.
However, we also activated the downloading of subtitles from Internet, notably the OpenSubtitles website.
We also improved the browsing of local network servers, similar to what we did to the Android port.
That's it for this week, stay tuned!
During the week-end, we released VLC 2.2.4, to fix 2 security issues, one in VLC, one in a 3rd party library! It is already released and pushed to our users.
The input core was modified to support network slaves, aka external subtitles or audio tracks, over the network. In the past, it was only working for local subtitles.
The libVLC API added for this is called
The core threading code was improved for recent versions of Windows: it can use futeces and generic semaphore, starting from Windows 8.
We also added the
libvlc_media_player_(get|set)_role calls for libVLC, to set the media role (notification, video, audio) that are reflected to the audio output mixer. This is notably used for the PulseAudio output.
Finally, the preparser was reworked to allow interruption and have a default timeout. Applications can also now cancel their preparsing requests with
The Qt interface received the first renderers selection dialog. You should be able to detect your ChromeCast from this interface, and stream to it.
The UPnP module was improved to support more type of servers, more metadata per item and the code was heavily cleaned. (The library we use is still very bad though).
The OS X interface got new HUD panels and widgets for the dark mode.
Finally, we added the first AppStream Metadata for Linux distributions, a few Qt minor changes, support for GoPro highlights chapters in MP4 and some OS X interface fixes.
Nothing very exciting on Android, just the beta 1.9.13, 2.0.0-rc1 and 2.0.0-rc2 releases, pushed to the store.
For 1.9.13, we mostly focused on activating subtitles over the network, and improving the support for subtitles.
2.0.0-rc1 was mostly focused on fixing the UPnP support and 2.0.0-rc2 was minor fixes for bugs reported by several beta testers.
On WinRT, we reimplemented the playlists management, and the support for playlists in the PlaybackService.
The Search page, that was hidden, is now visible again, and we support favorites for streams and servers, like the Android version.
The notifications and toasts were reworked to be less intrusive, and Cortana support was improved.
Finally, the new equalizer got a facelift.
And of course, numerous bugs were fixed, so we can have a proper release soon!
That's already quite a bit for last week, see you next!
VLC developers will be tending a booth in cooperation with the VideoLAN foundation at the upcoming Hong Kong Open Source Conference on 24-25 June 2016. Follow the link to sign up. See you there.
Reimplementing condition variable with futex on Linux and Windows.
We started the week by adding the support for MPEG-2 and VC-1 hardware decoders on Android in the mediacodec module.
We also fixed some MPEG-4 regressions on this module.
Hugo fixed a few issues on the UPnP module, and mostly added the support for Windows Media Sharing servers, in this module.
We also added support for subtitles over UPnP, using the work done in the core the previous week.
The Matroska demuxer got a few fixes for some regressions, but mostly implemented the
fast-seek option, that is imprecise, but faster than the normal seek. This is useful when computing thumbnails, for example.
Near the end of the week, the core got some important changes on threads manipulation, with the introduction of
vlc_thread_id(). The usage of futeces was introduced in the core: see Rémi's post about it.
The MMDevice audio output on Windows now supports device change events.
The Windows 64bits build will now have high-entropy ASLR activated, which should reduce the possibility of exploitation of security issues.
On Windows, we also fixed the raising issue of the Qt tooltip that we had with Qt5, the 2.2.3 DirectDraw regression and a small D3D improvement when handling large pictures.
Finally, a few H264 annex-B parsing issues were fixed and the video headers were modified to support, in the future, VR videos (nothing working yet).
On the Android side, we're going on fixing issues for the 2.0.0 release.
This week, we:
All this was pushed in the update 1.9.12 on the play store. Hopefully, the 2.0.0 release will come this week.
As for Android, we're focusing on preparing the release, and fixing the biggest bugs people have reported.
On the libVLC backend, we fixed a few performance issues, we added more codecs support, and we improved the UPnP and SMB browsing.
On the interface side, we improved the thumbnailing and parsing process, we fixed numerous bugs that happened when resizing (and Windows 10 Mobile look) and we fixed a few crashes.
We also improved the settings and activated the access to the equalizer.
Hopefully, we'll be able to open the beta to the public soon.
That's all for this week! See you next!
Once again, unfortunately, the report skipped a week
But this report, the 44th report, is quite important for 2 reasons:
This also mean I skipped 8 weekly reports, and did dual-reports for those weeks, which is not too bad, compared to what I hoped to achieve...
The week started by some work on the supported MIME-types for the .desktop file for VLC on Linux, by a Debian developer, which cleaned and merged all our different mimetypes support correctly.
Then, a very large patchset for seeking in the MKV (matroska) files was merged. It rewrites most of the seeking support and builds an index when playing the file. This new code fixes quite a few bugs we had on the matroska support.
We added support for subtitles over the network, with a set of functions named
libvlc_media_slaves_get (and related).
At the same time, we now auto-detect subtitles in networking shares; this is currently tested on SMB and UPnP.
We've had improvements on the Qt main window resizing, and on the playlist model.
The work on DVB scan was continued, notably to support device limits.
Another batch for ChromeCast was merged, mostly focusing on seeking and stopping the stream. We're still missing a few bits, though
And finally, we improved again our adaptive streaming support, our Blurays menus support, added support for vorbis and flac inside MP4, improved WMV metadata and prepared support for streaming output on Android.
The VLC engine has seen many changes for WinRT, in the last few weeks, mostly to merge the existing patches we had pending.
The 3rd party libraries (contribs) were updated and patched to correctly compile for the WinRT/UWP version.
At the same time, we merged numerous patches for the core, the modules and the buildsystem.
We improved quite a bit the Direct3D11 output, both for desktop and the WinRT version. We notably fixed the green line issue and added support for more hardware decoders on Windows Phone/RT.
We also accelerated the chroma conversions when using hardware decoding.
Finally, the WinRT audio module now supports volume changes. This was forbidden in Windows 8 apps, but is allowed in Windows 10.
As we're approaching the 2.0.0 release, the Android port was quite calm.
We pushed 2 beta releases on the store: 1.9.10 and 1.9.11 to fix minor issues, mostly to fix subtitles regression and improve the thumbnails look.
We then added support for the network subtitles and subtitles downloading for network media.
This will be in the next release, that should come soon.
Since then, there were fixes for onedrive support, for subtitles over FTP and for SPDIF pass-through support.
The WinRT port was extremely busy, these past two weeks.
Indeed, we are preparing a beta version named 1.9.0, that would prepare for the first true UWP version, that will be named 2.0.0.
We've added most of the features that you usually see on the Android and iOS versions of VLC, notably UPnP and network shares browsing, support for HTTPS and adaptive streaming, better hardware decoding, dialogs support, as many codecs as the desktop version, and so on.
Moreover, the engine use the runtime 12.0_app instead of the 11.0 one we used on the WinRT version.
On the UI side, we now support correctly Windows 10 integration, with Cortana, drag and drop, tablet mode and a lot of fixes so that the application looks responsive enough on all the devices, from mobile to the Xbox 1. We polished this UI and fixed a few important regressions, notably on the playback and the thumbnailer.
The application is currently in private beta mode, so that the biggest issues are fixed before opening it up.
We released a new version of libbluray, numbered 0.9.3
bd_open_files()function, deprecating old global file system hooks;
That's all for those weeks! See you soon!
I've always been a big fan of static analysis. While I was working with C and C++, I was scanning my code with:
For a longer list of static analyzers for each language, look at wikipedia
As I'm now mostly programming in Python (I'm working on LAVA), I had a closer look at the available static analyzers for this language.
I haven't found any static analyzer for Python as powerful as the one available for C or /C++. However the ones listed in this article must be used on your Python code. That's the bare minimum.
The first tool to run on any Python source code would be pep8. You can also give a try to pep256.
pep8 is a simple tool that only check for coding style. Python does advice the use of a standardize code style: PEP8. It's recommended to use the same coding style in order to keep a common style among the Python community.
However, you can obviously configure pep8 to match your coding style.
def main(): print("Hello" + " World") if __name__ == "__main__": main()
If you run pep8 on this file you will get:
pep8 code.py code.py:2:3: E111 indentation is not a multiple of four
Pylint is more of a static analyzer than pep8 as it actually check for some Python common errors. For instance, on this example:
def append(data=): data.append(1) return data print(append())  print(append()) [1, 1] print(append()) [1, 1, 1]
This is usually not what your are expecting. Pylint will warn you:
pylint code.py No config file found, using default configuration ************* Module code C: 1, 0: Missing module docstring (missing-docstring) W: 1, 0: Dangerous default value  as argument (dangerous-default-value) C: 1, 0: Missing function docstring (missing-docstring) [...] Global evaluation ----------------- Your code has been rated at 0.00/10
As you can see, Pylint is rating the source code (and show the evolution of this rate).
Vulture is specialized in dead code elimination. Due to the dynamic nature of Python, such task is not as easy as it is with C. So don't expect any tool to find all dead code.
def append(data=): data.append(1) return data def unused(): for i in range(0, 10): append() def main(): append() if __name__ == '__main__': main()
Running vulture will give:
vulture code.py code.py:5: Unused function 'unused' code.py:6: Unused variable 'i'
Another useful tool: Pychecker does provide some interesting information. However, it only works with Python2.
code.py:2: Modifying parameter (data) with a default value may have unexpected consequences code.py:6: Local variable (i) not used
I discovered prospector some weeks ago and that's now the only one I'm using. In fact, it uses all the other static analyzers (dodgy, pep257, pep8, pyflakes, pylint, vulture, pyroma, frosted) and provides a nice report.
Messages ======== code.py Line: 1 pylint: dangerous-default-value / Dangerous default value  as argument Line: 6 pylint: unused-variable / Unused variable 'i' (col 8) Check Information ================= Started: 2016-05-13 17:29:31.466860 Finished: 2016-05-13 17:29:31.553182 Time Taken: 0.09 seconds Formatter: grouped Profiles: default, no_doc_warnings, no_test_warnings, strictness_medium, strictness_high, strictness_veryhigh, no_member_warnings Strictness: None Libraries Used: Tools Run: dodgy, mccabe, pep8, profile-validator, pyflakes, pylint Messages Found: 2
My advice would be to run prospector regularly to track common mistakes. It does sometime found real bugs.
I was far from a computer last week, so here are 2 weeks in one.
The previous week, we started to introduce the concept of renderers in VLC.
Those are distant devices displaying audio and/or video, instead of playing it locally. The usual device people know are ChromeCasts, UPnP/DLNA renderers, AirPlay, WiDi or DIAL devices.
A new type of VLC module was introduced:
renderer discovery. Like Service Discovery, they can find those renderers devices on the network, using one of the discovery protocols.
The renderer discovery capability was implemented in our mDNS module.
The Chromecast code was heavily reworked at the same time, and after 4/5 redesigns, we're almost happy with the code
The interface is still missing, but it should come soon!
The work on DVB scanning is still going on. We had numerous patches this week on this topic.
Our mDNS module now supports IPv6 and our MKV demuxer started to get a heavy lifting.
We also had fixes for the TS demuxer and muxer, the libVLC headers, the VideoToolbox decoder, Hurd compilation and improvements on the Direct3D11 video output!
The Android port got 2 more beta releases for 2.0.0: 1.9.9 and 1.9.10.
We added numerous fixes, notably in the popup video view, the binder, keyboard and pad management, title display and the video view.
And of course, improvements for the subtitles download feature.
Hopefully, we will push the release soon.
Cortana is now integrated in the application, so you can ask VLC to launch an album or the last video viewed.
Drag and Drop should now work almost everywhere, and you can drop just a subtitle on a playing video, if you want.
The Stream and the File dialogs have been relifted; the Settings dialog in the same way.
The mini-player and the command bar controller have been merged, together, if you have a Windows Preview build.
On the backend, some work was done on the thumbnailer, and the music and video libraries have been merged into one single library.
Some video information is now pulled from TheMovieDB.
Finally, some work was done to adapt the interface to Windows 10 Mobile.
Soon a release?
On AppleTV, search was implemented for local servers browsing.
And we also got support for repeat on the AppleTV application.
We should get updates on those 2 applications soon, on the App Store.
That's all for those 2 weeks, see you soon!
When running pylint on your Python source code, you might encounter this message:
Using type() instead of isinstance() for a typecheck. (unidiomatic-typecheck)
This message will be raised for this kind of code:
d = dict() if type(d) == dict: print("d is a dict")
The code is valid but pylint does prefer the use of isinstance(). Why is it preferable to use one instead of the other?
The short answer is: this code is unidiomatic. In fact, it does not make use of Duck typing.
In duck typing, an object's suitability is determined by the presence of certain methods and properties (with appropriate meaning), rather than the actual type of the object
In Python, it's preferable to use Duck Typing rather than inspecting the type of an object.
class User(object): def __init__(self, firstname): self.firstname = firstname @property def name(self): return self.firstname class Animal(object): pass class Fox(Animal): name = "Fox" class Bear(Animal): name = "Bear" # Use the .name attribute (or property) regardless of the type for a in [User("John"), Fox(), Bear()]: print(a.name)
The second reason not to use type() is the lack of support for inheritance.
class MyDict(dict): """A normal dict, that is always created with an "initial" key""" def __init__(self): self["initial"] = "some data" d = MyDict() type(d) == dict # False type(d) == MyDict # True d = dict() type(d) == dict # True type(d) == MyDict # False
The MyDict class has all the properties of a dict, without any new methods. It will behave exactly like a dictionary. But type() will not return the expected result.
Using isinstance() is preferable in this case because it will give the expected result:
d = Mydict() isinstance(d, MyDict) # True isinstance(d, dict) # True d = dict() isinstance(d, MyDict) # False isinstance(d, dict) # True
As a conclusion, try to avoid (as much as possible) the use of type or isinstance and prefer Duck Typing.
More information on StackOverflow