October 2019

Kodi News

New Nvidia Shield Pro + Stick Guide [2020 Version]

Nvidia has announced the brand new Nvidia Shield Pro and Nvidia Shield TV Stick and both are available right now! This guide has all of the details, information, and tips for the new Shield, the best Kodi box available today. The release date for the new Nvidia boxes was October 28th, 2019.   Nvidia Shield […]

The post New Nvidia Shield Pro + Stick Guide [2020 Version] appeared first on Kodi Tips.

DevCon 2019 – Belgrade – Part III

So, here we are, the third and final day of DevCon 2019. It’s likely to be a short list of topics this morning before some people head home while those who remain use the time together to write some fabulous code. So, let’s get straight to business.


We kicked off with kwiboo and jernej (from the LibreELEC team) talking about HDR support on Linux. This goes way beyond Kodi, as it’s kernel-level work to improve GPU support; this then ripples through the operating system before finding its way to Kodi via V4L2 and ffmpeg. We’ve been working mostly with the Intel team to complete support for their chipset, but there’s also basic work in place for Allwinner, Amlogic and Rockchip. This means that we’re well on the way to having a common implementation across all major chipsets that are likely to be running Linux. The industry-wide, concerted focus on V4L2 (driven significantly by Google/ChromeOS) also means that we can finally strip away large chunks of proprietary, vendor-specific code as all of these chipsets move to a common, standardised API model. We’ve grudgingly tolerated these for a long time, but they make maintaining and updating functionality so much more difficult when you need to consider dozens of different code paths, so we’ll be glad to see the back of them.

A couple of topics that took some time but didn’t really make it to the final sessions, so perhaps we’ll come back to them later: roles and responsibilities within the Board, the overall Kodi architecture and how it could be improved, potential for web browser support in Kodi. Just headings for the moment, so don’t get too excited.

Following this, we spent a chunk of time on introspective activities: admin rights, system and application access, social media access, password lockers, two-factor authentication, and similar. We also talked about Team matters: new members, absent friends, acknowledgements. Maybe not really interesting to the outside world, but still stuff we need to worry about if we’re to keep everything running smoothly.

And now it’s time for what a room full of developers (“a segfault of programmers”, perhaps?) with laptops does naturally. All around me, I can see screens scrolling as code compiles, the brightly-coloured syntax highlighting of IDEs, the transient flash of windows and terminal prompts as people cycle between them. The mob is talking animatedly about CODECs, rendering planes, operating systems, APIs, kernel calls. In the distance, a heated debate begins about the relative merits of Linux distros. There’s a constant murmur of noise, the combination of conversation, keyboard taps and error sounds. The mood for the rest of the day is set… let’s hope no-one breaks anything important… ¯\_(ツ)_/¯

So, that’s it for this year. Thanks for listening, and I hope you’ve found these posts informative. More than that, though, thanks for continuing to support Kodi!

All the best,

Team Kodi.


DevCon 2019 – Belgrade – Part II

Morning, all. It’s a beautiful day here, and we’re just waiting for the last few latecomers to arrive before another day of DevCon…


We kicked off with Python 3, following on from yesterday’s conversation. The general consensus was to get this merged and live with any minor breakage – we need to get this done, and can’t wait for absolutely every add-on to be updated before we merge. This shouldn’t be a surprise to anyone, after all.

The conversation then quickly shifted to sarbes talking about features that would make life much easier from a Python developer’s perspective. These are really around how the core code handles items, lists and displays, and how this could be modified to improve the user experience (e.g. pagination of long lists). The obvious affect is on lists of Internet content, but it would also improve PVR/EPG display, searching, and others. Similarly, allowing add-ons to specify viewtypes or just know more about what views the user prefers would make things more consistent and usable. Other ideas included subtitle support for use within add-ons, and some kind of URI mechanism so an add-on could transfer a path from one Kodi instance to another – this would allow you to move playback from your ‘phone to the TV, for example.

Next up, jimcaroll stepped up to talk about Codegenerator, which is a core part of Kodi’s Python (and, in theory, other scripting language) API, auto-generating the C++ API code as required. The main purpose of this is to reduce code size and improve maintainability, but it could potentially scale to give a more flexible, standardised approach to supporting multiple different types of external module. Only a concept, but that would open up huge possibilities for add-ons in C#, JavaScript, Groovy and many others, bringing very different functionality, security models, and scope.

This was followed by an update on tvOS by kambala and fuzzard. Much of the Apple-specific code has been floating around for a while in various forks and branches, so this is a more concerted effort to bring it all back together, update and augment it to form a complete package for the Apple TV 4. Still a work in progress, but getting closer.

