• Resolver Vs Encoder

We’re proud to release the first Pitivi 1.0 release candidate “Ocean Big Chair” (0.99). This release has many bug fixes and performance improvements, and is a release candidate for 1.0. Our test suite grew considerably, from 164 to 191 meaningful unit tests.

You can right away using Flatpak. GSoC Early on this year, we got caught up in the Google Summer of Code. A lot of students hacked on Pitivi this spring, to get to know Pitivi better. As a result quite a few important fixes and improvements have been made. A big thank you to all of the students who contributed! This summer we had three GSoC Pitivi projects. The GSoC work has been merged on the “master” branch and we made a separate “1.0” branch where we implement or backport the relevant fixes.

Resolver Vs Encoder

1 - Corrupt Client Backup Data - Questions and Troubles. And checking the SMART data on the drives may give indication if the drives are going bad also. The manu- tools don't always check that. That includes Linux, BSD, UNIX, etc. I've been getting a message from WHS that there are 'file conflicts' that need to be addressed.

A special thank you to Suhas Nayak and Ștefan-Adrian Popa, two of our GSoC students who contributed a large number of bugfixes and made possible this release. 1.0 As you might know, we’re focused on bug fixing until Pitivi 1.0. See what’s left to do for 1.0 in. We need people to test Pitivi (the Flatpak “stable” branch) and report back any crash or stability issue they notice, so we fix it. — If you want to in any way, come to our. I have been reading the source code of Cheese.

I wanted to get an idea of how it works. So this is what I understand. Below the diagram you will see an explanation of this, if you know about GStreamer you may want to skip the explanation.

Cheese reads some data from the selected webcam device using the bin camerasource. In parallel, Cheese uses an autoaudiosrc to capture data from the sound card. The data from the webcam is sent to a tee which work is to duplicate the output. Firstly, one of the outputs of this tee is passed to an element called elementbinpreview (this also uses a tee of nine outputs but that’s not showed in the diagram).

An elementsbinpreview has 9 sink pads. The output that flows out from there is (for each sink pad) passed to a filter and finally to a cluttersink. Its name on itself is just descriptive, elementsbinpreview is used to preview the effects in that 3x3 “grid” used for Cheese when you click on the “Effects” button. Secondly, the data that flows from the other sink pad of the tee is sent to an element called currentselectedfilter which is the filter that has been currently selected by the user by clicking the grid of effects in Cheese. In case of recording video, the output that flows out from one of the sink pads of the tee is sent in parallel with the autoaudiosrc to an encodebin which (of course) encodes and mixes to pass it to a filesink so you have the result (a video file) on your disk. In case of using the “burst mode” in Cheese, the second output of the tee is used to be passed to a filesink.

The filesink can then capture some bunch of frames (by default 4 in Cheese) saving the output in the disk. Filesink usually receives an index in its filename, so when you take a picture with Cheese, you will usually see that base names of file names have a number from 1 to 4 in the sufix when using “Burst mode”.

Finally, the third output of the sink is used to show the output of the camera with the filter applied in the Cheese main window using a cluttersink element. Plugin Module = codeeditor Name = Code Editor Description = A plugin to edit code in Python.

Authors = Example website = Copyright = Copyright © Example Loader = Python3 For a complete example of a plugin description file, see. Creating a simple Python module The only interface available to implement by Pitivi extensions is the. Extension modules should implement this interface and internally as soon this module is loaded Pitivi will set to it the object attribute to the Pitivi application object, which will give you access to almost everything. Now create the file helloworld.py in the same directory of hello-world.py. Class CodeEditor ( GObject. GObject, Peas.

Activatable ): gtypename = 'CodeEditor' object = GObject. Property ( type = GObject. Object ) def init ( self ): GObject. init ( self ) def doactivate ( self ): print ( 'Hello world!' ) def dodeactivate ( self ): print ( 'Bye!' ) You’ve just created your first plugin! It will print a message in the terminal when you activate or deactivate the plugin.

