#pitivi

[fabioarturoblog]

I made a "start" video from pitivi. I like that. Show this pitivi is awesome 🔥

[tommaso2]

Nuovo video in arrivo... #kdenlive vince su #pitivi

[blogimenaua]

Сам себе режиссёр: 5 бесплатных программ для работы с видео

Сам себе режиссёр: 5 бесплатных программ для работы с видео

Для работы с видео в той или иной форме почти всегда нужна программа, которая обладает определёнными возможностями. От небольших монтажных правок до сведения звука, от создания спецэффектов – до восстановления повреждённых данных.

Для запуска видеоблога вовсе не обязательно покупать дорогостоящие профессиональные программы. Как выяснилось, в сети полно бесплатных продуктов, которые ни в чём не ус…

View On WordPress

[cfoch-dev]

Hi, ImageSequenceSrc!

Hello guys. I've written an element in gst-plugins-bad which I called as GstImageSequenceSrc. It works very similar to GstMultiFileSrc, but there are some differences.

Differences with GstMultiFileSrc.

Handles a list of filenames instead of a printf pattern as GstMultiFileSrc does. * Having a list of filenames is useful because you can set the filenames you want, in the order you want. For example, you can add more filenames or sort the list. * There are two ways to create this list:     a) Setting a location propertie. This value could look like:

'/some/folder/with/images/ or .'

'/a/path/img.jpg,/other/path/img2.jpg' or 'img1.png,img2.png'

'/a/path/*.JPEG or *.png'

    b) Setting the filename-list (GList) directly. * Creates an "imagesequence://" protocol which allows the playbin to play this element. It handles a 'fake' uri but it is useful finally. gst-launch-1.0 playbin uri="imagesequencesrc:///some/path/*.jpg?framerate=20/1&loop=1" * It "detects" the mimetype of the images. You only have to worry about the framerate. * It calculates the duration.

Things to improve:

* Seeking: it seeks to the wrong image sometimes (actually, after many seeks). * The way duration is calculated.

PD: stormer, the guy who hangs on #gstreamer, was telling me to support png *and* jpeg files (both at the same time) but I don't see a usecase.

You can see the most-stable version of this element in  https://github.com/cfoch/gst-plugins-bad/tree/sequences/gst/sequences

The develop branch in (currently it is the same): https://github.com/cfoch/gst-plugins-bad/tree/sequences-develop/gst/sequences

[rin-tin-tezuka-blog]

God dammit Pitivi, get your shit together.

[cfoch-dev]

How would you like Pitivi image-sequence feature look?

Hello! I'm Fabián Orccón. I've been accepted to Google Summer of Code 2014 for GNOME with Pitivi. My project consists on adding an image-sequence feature to Pitivi. The usecases could be creating stop-motion films or a 2D animation for example. The idea of this feature came to my mind when I wanted to film a homemade stop-motion movie with my sister. I had Ubuntu, and by that time Pitivi was the video-editing tool by default. I realized that Pitivi doesn't have this feature implemented, and I wanted to do it. I'm not the expert in the arts of cinematography. I was talking with Pitivi people and Bassam Kurdali, director of the first open movie, about how Pitivi could handle this feature. After mixing and organizing ideas I have this mockup. It is just a draft; I don't know if I'm missing something. I would like you to tell me how would you like this feature should work. Your opinion as user is so important. Pitivi wants to be the best option for you!

Download | svg |

[gpctech]

[cfoch-dev]

How to play a video using GES?

Hello. I want to show you an example of a command-line video player using GES. This program is very simple and my purpose is you learn the basis. I paste the enterily code here if you just want to read the code.

from gi.repository import Gtk from gi.repository import GES from gi.repository import Gst from gi.repository import GObject import signal video_path = "/home/cfoch/Videos/samples/big_buck_bunny_1080p_stereo.ogg" def handle_sigint(sig, frame): print "Bye!" Gtk.main_quit() def busMessageCb(unused_bus, message): if message.type == Gst.MessageType.EOS: print "EOS: The End" Gtk.main_quit() def duration_querier(pipeline): print pipeline.query_position(Gst.Format.TIME) return True if __name__ == "__main__": GObject.threads_init() Gst.init(None) GES.init() video_uri = "file://" + video_path timeline = GES.Timeline.new_audio_video() layer = timeline.append_layer() asset = GES.UriClipAsset.request_sync(video_uri) clip = layer.add_asset(asset, 0, 0, asset.get_duration(), GES.TrackType.UNKNOWN) timeline.commit() pipeline = GES.Pipeline() pipeline.set_timeline(timeline) pipeline.set_state(Gst.State.PLAYING) bus = pipeline.get_bus() bus.add_signal_watch() bus.connect("message", busMessageCb) GObject.timeout_add(300, duration_querier, pipeline) signal.signal(signal.SIGINT, handle_sigint) Gtk.main()

