Latest News

Follow the latest news on OpenShot Video Editor!


,

Welcome to third and final update of the Epic OpenShot 2.0 Update! I've already received some great feedback on the previous two updates, so thank you for that. This update will not be as technical as the previous, so hopefully everyone who was a little lost will enjoy this one.

Open-Source Challenges

As everyone reading this knows, OpenShot 2.0 is an open-source application. Kickstarter has been a challenging balancing act. Certain backer levels on Kickstarter are promised early access to various things, such as alpha, beta, and final releases. But how can an application be built and shared freely, while also restricting parts of it to a small group of people? It is a challenge, and here is my plan to solve it.

The alpha, beta, and final installers (i.e. easy ways of installing and configuring the binary application files), will be released first to the backers on Kickstarter (as promised). After all, without their support OpenShot 2.0 might never have happened.

However, the source code to OpenShot 2.0 should be released to the broader open-source developer community prior to me building the installers. I need the community to get involved with testing, bug fixes, translations, documentation, and even packaging. This will result in a much happier community, and a much better product for the backers on Kickstarter.

So, my current plan is to first release the source code to the OpenShot Library, and then soon after that, the PyQt source code to OpenShot 2.0. For the average person, compiling OpenShot 2.0 themselves would not be advised, and they should wait for the alpha, beta, and final releases (with installers). I hope that all makes sense, and if not, please feel free to share your questions or comments with me.

Web-Based Video File Testing

One of the most important (and challenging) tasks for a video editor is to offer broad support for your favorite video formats. This is currently accomplished by utilizing the FFmpeg and/or libav projects. So, while I don't have direct control over these formats/codecs, it is my job to integrate them as best as possible.

Later this month (or possibily early February), I will be launching a web page which will let you share sample video and audio files with me (as long as they are less than 50 Mb). These sample files will feed into an automated testing suite that I have developed, and will be inspected, decoded, thumbnailed, audio waveforms generated, and transcoded. The results will be posted on the website... although I will probably not share the actual video file or thumbnails (due to copyright issues, inappropriate content, etc...). My ultimate goal is to develop a huge cross-section of video files with different formats and codecs, which can be used now and in the future to regression test updates to libopenshot. In other words, this will help compile a list of compatible video and audio files, as well as identify issues with certain file types. It is also another great way for people to contribute to OpenShot.

Common Profiles

What is a profile you ask? Well simply put, a profile is a collection of video settings, such as height, width, frame rate, display ratio, pixel ratio, etc... OpenShot has a large list of "profiles", but I am very interested in the most common profiles used by normal users. So, I will also soon be releasing a simple web-based form, which will allow users to submit their favorite and most common profiles they use when editing videos. I will also display this information on the website (in total), for others to view. This data, along with the previous data-set of supported video and audio files, will help me ensure I support the most popular formats and profiles, and thus, I satisfy the largest group of users.

Southern California Linux Expo (SCALE 12x)

On February 21 to 23, I will be representing OpenShot at SCALE 12x, one of the largest community run events focused on Linux and free software in the United States. Although this might take a few days away from programming, it is an important event for OpenShot and a chance for me to meet many users face-to-face, listen to feedback, and meet with other OpenShot developers. I will be demonstrating OpenShot 2.0 LIVE at the show, and hopefully by this time, many of you will also be playing with an alpha release at home. =) I'm also considering having a LIVE stream of the event, but I'm not sure I'll have enough bandwidth for that yet. So, if you are near Los Angeles, CA towards the end of February, please stop by and hang out with us a bit.

Thanks for your Support

One again, thank you EVERYONE for your support! OpenShot 2.0 is moving along as quickly as I can build it. I will be posting a new update at the beginning of each month, and will be releasing an alpha as soon as everything is stable. On a final note... I'm still fighting a C++ heap corruption issue on Windows, and if any expert C++/MinGW developer wants to jump in an offer me a hand and be a hero, please send me an email to jonathan@openshot.org!

,

Welcome to the second of three exciting updates on OpenShot 2.0! This update will be a bit more technical than the last, but I'll try and keep it understandable for those who want to follow the process of developing software, and especially the process of developing a video editor.

Sharing Data and Synchronizing Everything

OpenShot 2.0 contains many different modules which all need to have access to the same information. For example, the interface needs to know what files are available for a project, be able to undo and redo actions, communicate button clicks to the other modules, etc... The video player needs to know what clips to mix together, which effects to apply, what frame to display, etc... And the timeline needs to visualize this same data to the user, so they can see what's happening and arrange their clips, etc...

When a user moves a clip on the timeline, many things must happen. First, the timeline must communicate the clip's new position / location to both the interface (so it can be saved in your project, added to the project's history, etc...) and the video player (so it can update the video preview, and display the new video). And similarly, when a file is deleted from the interface (i.e. video project), the timeline needs to remove any clips related to that file, and the video preview must be updated.

So, they all need to access the same data, and communicate in 3 directions at all times. No problem, right? To accomplish this feet, we have built in some very robust support for JSON (JavaScript Object Notation). If you are not familiar with JSON, feel free to follow the link and learn more, but basically it is a simple, easy-to-write and understand notation, which can be used to share information between different programs.

In other words, we have 3 basic programs: a C++ video library, Python user-interface, and a JavaScript timeline. Of course, there is no built-in way for all these different programs to communicate. So, using the powerful JSON notation just felt right, and has worked great for us.

Using JSON to Communicate Changes

When something is changed in OpenShot 2.0, such as a new clip is dragged onto the timeline, a new file is added to a project, or the user clicks the undo button, this creates a small JSON string, which describes the change, and then distributes that change to all modules in OpenShot 2.0. Our powerful new video editing framework, libopenshot, can easily digest these special JSON "changes", and then only apply those changes to the current timeline. This is much faster than serializing our entire timeline on each change.