Replacing the Pitivi Timeline by a GtkSourceView The plugin we wrote was bery simple, now we want to do something more complex. We will rewrite our init function to look like this. Def doactivate ( self ): API = self. timeline = self. Getchildat ( 0, 1 ) self. Remove ( self. timeline ) self.

Sourceview = GtkSource. View languagemanager = GtkSource. LanguageManager language = languagemanager. Getlanguage ( 'python3' ) buf = self. Getbuffer buf.

Setlanguage ( language ) self. Show The API object contains the Pitivi application, so we assign it to self.app just to access it without typing too much. Then we get the Timeline object that is the widget that displays a representation of the. Then we create a GtkSourceView that is the widget that provides a text editor with features like highlighting (among others). Then we set to it as “python3” as the default language and then set it to the buffer of the GtkSourceView. Finally, we show the source view.

Now we wish to add just these lines to have a better code editor. Def dodeactivate ( self ): self. Destroy self.

Attach ( self. timeline, 0, 1, 2, 1 ) self. Sourceview = None That’s it. You can do more if you want like adding support for more languages or a button to export the code as a file. You can also add preferences to the Preferences Dialog and add new settings. With this example I want to show you that you can go as far as you want just with imagination and some knowledge about programming. One of the things I like the most about GNOME are the annual conferences called GUADEC.

You can see in person to the folks you were chatting with on IRC. As I have mentioned in my previous posts, I am an accepted GSoC 2017 student this year, and thus like other students, I was invited to give a lightning talk about my project with Pitivi, that consist on adding a plugin system as I mentioned in other posts. I live in Peru, so the duration of the flight is really long. Actually, I found a great deal by going first to Madrid and then taking other flight to Manchester. From Lima to Amsterdam (the stop of my flight to Madrid) it was about 12 hours, from Amsterdam to Madrid it was about 3 hours and from Madrid to Manchester about 2 hours. Almost 17 hours flying. But it was worth it.

I arrived to Manchester on July 27 at 12:20 p.m. And the weather surprised me with a strong rain. It may be more surprising when you live in a city were it does not rain. Then I had to go to the Manchester Metropolitan University where many of the GNOME contributors would be hosted. When the bus stopped on the Manchester Metropolitan University I went to the first building of it I see and asked how to get to the Birley Fields, our accomodations. A man told me the directions and gave me a map. After some minutes walking I got the office that assigns the rooms to the new residents.

I met there Mario, a guy from GNOME who is involved in Flatpak. It was interesting to talk with him in English when at the end we realized that we both could speak in Spanish. After leaving my stuff on my room, I left the room to walk outside and I found David King. It was incredible because it was almost three years we didn’t see to each other.

In that day, I also met hadess (Bastien Nocera). He helped me to get a traveler adapter. This was also the day of pre-registration in a bar called KROBAR. I got joined to the GStreamer folks who I met before in GUADEC 2014. Some of the guys came up with the idea that the GNOME logo needs a new design. I talked about it before on the #gnome-design channel.

I also met ystreet00 (Matthew Waters) who helped once to create a GStreamer plugin with OpenGL. GNOME stickers. With the Ken-Burns effect project completed, most of my last two weeks were spent working on some existing tasks that should be solved for Pitivi 1.0, so we can get it out sooner. Here are some things I’ve been working on:. Make sure well supported audio streams are not proxyed even if they are not in a container:.

Solved a bug where the undo stack sometimes crashed when moving the viewer:. Added the possibility to create custom validation checks for the advanced properties of the encoders, which will make rendering more robust in the long run: Also, Alex Balut (aka aleb) found some time to test the Ken-Burns branch and suggested some changes. Therefore, the sail towards Pitivi 1.0 had some stops, in which I spent my time working on making the Ken-Burns project a bit better. The most noticeable improvement is the fact that the displayed values of the transformation properties are now updated more often, so they are more accurate (they were sometimes completely wrong as we were not updating them when we should have).

