Words from the Inside

Major Upgrades to the Raspberry Pi GPU Driver Stack (XDC 2025 Recap)

Mon, 24 Nov 2025 00:00:00 +0100

XDC 2025 happened at the end of September, beginning of October this year, in Kuppelsaal, the historic TU Wien building in Vienna. XDC, The X.Org Developer’s Conference, is truly the premier gathering for open-source graphics development. The atmosphere was, as always, highly collaborative and packed with experts across the entire stack.

I was thrilled to present, together with my workmate Ella Stanforth, on the progress we have made in enhancing the Raspberry Pi GPU driver stack. Representing the broader Igalia Graphics Team that work on this GPU, Ella and I detailed the strides we have made in the OpenGL driver, though part of the improvements affect also the Vulkan driver.

The presentation was divided in two parts. In the first one, we talked about the new features that we were implementing, or are under implementation, mainly to make the driver more closely aligned with OpenGL 3.2. Key features explained were 16-bit Normalized Format support, Robust Context support, and Seamless cubemap implementation.

Beyond these core OpenGL updates, we also highlighted other features, such as NIR printf support, framebuffer fetch or dual source blend, which is important for some game emulators.

The second part was focused on specific work done to improve the performance. Here, we started with different traces from the popular GFXBench application, and explained the main improvements done throughout the year, with a look at how much each of these changes improved the performance for each of the benchmarks (or in average).

At the end, for some benchmarks we nearly doubled the performance compared to last year. I won’t explain here each of the changes done, But I encourage the reader to watch the talk, which is already available.

For those that prefer to check the slides instead of the full video, you can view them here:

Outside of the technical track, the venue’s location provided some excellent down time opportunities to have lunch at different nearby places. I need to highlight here one that I really enjoyed: An’s Kitchen Karlsplatz. This cozy Vietnamese street food spot quickly became one of my favourite places, and I went there a couple of times.

On the last day, I also had the opportunity to visit some of the most recomendable sightseeings spots in Vienna. Of course, one needs more than a half-day to do a proper visit, but at least it helps to spark an interest to write it down to pay a full visit to the city.

Meanwhile, I would like to thank all the conference organizers, as well as all the attendees, and I look forward to see them again.

Downloading personal data from web services

Wed, 12 Jan 2022 00:00:00 +0100

This post is a basic compilation on how to get your personal data from different social networks and web services. The reason to write it is for myself, as I usually make a backup of that data once or twice per year. So having all the steps in a single post is useful. I hope it is useful for others too.

The services here are the ones I use. My plan is to update the post with new instructions if they change, or with new services I use (and the other way around, I’ll drop the services that I don’t use anymore).

Feedly

This service provides a direct way to export our data:

Go to “Settings” and then select “Privacy and Personal data”
Scroll down to “Control Your Data and Take Your Data With You”, and click on “Generate your personal data archive”.

After some minutes, a compressed file will be offered with all your data.

GitHub

This service also provides a way to export our data:

Go to “Settings/Account”, and in “Export account data” section, click on “Start export”.

It will take some minutes to provide the data. The link to download it will be sent through an email.

Goodreads

To get a copy of your Goodreads data:

Go to “Account settings”, and “Settings” tab.
In the Privacy section, click on “Submit a dowload request”.
Now click on “Submit request”.

Again, a link with to download the data will be submitted to your email.

Google

Google allows to export everything you have (GMail, YouTube, etc). Note that this could be a lot of data.

Go to your account.
Go to “Data & privacy”.
Scroll down until “Download your data”.
Finally select “Create archive”.

Now you can control which data you want to export (by default data from all Google services). Once you know which data you want to export, press “Next”. Now, you can select the destination file type, the size (data will be split in files with that size as much), and where the file is put (by default a link is emailed to download it). We just use default options, and press “Create archive”. Now just wait until the you get it.

Gravatar

This services offers an option to export data.

Just go to “Export Data” option and click on “Send me my data”.

LastFM

Unfortunately, they removed the option it had to export data. So we need to use an external application to export, at least, part of the user data.