Next up, lrusak took the stage to lead a session on how platform specifics can block or delay overall development – for example, when a pull request affects all platforms but there’s some obscure issue on one particular operating system. Older versions of operating systems may come with different libraries or different development toolchains; different platforms might diverge totally or even miss out components that are business-as-usual on everything else; API calls can behave slightly differently even when they shouldn’t.

So, should we hold everything back because of one platform? Should we hold back all platforms because, say, an older but still maintained (e.g. LTS) OS release can’t support some aspect of newer functionality? Should we merge a change if it compiles on all platforms except one, effectively breaking that platform until “later”? This isn’t an easy issue: ultimately, we want to get new functions and fixes out there, and that may mean living with some dead code and platform-specific workarounds in the meantime; alternatively, we simply freeze older platforms at a previous Kodi release, and move on (as, indeed, many other application developers do). As always, though, if you’re a developer who could help here, you know where to find us…

After a break for lunch, kib and keith kicked off a conversation about Foundation responsibilities and costs – some activities are legal in nature, many of them administrative, all of them important. As a registered non-profit organisation, we’re obliged to submit certain paperwork on an annual basis to keep that status along with US tax declarations. Forget this, or get it wrong, and we face losing our status and either incurring significant taxes or else paying lawyers to re-submit and regain it – neither scenario being something we want. As such, we have an ongoing task to better document what people do and highlight the imperative tasks within that list: even as a bunch of volunteers, there’s a degree of professionalism required behind the scenes, and that means sometimes paying for help.

Time to return to more technical matters: jimcarroll once again took the floor, this time to talk about threading in Kodi. Given the history of Kodi, there was a lot of platform-specific threading mechanisms. That creates complex code, with dependencies and checks that just get in the way – so, can we collapse it down into a more platform-independent model, or, at least, a minimal set of variations? It turns out that you can slim down to two main models: POSIX and Windows, and that’s where the work has been heading. Some code will still need variations, though, although other code can be collapsed still further into newer, more standardised threading mechanisms that have been implemented on all platforms since the original code was written (e.g. as implemented in C++11).

Bringing the afternoon to a close, then, jimcarroll stayed on his feet to talk about DI – dependency injection. This is a mechanism to move away from a monolithic main() routine that directs all other application activities, and instead having a suite of dynamic dependencies between modules that are resolved at runtime. In this instance, the code can declare a constructor that has a dependency on some other component without explicitly knowing about that other component when the code is written.


And that’s it for Day Two. A few more topics to roll over until tomorrow, along with a hackathon while everyone is together – but, until then, that’s all for now.


DevCon 2019 – Belgrade – Part I

Another year passes, and here we are once again, locked in a windowless room to discuss all things Kodi-shaped. Genuine thanks to the generosity of our sponsors and users – that means you, you lovely people – whose donations make these meetings possible. Old faces, new faces, guests – these events really do help us to come together, share ideas and shape the direction of our favourite media software.

So, where are we? Well, this blog post comes to you from Belgrade, the capital of the Balkan state of Serbia, at the crossroads of central and south-east Europe. A city of some 1.25 million people, Belgrade has a long and turbulent history: the area has been inhabited for some 8,000 years, and has been home to, or part of, the Vinča culture, Celts, the Roman Empire, Slavs, the Bulgarian Empire, the Hungarian Empire, the Ottoman Empire, the Habsburgs and Yugoslavia. 

On with the show…


After the usual round of introductions, kambala opened the show with a session on crash reporting: whether and how we could collect more crash logs by making it semi-automated or just generally easier (“Kodi has had a problem, would you like to send a report to the developers?” sort of thing). If we can get better insights, particularly into “silent” crashes, then we can get to work on eliminating bugs without waiting until someone gets annoyed enough to report it. Of course, we need to balance data volumes, human workload, user privacy, platform/component-specifics, and several other factors before we go down this road, so it isn’t something that would appear tomorrow.

Next up, DarrenHill gave an update on forum activity and moderation. Overall, we’ve got a solid, worldwide team of moderators and a good suite of supporting tools that have had a significant positive impact on volumes of spam or undesirable posts. There’s more user-led engagement around what we can and can’t support on the forum; we’ve improved how we can notify our users when there’s an upstream problem (e.g. with metadata providers) that might cause issues with Kodi; spammers are either blocked at source or removed from the forum very swiftly. What we’re perhaps lacking, though, is more diligence around the wiki as a source of help – keeping this up-to-date as Kodi continues to grow and improve. As usual, volunteers are always welcome.