With that said, I will continue helping with the Pitivi 1.0 release and keep you posted on the progress. Until next time! In my last, I was telling you how my GSOC project was close to its completion. Since then, I’ve been working on getting it to a deployable state, while also adding some final touches. Now, it should be ready to land and you’ll probably see it included in Pitivi 2.0. About the final touches: one is extending the undo/redo system so it can handle activation of transformation properties keyframes and the reset to default operation (which will deactivate the keyframes). The other one I’ve been working on is a mechanism which allows selection of the transformation properties keyframes.

Before this, the only way of navigating to a certain keyframe was using the two arrows in the transformation box. Now, you can also click on a keyframe to select it and the playhead will seek to its position. This should make navigation a bit more intuitive.

How Custom Effect Widget API evolved Simply using the initial API, for allowing custom widgets instead of the default UI for effects, has brought in a lot of changes to it. Being new to such a task of designing the API, it was good that I had to make an for the alpha effect.

I realized that the default UI for effects does a good job (I mean, you can’t do anything more fancy than the default sometimes), except for some widgets of effect properties where something more modern can provide a better user interface for editing. This called for an improvement to the existing custom widget mechanism. Now, custom widgets for only certain properties can be added while falling back to the auto-generated UI for the rest. To maintain consistency, one has to connect a callback to the ‘createpropertywidget’ signal and return a DynamicWidget wrapper around the custom property widget. Although, I would have liked to do away with this wrapper. It seems like the best approach as it would allow the designer to truly customize the widget. Holds these new changes.

Baby steps in making custom widgets For the past few days, I’ve been learning gtk in c and cairo. Porting the to gtk3 and exploring the basics.

My next immediate task is to make a color wheel widget. Gtk3 already had such a widget, which is now deprecated (infact, removed from the master!).

Having talked on the IRC, it seems Gtk had pulled the widget from GIMP but since they found that it was not being used by other applications, they decided to deprecate it. GIMP has taken back their widget. Although, our widget would heavily borrow code, it seems building a separate Pitivi Library of custom widgets would be the best thing to do. Subclassing a GtkDrawingArea and drawing a circle, I was trying to run a skeleton-like custom widget code, all I could see was an empty window.

Took me to some to ‘realize’ my mistake (I had left the overrided realize callback empty). I was so happy when I managed to draw this circle in cairo:P Until next time:).

With a bit more than a month into the GSOC coding time, my project is almost complete. As a reminder, I was working on implementing a keyframe curve for the transformation properties (which control the positioning and size of a clip) in Pitivi. For the last two weeks, I’ve been working on integrating the newly added keyframe curve with the undo/redo system, as well as allow values for the keyframes to be specified by dragging the viewer. I’ve also had some battles with a pretty nasty bug which made the app crash all of a sudden. Fortunately, my mentor, Thibault Saunier, took a look at it and managed to crack it, so everything should work fine now. With my project being close to completion, I thought it would be a good idea to make an extended demo video in which I explain how the new feature works.

In my, I described ‘how’ I managed to port nekohayo and thiblahute’s work towards providing an interface for adding custom widgets for effects in Pitivi. In this, I’ll tell you ‘what’ it is that I have done in my first month of Google Summer of Code. The initial design How Pitivi auto-generates UI for effects is interesting. For every GStreamer effect in Pitivi, a GtkGrid with the right type of widgets for its properties are packed and to manage changes to these widgets and map back the changes to the effect properties, a DynamicWidget class is created and subclassed for different type of widgets. EffectsPropertiesManager provides and caches UIs for editing effects, while GstElementSettingsWidget is a container class for configuring the effects.

It is sad that such a unique infrastructure leads to a rather uniform UI. Porting nekohayo’s branch I ended up with a light-weight plugin like architecture for having custom widgets for effects. Now, when a GstElementSettingsWidget got created it searched a particular directory to see if there is ‘createwidget’ entry point in ‘fooeffect.py’ files and saved references to this entry point.

GstElementSettingsWidget’s setElement method, which previously simply called addwidgets method to generate and show the GtkGrid, was changed. to call the ‘createwidget’ entry point if it existed.