We're going to start checking these lines.

Gst.init(None) GES.init()

We always need to use these lines to initialize GES. And you have to follow this order: initialize Gst before GES. If you change the order of these lines you program won't work.

The next important line is

timeline = GES.Timeline.new_audio_video()

With this line we create a Timeline. I understand the timeline as the general container. It will contain all the elements necessary to play the (edited) video or audio we want. A timeline contains GESVideoTracks and/or GESAudioTracks.

For example, if we want to play a video (with sound), our Timeline will contain both, a GESVideoTrack and a GESAudioTrack. If we want to play our favorite song, the timeline will contain only a GESAudioTrack.

In this case, this line is creating a GESTimeline adding to it a GESVideoTrack and a GESAudioTrack. It is a shortcut to it:

videotrack = GES.VideoTrack.new() audiotrack = GES.AudioTrack.new() timeline = GES.Timeline.new() timeline.add_track(videotrack) timeline.add_track(audiotrack)

The Timeline not only contains tracks, but also it contains many GESLayer. Our program will contain an only one GESLayer. But a Timeline is a stack of layers. The most-top layer will have the major priority. In the default case, the priority is given by 0. But... why do we need a GESLayer? Here we'll add our clips, our effects, transitions. So, a GESLayer is another container. We not only create a GESLayer with this following line, but also we append the created layer to our timeline:

layer = timeline.append_layer()

What it is a kind of confusing to me is the GESAsset. I found them as an abstract idea of information of the video or audio file for example we will use. However, a GESAsset is not only limited to audio and video. It can have information about an effect or about a GESVideoTrack/GESAudioTrack.

In this case we'll take advantage of the method request_sync GESUriClipAsset which allow us to create a GESAsset from a real file located in our computer, for example from a 'video.ogv'. This method gets information like the duration of the video.

asset = GES.UriClipAsset.request_sync(video_uri)

The following line will generate the clip from the asset and add it to the layer we've created before.

clip = layer.add_asset(asset, 0, 0, asset.get_duration(), GES.TrackType.UNKNOWN)

And To apply our changes...

timeline.commit()

To be able to display our video on the screen we need the GESPipeline. The GESPipeline allow us to play or render the result of our work, the result of our timeline. So a pipeline needs to be linked to a timeline.

pipeline = GES.Pipeline() pipeline.set_timeline(timeline)

By default, the state of the pipeline is NULL. However, we can change this state to PLAYING or RENDER. When its state is in PLAYING the pipeline will display the result in the screen. If the state is RENDER it will 'export' the result of our work in an out_file.ogv video, for example. We will set the state or mode of the pipeline in PLAYING because we want only to play the video.

pipeline.set_state(Gst.State.PLAYING)

If we remove lines bewtween 43 and 48 lines, and we execute the program, we can see the video playing. But these lines are necessary to handle when to stop the program. The program is an active process until something stop it. If we don't stop it, when our video has finished, it will be still executing. We don't want. We would like to stop/close/finish our program when. Ok... but... what do we have to stop? We have to stop the loop. What loop?

Gtk.main()

Every pipeline contains a GstBUS by default. A GstBUS is a system which is watching out to some mesages; this messages could be for example: the EOS of the video or another messages. See http://gstreamer.freedesktop.org/data/doc/gstreamer/head/gstreamer/html/gstreamer-GstMessage.html#GstMessageType. We need to add a message handler to the bus of our pipeline using gst_bus_add_watch().

bus.add_signal_watch()

If you want to know more about the GstBUS, by the way. Look at this link: http://gstreamer.freedesktop.org/data/doc/gstreamer/head/manual/html/chapter-bus.html

We've already added the message handler, but now we need to add the function we're going to use to handle the message. This function is busMessageCb. 'Cb' from Callback. We connect the bus with this function with the following line.

bus.connect("message", busMessageCb)

The function busMessageCb is created by the developer. The target of this function is to stop the loop create by Gtk.main() when the playing of the video has finished.

def busMessageCb(unused_bus, message): if message.type == Gst.MessageType.EOS: print "EOS: The End" Gtk.main_quit()

We're finishing... this following line is just going to tell us what nanosecond of the video is the program playing each 300 miliseconds. Each 300 miliseconds our program will execute the duration_querier function which prints on the console the time of the video in a certain moment in nanoseconds.

bus.connect("message", busMessageCb)

Finally, as an extra, I want this program being able to get closed when the user press "Ctrl+C". The line below allow it. We're taking advantage of the signal python library. And the program knows when "Ctrl+c" keys have been pressed because of the signal.SIGINT parameter. When these keys are pressed it calls to the function handle_sigint(sig, frame) which says "Bye!" and stop the loop.

signal.signal(signal.SIGINT, handle_sigint)