Our 2019 Google Summer of Code student, gusandrianos, took the microphone next to talk about his work on multi-pass shaders in RetroPlayer. Shaders are GPU routines that handle scaling, colours, lighting, shading, etc., and are used in RetroPlayer to change the look-and-feel of games as individual frames are rendered: pixellation, colour saturation, scaling, video effects, and similar. More information can be found via the GSoC website here.

Keith then stepped up to lead a discussion about Kodi’s trademark policy and how we work with community groups that wish to use our code and/or branding.  This covers projects which effectively bundle or build Kodi for specific purposes (e.g. LibreELEC or Debian) as well as complete rebranding (e.g. OSMC, SPMC). What we’re really trying to do is protect our intellectual property while being as easy to work with as we can be: we’ve probably been a bit heavy-handed in the past, and this isn’t helpful when people are simply trying (for the most part) to do the right thing. This conversation then led into how we include more “stakeholders” into our conversations – people who aren’t team members, who maybe aren’t specifically contributing to Kodi, but who are still doing interesting, relevant things that should be embraced. The conversation also covered “best practices” and how we can more easily advise people what they can and can’t do, or under what conditions.

The afternoon session kicked off with Keith giving an overview of Kodi’s financial position – where our money has come from, where it’s gone back out to, what we have left. Changing financial regulations around the world also mean that we need to re-assess our bank account setup, specifically in terms of how we keep “local” accounts to receive donations and pay expenses in e.g. EUR when we’re incorporated in the US.

Within the team, we use Slack extensively to talk to each other on both broad (e.g. “moderators”) and narrow (e.g. “HDR on Windows”) topics, so we had a conversation about all the channels we have that team members may have missed. We also talked about external channels, which we have so we can invite guests, bridge to IRC, and similar. If you collaborate with Team Kodi in any way and would find this useful, please let us know and we’ll set something up.

Next up, yol and DaVu led a conversation about how, now we’ve completed the move, switching bug tracking from Trac to GitHub Issues has worked out. In general, it’s working well, although we need to tighten up how we tag issues to both make sure they get routed correctly and, ultimately, to ensure that they get closed off once complete. You can find the current list of open and closed issues on our GitHub code repository. We’ve adopted a similar process for tagging pull requests, although we clearly need to improve our approach for notifying, reviewing and merging PRs given the backlog we’ve built up.

We talked a little about the European Union’s General Data Protection Regulation (GDPR) and what this means for us – specifically, the forum, as that’s arguably personally-identifiable information. Generally, we don’t aim to collect such information, and people’s posts are made publicly and thus outside of the scope of the legislation. However, there are still perhaps some tweaks we can make to ensure all “fingerprints” are removed should someone ask.

The next topic was around the vision for Kodi and how it fits into the streaming world we find ourselves in. The conversation was started off by da-anda, reflecting how we, as individuals, have seen our viewing habits change in recent years. This is a big topic, as there are as many political issues as there are any others: as part of the battle between themselves, the “walled garden” content providers fiercely defend the ‘user experience’ via their specific interface and applications. This obviously has real implications for any attempts to bring streamed content into a combined library view.

The conversation moved on with a conversation about add-ons – specifically, how they’re listed and shown, which is currently best summarised as “in a long list, not all of which will work for everyone even if you know what they might be for”. Can we group them? Can we tag them? Who would, how? We also touched on use cases – how clumsy it is to add your own home videos or similar content, for example – and also how else people do or could use Kodi. And we also talked about the implications for core developer time (both as mentors and programmers), and our constant need for more people who are motivated and interested in contributing significant features to the project; if nothing else, it’s futile to have a roadmap or list of features if we then can’t actually implement them. Kodi is a fantastic playground for experienced C++ developers and for those who wish to develop these skills; you don’t need to be a video guru either, as there’s an awful lot of code around the core player/renderer routines. Go on: you know you want to…

The day continued with a1rwulf and the work he’s been doing on metadata and database storage. This is major re-work that impacts large pieces of code throughout the application, so merging it needs to be done carefully. However, it brings about significant performance improvements, scales to large databases better, and brings new functionality around music sources and playlists. Some of these functions might better implemented as binary add-ons so they can be ported to the core application sooner rather than later – the benefit of taking a more modular approach.

Rounding off the session, then, garbear introduced a discussion around Kodi versioning which quickly led into plans for Kodi 19 “Matrix”. New features or capabilities notwithstanding, Python 2 goes end-of-life on New Year’s Day 2020 – the clock is literally ticking down – and that gives a growing imperative to release the Python 3 version of Kodi into the wild. There are, of course, other issues to address and other code to include before we can release, and a final check that Python 3 doesn’t break more than it solves, so it’s a balancing act now.


And that concludes our first day. As the sun sets on Belgrade, it’s time to head out into the Balkan night in search of beer and something to eat. Okay, mostly beer.