Otherwise, check if we have a custom UI availabe as a glade file. If all else fails, fallback to the auto-generation. Both of these ways of having custom UI utilized the mapBuilder method of GstElementSettingsWidget to map the GStreamer element’s properties to corresponding widgets and wrapping the widgets themself with the standardized DynamicWidget API to control them. Problems with this design -.

This ‘forced’ us to have different files for each custom widget. References to the entry points were stored as a class attribute of GstElementSettingsWidget.

When Pitivi does have the ‘plugins’ feature, it should somehow, if required, be able to access this custom widget API, which this didn’t allow. The current design The solution we came up with was to add a ‘createwidget’ signal to EffectsPropertiesManager and connect a callback which would call the corresponding createfoowidget method for a ‘foo’ effect. An accumulator stops emission of the signal when we receive a widget, again if all else fails then we fallback to the default handler of the signal which auto-generates the UI for the effect. This removed rigidity in the API, giving the option of creating custom widgets in single or multiple files, it is left up to the one creating the widget. We are no more storing reference to the createwidget methods for individual widgets. Plugins can connect to the ‘createwidget’ signal to provide enhancements.

Another possible improvement While making an example custom UI for the ‘alpha’ filter effect I noticed that within the custom widget for the effect, the widgets for individual properties can turn out to be same as the ones auto-generated. Having this additional feature of using a single custom widget for a particular property and auto-generating everything else would prove useful in such cases. Although the for custom widgets is up and running with tests, we at Pitivi want to have stable 1.0 release, as result, the current decision is that Google Summer of Code projects will not be part of this release. Feel free to ping me on #pitivi channel on freenode:) Until next time. It’s been three weeks since the coding period for GSOC 2017 started, so it’s time to show the world the progress I made. A short recap: I’ve been working on building a user interface which allows simulating the and other similar effects in.

The idea is to allow adding keyframes on x, y, width, height properties of a clip, much like we are doing with other effects. Fortunately, my mentor, Thibault Saunier, implemented this feature about 2 years ago, but a rebase of that branch was impossible, as the codebase underwent a lot of changes in the meantime. Even so, having his work as a guideline allowed me to move pretty fast. By now, I’ve implemented an interface that can be used to add and remove keyframes on transformation properties, using the transformation box to specify values at various timestamps. Here is a short demo.

Ultimately, my aim was to provide an interface, at the code level, for developers (rather designers) to improve the GUI of video effects. GStreamer effects are very beautifully handled in Pitivi, the main focus was to use this existing underlying infrastructure on top of which a way of easily adding custom UI for effects had to be setup. One of the ways of stopping ‘duplication of effort’ in Open Source projects is to document everything, even failed/blocked attempts.

Thanks to nekohayo (previous maintainer at Pitivi) opening task, his work from 2013 towards providing such an interface is now up and running again. Unless you want to preserve commits, rebasing a very old feature branch, that is not yours, is pointless. I did not want to waste time resolving merge conflicts in then unfamiliar code. Following a bottom-up approach, I started working on top of the current Pitivi master integrating the old code into it, step-by-step, one function at a time. Compiling and understanding the errors and then fixing them. I found this approach to be rather systematic and I think it is much faster since you start porting the code as you read it.

After I had completed porting, it was a first time for me hitting a regarding support for multiple authors on a single commit. I simply settled with the temporary solution of using. Hey everyone, This is the beginning of what seems to be a really exciting summer. Why, you ask? Well, it’s because I’m going to spend most of it as a true GNOME contributor, working on a really cool project. But let’s start from the beginning. Only 4 months ago, I was making my first steps as a contributor in the open-source world.

One of the first things I discovered is how amazing and helpful the GNOME community is. I started by trying out a lot of GNOME apps and looking through the code behind them and that’s how I discovered Pitivi, a really great video editing solution. After my first patch on Pitivi got accepted, I was really hooked up. Fast forward a couple of patches and now I have the opportunity and great pleasure to work on my own project: UI for the Ken Burns effect, after being accepted for Google Summer of Code 2017.