There’s a python2 script, lastexport.py, download it and run as

python lastexport.py -u <username> -o <output> [-t <type>]

By default it exports scrobbles, but we can change setting to "scrobbles", "loved" or "banned" (this one doesn't work anymore). Output is in CSV.

Libravatar

It is very easy to download the data.

Once logged in, click on “Download your libravatar data” on the main menu. It will expose your data as compressed XML file.

Fortunately, this service provides a way to export all your data.

Go to “Settings & Privacy”.
In “Data privacy”, select “Get a copy of your data”.

Select what to download, and press “Request archive”. An email will be sent with the link to download the data.

Mastodon

This service allows to download your datra too.

Click on “Preferences”.
Then click on “Import and export”, which by default selects “Data export”.
In the right side, you can request a file with your data.

SlideShare

Go to your Account, and select Export.

It provides two downlads: a JSON with your account data, and another to download a CSV with links to all the documents and presentations.

Surprinsingly it is possible to get all the Telegram data, but his requires to use Telegram Desktop application.

Once installed, go to “Settings”, then “Advanced” and at the end there is “Export Telegram data”. Select what information to export, and press “Export”.

It will take some time to get the data ready.

Twitter

Another service that provides an easy way to export all your data.

Go to account “Settings”
Select “Request your archive” in “Account”

An email will be sent with a link to download the file.

Xiaomi

Another service that provides a way to download your data.

Go to your Xiaomi Account
In the “Privacy” section, click on “Manage your data”

It provides different options to download your data. It takes time to get data ready (even some days or weeks), but a link with the data will be submitted to your email.

Implementing Performance Counters in V3D driver

Wed, 01 Sep 2021 00:00:00 +0200

Let me talk here about how we implemented the support for performance counters in the Mesa V3D driver, the OpenGL driver used by the Raspberry Pi 4. For reference, the implementation is very similar to the one already available (not done by me, by the way) for the VC4, OpenGL driver for the Raspberry Pi 3 and prior devices, also part of Mesa. If you are already familiar with how this is implemented in VC4, then this will mostly be a refresher.

First of all, what are these performance counters? Most of the processors nowadays contain some hardware facilities to get measurements about what is happening inside the processor. And of course graphics processors aren’t different. In this case, the graphics chips used by Raspberry Pi devices (manufactured by Broadcom) can record a bunch of different graphics-related parameters: how many quads are passing or failing depth/stencil tests, how many clock cycles are spent on doing vertex/fragment shading, hits/misses in the GPU cache, and many others values. In fact, with the V3D driver it is possible to measure around 87 different parameters, and up to 32 of them simultaneously. Quite a few less in VC4, though. But still a lot.

On a hardware level, using these counters is just a matter of writing and reading some GPU registers. First, write the registers to select what we want to measure, then a few more to start to measure, and finally read other registers containing the results. But of course, much like we don’t expect users to write GPU assembly code, we don’t expect users to write registers in the GPU directly. Moreover, even the Mesa drivers such as V3D can’t interact directly with the hardware; rather, this is done through the kernel, the one that can use the hardware directly, through the DRM subsystem in the kernel. For the case of V3D (and same applies to VC4, and in general to any other driver), we have a driver in user-space (whether the OpenGL driver, V3D, or the Vulkan driver, V3DV), and a kernel driver in the kernel-space, unsurprisingly also called V3D. The user-space driver is in charge of translating all the commands and options created with the OpenGL API or other API to batches of commands to be executed by the GPU, which are submitted to the kernel driver as DRM jobs. The kernel does the proper actions to send these to the GPU to execute them, including touching the proper registers. Thus, if we want to implement support for the performance counters, we need to modify the code in two places: the kernel and the (user-space) driver.

Implementation in the kernel

Here we need to think about how to deal with the GPU and the registers to make the performance counters work, as well as the API we provide to user-space to use them. As mentioned before, the approach we are following here is the same as the one used in the VC4 driver: performance counters monitors. That is, the user-space driver creates one or more monitors, specifying for each monitor what counters it is interested in (up to 32 simultaneously, the hardware limit). The kernel returns a unique identifier for each monitor, which can be used later to do the measurement, query the results, and finally destroy it when done.

In this case, there isn’t an explicit start/stop the measurement. Rather, every time the driver wants to measure a job, it includes the identifier of the monitor it wants to use for that job, if any. Before submitting a job to the GPU, the kernel checks if the job has a monitor identifier attached. If so, then it needs to check if the previous job executed by the GPU was also using the same monitor identifier, in which case it doesn’t need to do anything other than send the job to the GPU, as the performance counters required are already enabled. If the monitor is different, then it needs first to read the current counter values (through proper GPU registers), adding them to the current monitor, stop the measurement, configure the counters for the new monitor, start the measurement again, and finally submit the new job to the GPU. In this process, if it turns out there wasn’t a monitor under execution before, then it only needs to execute the last steps.

The reason to do all this is that multiple applications can be executing at the same time, some using (different) performance counters, and most of them probably not using performance counters at all. But the performance counter values of one application shouldn’t affect any other application so we need to make sure we don’t mix up the counters between applications. Keeping the values in their respective monitors helps to accomplish this. There is still a small requirement in the user-space driver to help with accomplishing this, but in general, this is how we avoid the mixing.

If you want to take a look at the full implementation, it is available in a single commit.

Implementation in the driver

Once we have a way to create and manage the monitors, using them in the driver is quite easy: as mentioned before, we only need to create a monitor with the counters we are interested in and attach it to the job to be submitted to the kernel. In order to make things easier, we keep a mirror-like version of the monitor inside the driver.

This approach is adequate when you are developing the driver, and you can add code directly on it to check performance. But what about the final user, who is writing an OpenGL application and wants to check how to improve its performance, or check any bottleneck on it? We want the user to have a way to use OpenGL for this.

Fortunately, there is in fact a way to do this through OpenGL: the GL_AMD_performance_monitor extension. This OpenGL extension provides an API to query what counters the hardware supports, to create monitors, to start and stop them, and to retrieve the values. It looks very similar to what we have described so far, except for an important difference: the user needs to start and stop the monitors explicitly. We will explain later why this is necessary. But the key point here is that when we start a monitor, this means that from that moment on, until stopping it, any job created and submitted to the kernel will have the identifier of that monitor attached. This implies that only one monitor can be enabled in the application at the same time. But this isn’t a problem, as this restriction is part of the extension.

Our driver does not implement this API directly, but through “queries”, which are used then by the Gallium subsystem in Mesa to implement the extension. For reference, the V3D driver (as well as the VC4) is implemented as part of the Gallium subsystem. The Gallium part basically handles all the hardware-independent OpenGL functionality, and just requires the driver hook functions to be implemented by the driver. If the driver implements the proper functions, then Gallium exposes the right extension (in this case, the GL_AMD_performance_monitor extension).

For our case, it requires the driver to implement functions to return which counters are available, to create or destroy a query (in this case, the query is the same as the monitor), start and stop the query, and once it is finished, to get the results back.

At this point, I would like to explain a bit better what it implies to stop the monitor and get the results back. As explained earlier, stopping the monitor or query means that from that moment on, any new job submitted to the kernel (and thus to the GPU) won’t contain a performance monitor identifier attached, and hence won’t be measured. But it is important to know that the driver submits jobs to the kernel to be executed at its own pace, but these aren’t executed immediatly; the GPU needs time to execute the jobs, and so the kernel puts the arriving jobs in a queue, to be submitted to the GPU. This means when the user stops the monitor, there could be still jobs in the queue that haven’t been executed yet and are thus pending to be measured.

And how do we know that the jobs have been executed by the GPU? The hook function to implement getting the query results has a “wait” parameter, which tells if the function needs to wait for all the pending jobs to be measured to be executed or not. If it doesn’t but there are pending jobs, then it just returns telling the caller this fact. This allows to do other work meanwhile and query again later, instead of becoming blocked waiting for all the jobs to be executed. This is implemented through sync objects. Every time a job is sent to the kernel, there’s a sync object that is used to signal when the job has finished executing. This is mainly used to have a way to synchronize the jobs. In our case, when the user finalizes the query we save this fence for the last submitted job, and we use it to know when this last job has been executed.

There are quite a few details I’m not covering here. If you are interested though, you can take a look at the merge request.

Gallium HUD

So far we have seen how the performance counters are implemented, and how to use them. In all the cases it requires writing code to create the monitor/query, start/stop it, and querying back the results, either in the driver itself or in the application through the GL_AMD_performance_monitor extension¹.

But what if we want to get some general measurements without adding code to the application or the driver? Fortunately, there is an environmental variable GALLIUM_HUD that, when correctly, will show on top of the application some graphs with the measured counters.

Using it is very easy; set it to help to know how to use it, as well as to get a list of the available counters for the current hardware.

As example:

$ env GALLIUM_HUD=L2T-CLE-reads,TLB-quads-passing-z-and-stencil-test,QPU-total-active-clk-cycles-vertex-coord-shading scorched3d

You will see:

Bear in mind that to be able to use this you will need a kernel that supports performance counters for V3D. At the moment of writing this, no kernel has been released yet with this support. If you don’t want to wait for it, you can download the patch, apply it to your raspberry pi kernel (which has been tested in the 5.12 branch), build and install it.

All this is for the case of using OpenGL; if your application uses Vulkan, there are other similar extensions, which are not yet implemented in our V3DV driver at the moment of writing this post. ↩

Grilo, Travis CI and Containers

Thu, 09 Mar 2017 00:00:00 +0100

Good news! Finally, we are using containers in Travis CI for Grilo!. Something I was trying for a while, but we achived it now. I must say that a post Bassi wrote was the trigger for getting into this. So all my kudos to him!

In this post I’ll explain the history behind using Travis CI for Grilo continuous integration.

The origin

It all started when one day exploring how GitHub integrates with other services, I discovered Travis CI. As you may know, Travis is a continuous integration service that checks every commit from a project in GitHub, and for each one it starts a testing process. Roughly, it starts a “virtual machine”¹ running Ubuntu², clones the repository at that commit under test, and runs a set of commands defined in the .travis.yml file, located in the same project GitHub repository. In that file, beside the steps to execute the tests, it contains the instructions about how to build the project, as well as which dependencies are required.

Note that before Travis, instead of a continuous integration system in Grilo we had a ‘discontinuous’ one: run the checks manually, from time to time. So we could have a commit entering a bug, and we won’t realize until we run the next check, which can happen way later. Thus, when I found Travis, I thought it would be a good idea to use it.

Setting up .travis.yml for Grilo was quite easy: in the before_install section we just use apt-get to install all requirements: libglib2.0-dev, libxml2-dev, and so on. And then, in the script section we run autogen.sh and make. If nothing fails, we consider the test is successful. We do not run any specific test because we don’t have any in Grilo.

For the plugins, the same steps: install dependencies, configure and build the plugins. In this case, we also run make check, so tests are run always. Again, if nothing fails Travis gives us a green light. Otherwise, a red one. The status is shown in the main web page. Also, if the test fail, an email is sent to the commit author.

Now, this has a small problem when testing plugins: they require Grilo, and we were relying in the package provided by Ubuntu (it is listed in the dependencies). But what happens if the current commit is using a feature that was added in Grilo upstream, but not released yet? One option could be cloning Grilo core, building and installing it, before the plugins, and then compiling the plugins, depending on this version. This means that for each commit in plugins, we need to build two projects, adding lot of complexity in the Travis file. So we decided to go with a different approach: just create a Grilo package with the required unreleased Grilo core version (only for testing), and put it in a PPA. Then we can add that PPA in our .travis.yml file and use that version instead.

A similar problem happens with Grilo itself: sometimes we require a specific version of a package that is not available in the Ubuntu version used by Travis (Ubuntu 12.04). So we need to backport it from a more recent Ubuntu version, and add it in the same PPA.

Summing up, our .travis.yml files just add the PPA, install the required dependencies, build and test it. You can take a look at the core and plugins file.

Travis and the Peter Pan syndrome

Time passes, we were adding more features, new plugins, fixing problem, adding new requirements or bumping up the required versions… but Travis continues using Ubuntu 12.04. My first thoughts were “OK, maybe Travis wants to rely only in LTS releases”. So we need to wait until the next LTS is released, and meanwhile backporting everything we need. No need to say that doing this becomes more and more complicated as time is passing. Sometimes backporting a single dependency requires to backport a lot of other dependencies, which can end up in a bloody nightmare. “Only for a while, until the new LTS is released”, repeated to myself.

And good news! Ubuntu 14.04, the new LTS, is released. But you know what? Travis is not updated, and still uses the old LTS!. What the hell!

Moreover, two years later after this release, Ubuntu 16.04 LTS is also released, and Travis still uses 12.04!

At that moment, backporting were so complex that basically I gave up. And Continuous Integration was basically broken.

Travis and the containers.

And we were under this broken status until I read Travis was adding support for containers. “This is what we need”. But the truth is that even I knew that it would fix all the problems, I wasn’t very sure how to use the new feature. I tried several approaches, but I wasn’t happy with none of them.

Until Emmanuele Bassi published a post about using Meson in Epoxy. That post included an explanation about using Docker containers in Travis, which solved all the doubts I had, and allowed me to finally move to use containers. So again, thank you, Emmanuele!

What’s the idea? First, we have created a Docker container that has preinstalled all the requirements to build Grilo and the plugins. We tagged this image as base.

When Travis is going to test Grilo, we instruct Travis to build a new container, based on base, that builds and installs Grilo. If everything goes fine, then our continous integration is successful, and Travis gives green light. Otherwise it gives red light. Exactly like it happened in the old approach.

But we don’t stop here. If everything goes fine, we push the new container into Docker register, tagging it as core. Why? Because this is the image we will use for building the plugins.

And in the case of plugins we do exactly the same as in the core. But this time, instead of relying in the base image, we rely in the core one. This way, we always use a version that has an up-to-date version of Grilo, so we don’t need to package it when introducing new features. Only if either Grilo or the plugins require a new dependency we need to build a new base image and push it. That’s all.

Also, as a plus, instead of discarding the container that contains the plugins, we push it in Docker, tagged as latest. So anyone can just pull it with Docker to have a container to run and test Grilo and all the plugins.

If interested, you can take a look at the core and plugins files to check how it looks like.

Oh! Last but not least. This also helped us to test the building both using Autotools and Meson, both supported in Grilo. Which is really awesome.

Summing up, moving to containers provides a lot of flexibility, and make things quite easier.

Please, leave any comment or question either in Facebook or Google+.

UPDATE (26/11/2017): comments are available again.

Let’s call Virtual Machine, container, whatever. In this context it doesn’t matter. ↩
Ubuntu 12.04 LTS, to be exact. ↩

New Year, New Blog!

Thu, 12 Jan 2017 00:00:00 +0100

A new year has come! And with the new year, the usual new proposals: be better person, do more exercise, blog more, … :smile:

More than two years without blogging. Lot of time. So let’s start with the last proposal.

But I also wanted to do a clean restart, and entirely reboot my blog. This is something I was thinking of during the last months, specially after Rego moved his blog to Jekyll. I really like how clean and simple it looks like.

I have (or better had) my blog hosted in a WordPress server. WordPress is a very popular and also, why not, very good system to create and manage website content and blogs. It’s entirely an online service, where you create your content, and it’s served to the world. And there are tons of plugins that practically allow to do whatever you need.

But to be honest, it seems too much cathedral for me. I just wanted something simpler, that serves the content I have, and nothing else. Specially, after reading lot of times about bugs and different security problems it has (fortunately, most of them fixed quickly). Nevertheless, I’m very lucky in this topic, because the WordPress server I was using is hosted by Igalia, and their sysadmins are awesome professional people that keep everything updated. But still, can’t avoid the feeling that there’s still a risk, and that implies spending time from our sysadmins to maintain it.

Besides that, there were other reasons that made me to consider a static blog system (again, these reasons are entirely for my personal case).

As said, too much big just to keep a simple blog. Using a static blog seems more suitable.
I’m a FLOSS person, and as such, I really like to know what’s going on under the hood. And in this case it is something I don’t really know. Yes, WordPress is a free software, and source code is available out there. What I mean is that I can’t go to the server and freely change things, because I’m not the sysadmin. If I want to use a modified version of a plugin, I can’t do it. Basically, I see it as a service like others in the cloud, that you just use and full stop. On the other hand, static blogging is different: you have the source code, that you can inspect or modify (like I did for this blog), and that runs in your own host. And once the final content is generated, can be served by any webserver. No need to install anything at all in the server.
I’m a developer person, and as such, I like the process of writing something in clear text, compile it, and get a final result I can use. Which is something that perfectly matches with the way of doing static blogging: you write your posts in clear text (usually, in MarkDown or reStructuredText), you run a generator which transforms the posts in HTML + CSS, and you get everything inside a directory. You only need to copy the generated content in the proper webserver. Nothing else.
A very important one for me, that I think triggered the change from WordPress: I really like Git. And really missed to have my posts under with Git. But now, as posts are just clear text files, I can easily handle them with Git: I can push, amend, branch, and even accept fixes through pull requests!

Probably there are more reasons that made me to switch from WordPress. But those above are enough.

So the next question was: which one? There are lot of different static site generators. Lot time ago I had done some shy attempts with Pelican first, and with Jekyll later. As Jekyll is the most popular one, I decided to go with it. It has lot of plugins that covers all my needs, and very big community. For sure it is not the fastest one, but I don’t mind spending some minutes if required to generate content. The good thing is that in the future I can move to a different generator if needed, and just use the same posts.

Once I decided to use Jekyll, a crucial question came up: which theme? Themes define how your content looks alike. For sure, I wanted something simple, like Rego’s blog, but not the same theme. I’m not a designer, so doing it myself from scratch was discarded. I could buy a theme from a professional designer, but I think it is too early to do that at this moment. Maybe in the future. Thus, I spent several days trying different free themes, checking how they look, until finding one that suited what I wanted: Mediator theme. I used it as a starting point, fixing some problems (most of those fixes were merged in the original theme), doing some modifications to adapt to my own wishes, and voilà! What you see here is the final result.

What’s next? Very likely, search for a way of allowing comments. This is not handled natively in Jekyll, but usually through third-party services, like Disqus or Discourse. I could use any of them, but again, I would be in the same situation as with WordPress.

So for now, I’ll leave a couple of links in Facebook and Google+ where people can leave comments.

Happy new year!

UPDATE (26/11/2017): comments are available again.

Highlights in Grilo 0.2.11 (and Plugins 0.2.13)

Mon, 29 Sep 2014 00:00:00 +0200

Hello, readers!

Some weeks ago we released a new version of Grilo and the Plugins set (yes, it sounds like a 70’s music group :smile:). You can read the announcement here and here. If you are more curious about all the detailed changes done, you can take a look at the Changelog here and here.

But even when you can read that information in the above links, it is always a pleasure if someone highlights what are the main changes. So let’s go!

Launch Tool

Regarding the core system, among the typical bug fixes, I would highlight a new tool: grl-launch. This tool, as others, got inspiration from GStreamer gst-launch. So far, when you wanted to do some operation in Grilo, like performing a search in YouTube or getting the title of a video on disk, the recommended way was using Grilo Test UI. This is a basic application that allows you to perform the typical operations in Grilo, like browsing or searching, and everthing from a graphical interface. The problem is that this tool is not flexible enough, so you can’t control all the details you could require. And it is also useful to visually check the results, but not to export the to manage with another tool.

So while the Test UI is still very useful, to cover the other cases we have grl-launch. It is a command-line based tool that allows you to perform most of the operations allowed in Grilo, with a great degree of control. You can browse, search, solve details from a Grilo media element, …, with a great control: how many elements to skip or return, the metadata keys (title, author, album, …) to retrieve, flags to use, etc.

And on top of that, the results can be exported directly to a CSV file so it can be loaded later in a spreadsheet.

As example, getting the 10 first trailers from Apple’s iTunes Movie Trailers site:

$ grl-launch-0.2 browse -c 10 -k title,url grl-apple-trailers
23 Blast,http://trailers.apple.com/movies/independent/23blast/23blast-tlr_h480p.mov
A Most Wanted Man,http://trailers.apple.com/movies/independent/amostwantedman/amostwantedman-tlr1_h480p.mov
ABC's of Death 2,http://trailers.apple.com/movies/magnolia_pictures/abcsofdeath2/abcsofdeath2-tlr3_h480p.mov
About Alex,http://trailers.apple.com/movies/independent/aboutalex/aboutalex-tlr1b_h480p.mov
Addicted,http://trailers.apple.com/movies/lionsgate/addicted/addicted-tlr1_h480p.mov
"Alexander and the Terrible, Horrible, No Good, Very Bad Day",http://trailers.apple.com/movies/disney/alexanderterribleday/alexanderterribleday-tlr1_h480p.mov
Annabelle,http://trailers.apple.com/movies/wb/annabelle/annabelle-tlr1_h480p.mov
Annie,http://trailers.apple.com/movies/sony_pictures/annie/annie-tlr2_h480p.mov
Are You Here,http://trailers.apple.com/movies/independent/areyouhere/areyouhere-tlr1_h480p.mov
As Above / So Below,http://trailers.apple.com/movies/universal/asabovesobelow/asabovesobelow-tlr1_h480p.mov
10 results

As said, if you re-direct the output to a file and you import it from a spreadsheet program as CSV you will read it better.

dLeyna/UPnP plugin

Regarding the plugins, here is where the fun takes place. Almost all plugins were touched, in some way or other. In most cases, for fixing bugs. But there are other changes I’d like to highlight. And among them, UPnP is one that suffered biggest changes.

Well, strictly speaking, there is no more UPnP plugin. Rather, it was replaced by new dLeyna plugin, written mainly by Emanuele Aina. From an user point of view, there shouldn’t be big differences, as this new plugin also provides access to UPnP/DLNA sources. So where are the differences?

First off, let’s specify what is dLeyna. So far, if you want to interact with a UPnP source, either you need to deal with the protocol, or use some low-level library, like gupnp. This is what the UPnP plugin was doing. Still it is a rather low-level API, but higher and better than dealing with the raw protocol.

On the other hand, dLeyna, written by the Intel Open Source Technology Center, wraps the UPnP sources with a D-Bus layer. Actually,not only sources, but also UPnP media renderers and controllers, though in our case we are only interested in the UPnP sources. Thanks to dLeyna, you don’t need any more to interact with low-level UPnP, but with a higher D-Bus service layer. Similar to the way we interact with other services in GNOME or in other platforms. This makes easier to browser or search UPnP sources, and allows us to add new features. dLeyna also hides some details specific to each UPnP server that are of no interest for us, but we would need to deal with in case of using a lower level API. The truth is that though UPnP is quite well specified, each implementation doesn’t follow it at 100%: there are always slight differences that create nasty bugs. In this case, dLeyna acts (or should act) as a protection, dealing itself with those differences.

And what is needed to use this new plugin? Basically, having dleyna-service D-Bus installed. When the plugin is started, it wakes up the service, which will expose all the available UPnP servers in the network, and the plugin would expose them as Grilo sources. Everything as it was happening with the previous UPnP source.

In any case, I still keep a copy of the old UPnP plugin for reference, in case someone want to use it or take a look. It is in “unmaintained” mode, so try to use the new dLeyna plugin instead.

Lua Factory plugin

There isn’t big changes here, except fixes. But I want to remark it here because it is where most activity is happening. I must thank Bastien and Victor for the work they are doing here. Just to refresh, this plugin allows to execute sources written in Lua. That is, instead of writing your sources in GObject/C, you can use Lua. The Lua Factory plugin will load and run them. Writing plugins in Lua is a pleasure, as it allows to focus on fixing the real problems and leave the boiler plate details to the factory. Honestly, if you are considering writing a new source, I would really think about writing it in Lua.

And that’s all! It is a longer post than usual, but it is nice to explain what’s going on in Grilo. And remember, if you are considering using Grilo in your product, don’t hesitate to contact with us.

Another year, another GUADEC

Thu, 24 Jul 2014 00:00:00 +0200

It’s 2014, and like previous years:

This time I won’t give any talk, just relax and enjoy talks from others, and hope Strasbourg.

And what is more important, meet those hackers you interact with frequently, and maybe share some beers.

So if you go there, and you want to have a nice chat with me, or talk about Grilo project, don’t hesitate to do it. Igalia, which is kindly sponsoring my attendance, will have a place there during the core days, so likely you could find me around or ask anyone there for me.

Enjoy!

Yum Search Extended

Thu, 06 Mar 2014 00:00:00 +0100

Hi again! Let me tell you something. I’m a Fedora user since several releases ago, probably since Fedora 13 or 14.

Before that, I was using Ubuntu, but decided to switch to Fedora for several reasons that are not worth explaining here. In any case, after switching to Fedora there was something that I was missing quite a lot: the aptitude package manager. aptitude is a deb package manager, similar to apt. What I really like about aptitude is its flexibility when searching packages.

While apt or yum allows to specify the search term, they just get all the packages matching the search text, but they don’t allow you where to search. Do you want to get only packages that are not installed? Or do you just remember the package had python in the name, and part of the description? With aptitude this is not a problem, as it allows you to specify such search expressions.

Though search in yum is not so flexible, as far as I know, it has a nice feature: it allows plugins to implement new features. So several months ago I wrote a plugin to mimic the aptitude search flexibility: yum searchex (search extended).

It is worth saying that I didn’t want to imitate the full aptitude functionality; only those features that I really missed from Ubuntu.

The basic idea is specifying for each term where to search. This is done by prefixing the text with ~ and a letter that expresses where to search. In some cases, the text to search is not needed. For instance, to search only in the list of installed packages, we would use ~i.

The full list of the available options can be found in the project forge.

As an example is worth a thousand words, let’s show how to search a package that we know it contains python in the name, it is not installed, and also we remember it has something to do with KDE:

yum searchex ~apython~dKDE

Hope this plugin is as useful for you as it is for me!

See you at GUADEC 2013!

Mon, 22 Jul 2013 00:00:00 +0200

GUADEC 2013 is around the corner.

Igalia is kindly sponsoring my attendance, as well as other mates, to this wonderful conference, where all years I meet good friends, and do new ones.

I’ll be there from August, 1st to 5th, both included. On saturday 3rd I’ll give a talk about Grilo. If you are using Grilo or willing to, join us to the talk. Of course, I always welcome any question, so if you see me and want to ask anything, don’t hesitate to address me.

Also, I expect to attend on 5th the gnome-music BoF. gnome-music is one of the programs I collaborate with that heavily use Grilo. I really suggest to give a try. I’ts so nice!

Besides all above, Igalia will have a booth during all the event, where we will be showing some of the cool things we do. I still don’t know where it be exactly located, but if you see us, come there!

Grilo 0.2.8 released

Sat, 25 May 2013 00:00:00 +0200

I did a new release of grilo plugins only one week after the previous release because it includes a patch that people from gnome-photos would like to see in next GNOME 3.9 pre-release.

Besides that patch, this new release also includes a new plugin to get content from the Magnatune service. Credits go to Victor Toso, who did a great job on it.

Happy weekend from Igalia headquarter!