Home

JMEdit

JMEdit is a Java-based non-linear video editor intended to provide simple methods for casual users to add effects to preexisting videos (such as a screen capture) that look professional while being quick to use.

Goals

• Portability - it should both compile and run on as many systems as possible, while requiring as few libraries as possible.
• Don't overcomplicate simple tasks - Adding text (or annotations) to a video shouldn't require much more than typing the desired text. Most (if not all) current Linux video editors don't seem to get this.
• General simplicity - in addition to the above, do a few tasks, and do them well. Other video editors exist for advanced tasks which are out of scope for this project.

Project Philosophy

• Workflow Integration - The software shouldn't become your workflow, but become part of it. In other words, not only should you be able to get done what you need quickly and efficiently, but you should be able to do this without wasting time fighting with the software.
• Learning Curve - It should "just work", but avoid oversimplification. Though the set of tasks that can be done may be limited, each one of those tasks should be sufficiently customizable to make sure it works in every applicable situation.

Libraries and Tools Used

• JRE 6 (Sun/OpenJDK/IcedTea supported)
• Apache Maven
• Apache Log4j
• FFmpeg

Get it!

JFFmpeg

JFFmpeg is the interface between JMEdit and FFmpeg. See here for more info.

Why?

I started the project when after becoming particularly aware of the somewhat abysmal state of Linux video editors. While trying to add some textual annotations to a video, something that one would think to be simple (see: YouTube's annotations), I became acutely aware of the complete lack of tools that would:

1. Run on Linux;
2. Compile on my system;
3. Allow text to be added (easily!); and
4. Work with WebM videos

No editors I tried met all four of these goals. Some didn't meet #2, and next to none met both #3 and #4. The was only one editor that came close to meeting #3, but it was still somewhat more complex than it really needed to be, had compilation issues, and crashed constantly. (I really do love this particular project, but unfortunately it still needs some work!)

I already did the vast majority of my video editing in FFmpeg - it's an awesome tool. Not only is it extremely easy to use (for a command-line application, especially), it's also really powerful, and supports practically every format ever (which basically no video editors do). The one thing it lacks, however, is a decent selection of video effects that would actually allow for proper video editing. Though that may be out of the scope of the project, I quickly saw FFmpeg as an easy way to access the video data, which would allow me to create my own video effects.

Having experience with the Java2D APIs, I knew that with proper access to frame data, a 2D graphics library could be extremely valuable for rendering video effects. I've got some experience in Java-based games, and I've seen the ease at which you can render good-looking graphics over a set of frames. Knowing that, I couldn't help but wonder why there wasn't already a good way to render to video frames in the same way that we already draw to the screen - that would make effects extremely easy to write, so why should there be obstacles preventing developers from making them?

And so came JFFmpeg. While it's far from being a full-blown FFmpeg wrapper, it does its job pretty well, and makes it extremely easy to render over a set of frames in much the same way normal graphics programming is done. JMEdit is the GUI realization for JFFmpeg, with an interface similar to most video editors, but with a focus on simplicity. While it has few functions, it makes them accessible, high quality, and quick to use.