In this amazing journey, I’ve had some great mentoring: special thanks to Thibault Saunier (thiblahute), who is also my current mentor for GSOC 2017, and Alexandru Balut (aleb), who helped me along the way. The goal of my GSOC project is to allow Pitivi users to create effects based on the positioning and zoom of their clips (like the ). More precisely, when this project will be completed, Pitivi will support adding values for the position and zoom of the clip at various timestamps and smoothly transitioning between these values. I’m expecting a lot of fun while working on this project and I encourage you to keep reading my blog for further updates.

Happy coding! Has a few generic encoding presets you can use when rendering. You can see the list of presets and exactly what encoding options they specify by running x264 -fullhelp. You'll most probably notice the following presets: ultrafast, superfast, veryfast, faster, fast, medium, slow, slower, veryslow. Ideally you'd always use veryslow when rendering, but you can't always wait for it to finish, so you go for faster ones.

The ffmpeg wiki summarizes the: veryslow helps about 3% compared to the slower preset, slower helps about 5% compared to the slow preset, and slow helps about 5-10% compared to the medium preset.To be able to use for example slow with ges-launch-1.0, you need to create a GStreamer preset. Add the following section to slow12mbps speed-preset=slow bitrate=12288. Being someone who has already experimented with two transformation box approaches for Pitivi in the past, maintainers thought I might be the right person to do a modern one. Creating a user interface for a video transformation requires three things:. The implementation of the transformation. A way to draw the widgets over the viewer and. Mapping the input to the reverse transformation The transformation First of all the implementation of the transformation, which is in our case scaling and translation, is currently done by GES.UriSource, calculated on the CPU.

In the first Pitivi transformation box I did in GSoC 2012 this was done by the notorious Frei0r plugins from GStreamer Plugins Bad, which is also a CPU implementation. In the second version this was done on the GPU with the gltransformation element I wrote for GSoC 2014. A method to draw widgets over the viewer In Pitivi’s case, the viewer is a GStreamer sink. In all three versions rendering of the overlay widgets was done by Cairo, but it was done differently for all three implementations, since they all used different sinks. 2012: The first one used a hacky solution where the sink and cairo drew in the same Gtk drawing area, acquired for GStreamer with the Gst Overlay API. Many Gtk and GStreamer devs wondered how this worked at all.

This and Pitivi switching to more modern sinks was the reason why the first version of the box didn’t stay upstream for long. 2014: Still using Gst Overlay API, but this time with the glimagesink. The cairo widgets are rendered into OpenGL textures and composed in the glimagesink draw callback in the GStreamer GL context.

Worked pretty smooth for me, but didn’t provide a fallback solution for users without GL. Clearly an approach for the future, but how about something solid? 2016: Now we have the almighty GtkSink in Pitivi. It is a Gtk widget and overlays can be added via Gtk Overlay.

The sink is also exchangeable with GtkGLSink, which uses a GStreamer GL context to display the video texture and also can use GStreamer GL plugins like gltransformation without needing to download the GPU memory with gldownload. Cairo rendering now can be easily added over GStreamer sinks, yay. Linking the UI with the components doing the transformation The mapping of the input from the UI to the transformation is clearly dependent on the transformation you are using.

In the 2012 version I needed to map the input to frei0r^-1. In 2014 I used an OpenGL Model-View-Projection matrix calculated in Graphene, which could also do rotations and 3D transformations (we have a z-axis, yay). The 2016 implementation uses the inverse transformation for the GES.UriSource transformation, which is done by the GStreamer elements videomixer and videoscale. Of course things like keeping aspect ratio, maintaining limits and transforming Gtk widget coordinates to the transformation’s coordinates are part of this 3rd ingredient. Extensibility The new transformation box fits great with Pitivi by making clips selectable from the viewer, so you can manage multiple overlapping clips quite easily. But the best part of this implementation may be its extensibility.