Not only is this an efficient model for sharing data between the interface, timeline, and libopenshot, but it is human readable, simple, and also allows us to use JSON in other creative ways. Such as a powerful undo / redo system, which is actually just re-applying these JSON changes in reverse or forward order.


Exciting Possibilities with JSON

By leveraging the power of JSON, it also allows us to save the project file as JSON, bind the JSON to our HTML timeline with Angular.js, and will allow users to easily edit their project files. In fact, it will even allow users to build their own project files dynamically with a little scripting... if they want to have some programming fun!

Okay, so hopefully you see some of the cool features that JSON will bring to OpenShot, but let me now demonstrate how easy it is to generate and use JSON in libopenshot with just a Python shell.

>>> import openshot 
>>> r = openshot.FFmpegReader("massive_warp_hd.mov") 
>>> print ( r.Json() )



Okay, so that was pretty easy! How about we change a few properties of this reader, by using some JSON of our own.

>>> r.SetJson(' {"width":640, "height": 480} ')

When Python, JSON, and libopenshot are combined, things suddenly become very fun! If you are especially bored one afternoon, you might find yourself in a Python shell editing a video project without any user-interface. When I catch myself doing that, it makes me laugh. Anyway, I hope you enjoyed part 2 of our special 3 part update! There are still many more updates to share, so I hope you will join me tomorrow evening for the final update (for now)!

,

Greetings OpenShot Backers! I hope everyone had a great holiday season and a happy new year! This is the first of three updates over the next couple days! So, be sure to check back often and keep up with all our new developments.

Schedule Update

Before I go any further, I first want to address the current schedule. My original plan was to release a beta around Christmas time and a final release mid-January, but unfortunately things were not quite ready. The last thing I wanted to do was to release an unfinished, broken version for everyone to try out. So, I made the hard decision to delay the testing releases to be sure things are ready on all 3 platforms. The work required to bring OpenShot fully cross-platform has been very challenging, but the show-stopping bugs are being knocked out, one by one, and there is a ton of progress to report, so please read on!

Development Expanded

Over the past couple months, I've expanded the OpenShot team to include Cody Parker and Noah Figg, who have been a tremendous help! In fact, the word tremendous does not do them justice... just know they have been a key part of the team to make OpenShot 2.0 a reality. They have completed dozens and dozens of tasks, and worked closely with me to bring all the different pieces together. Noah has focused on the Qt interface, improving the core PyQt framework to simplify our coding, solving complicated issues (such as cross-platform icon systems, translation system, undo / redo system, Qt integration with HTML timeline, and more). Cody has focused on the HTML timeline, JQuery integration, Qt integration, as well as leveraging the amazing Angular.js framework (used to bind our interface elements to our JSON data structure).

Bringing It All Together

We have been building OpenShot 2.0 in three different modules: libopenshot (the library which does most of the hard stuff), Qt interface (the user-interface which contains the buttons, sliders, labels, tabs, etc...), and the HTML Timeline (which is where you arrange your clips and effects). Most of the functionality in OpenShot 2.0 has now been programmed, but these independent modules are now being brought together, tested, debugged, and packaged (i.e. creating installers).

Windows Development =(

Many years ago, I used to develop software almost 100% with Microsoft's development tools (i.e. Visual Studio). So, I'm very comfortable within this operating system and development environment, or so I thought. Although, while I'm no longer using Visual Studio for OpenShot 2.0 (I'm using MinGW for those who are interested), I have been fighting Windows bugs for most of December, and wow, I've seen the dark side of Windows development with regards to working outside Microsoft's preferred tool set. The good news is, I've conquered most of these crazy bugs (many caused by subtle changes in Windows support for C++, and linking issues with Windows DLLs). I have one final bug on Windows that still has me stumped, related to a heap corruption caused by msvcrt.dll. So... if any developer out there want so to help me troubleshoot this issue on Windows, I would be most appreciative! I know... I can already hear the crickets chirping. =)

Of course, Mac and Linux support has been super easy, and simply a pleasure to work in those development environment. In fact, my build instructions document contains about 3 pages for Mac, 2 pages for Linux, and 12 pages for Windows... if that gives you an idea of how difficult Windows is to develop in.

Qt4, Qt5, GTK, PyQt, and Python3

Okay, that is a lot of acronyms, so let me explain. Over the coarse of the Kickstarter campaign, you may recall that I mentioned OpenShot 2.0 would be switching to Qt (used to draw our interface to the screen), instead of porting our GTK (our existing interface) code base. Well, we started work using Qt4 initially, which is widely distributed on Mac and Linux and generally easy to work with. However, we later discovered that Python3 requires Qt5 (and not Qt4). So, we made a decision to move to Qt5, PyQt5, and Python3.

Still makes no sense? Well, basically we are now using the latest version of Qt (for our interface), PyQt5 (a program to help us control Qt5 from Python), and Python3 (the latest version of Python... which is a programming language used by OpenShot). Unfortunately, this process of fine tuning our software stack slowed us down in October / November, but we now have this stack working great on Windows, Mac, and Linux. This stack represents the future of these frameworks and languages, and positions OpenShot in a good place for the future.

Want More Updates?!?

I hear you loud and clear! Stay tuned for part 2 of this update... scheduled for tomorrow (Saturday) evening! And part 3, scheduled for Sunday evening. And as I always like to reiterate, thank you so much for your support and patience!!! OpenShot 2.0 is not an easy application to build. Video editors are complex in many different ways. This Kickstarter represents important investments into many different and unique frameworks, such as libopenshot, and will pave the way for many wonderful open-source video editing platforms in the future.

Subscribe to: Posts (Atom)