Recently, I discovered that sometime in the past, we had developed a bug where only our first conversion would succeed. A stack trace pointed to a memory corruption bug in our converter list. The converter list contains all of the converter objects, which are responsible for everything related to a loaded converter. As a result, they are accessed all over the program, and when I verified that all of them were created properly I was concerned that it was going to be a really nasty issue to resolve. However, as it was a fairly reliable crash that was easy to reproduce I decided to give git bisect a try.
For those who aren’t familiar with git bisect, it is designed for exactly this situation. You provide it with a known good commit and a known bad commit, and I performs a binary search on the commit history, giving you commits to test. After a few re-compiles and some quick test, git bisect helped me determine which commit was responsible for introducing the bug. This commit was “Now converts with a copy of a converter.” It was a one line change, replacing a pointer copy with the creation of a new object using a copy constructor. Class converter has no functional copy constructor, only the default compiler-generated one. Now the source of memory corruption was obvious, we were duplicating pointers, and trying to access them after they had been deleted.
This is exactly the sort of situation where a version control system shines. Because I could look back in time to see what had been done in the past, and because the commit was a small one making a single change, I was able to determine the cause of the problem much more quickly than I would have been able to had I needed to sift through all the code that interacts with converter objects. Lesson learned, commit early, commit often, and use your development tools where they shine, and they will make your job as a developer a lot easier.
Below are a pdf that we used for our poster and our slides we used in the last presentation.
We’re working hard to get Convalot 0.4 released.
Here are a couple of new gui features I’ve been working on lately.
Drag and Drop:
It is now possible to drag entire folders from the file tree on the left and drop them in the list of files on the right.
One thing I do have a question about is this, if you perform a drop directly into one of the tabs, should it grab all files or only the ones that belong in that tab?
Color indication about file progress:
Basically this feature highlights in progress conversions in yellow, and successfully completed conversions in green. The green boxes last for about 3 seconds and then the file is removed from the list.
Possible future improvements:
Have a sound clip play as a file is about to be removed from the list.
Have the box flash green twice before disappearing.
Contextual Convert Button:
This is actually a rather simple feature technically speaking, but I think it actually makes the program way more usable. The convert button is now contextual based on which tab the user is currently viewing.
This feature can be viewed in the above screenshot.
Intelligent Tab Switching
This feature occurs as a convenience for the user. When new files are added to the “to be converted list,” the category that they belong int is automatically switched to.
To completely understand the above features I believe it is easier to experience them through a demo. As luck would have it, this Friday, September 30, we will be presenting the project at the weekly RCOS meeting.
Until Next TIme,
We have a new blog now! It’s infinitely less terrible than the previous one. Also, we’re in the process of renaming everything to Convalot. Universal Batch Converter was just too long and the shortened “unibatchconv” was even worse. We also have a cool new logo now:
We have a long agenda for this semester and we’re getting started.
I finally got around to reimplementing GetConversion. It now correctly will find a greedy path to the target output if a direct path is not available. By greedy path I mean it does a breadth first search of the tree of possibilities and picks lossless conversions over lossy conversions and higher priority converters over lower priority converters at each stage. This is optimal for direct and 2 stage conversions, but beyond that it is possible to get a non-optimal path, though it doesn’t really matter enough to use Dijstras, which could slow the algorithm down quite a bit.
A lot of bugs were fixed in Converter as well.
Finally, the project now compiles and runs on OSX.
More to come,
We have recently pushed a lot of new features to the devel branch as well as bug fixes.
- Unicode filename support (still some bugs to figure out but it works)
- Moved logging out to its own class, which removes the dependency on Qt if CL_VERSION is declared. This is significant because Qt is huge so when we release the command line version, a user will be able to simply download and convert things with that and won’t have to download Qt (which is > 1GB) unless they want the GUI.
- Improved dynamically detecting which formats a converter supports on a given operating system by querying the underlying converter. Example: ffmpeg doesn’t support mp3 on linux by default, but we now will not display mp3 as an output since we ask ffmpeg what it supports instead of listing static values for it.
- Smarter format detection all around (We identify lossy vs lossless, and equivalent formats such as mp4 and m4v are now recognized as equivalent)
We’re working on a new website, hosting service, and blog. This will come with a name change because Universal Batch Converter is far too long and hard to abbreviate since UBC is taken.
We’re still working on fixing our multi-stage conversions (That is, converting from .X to .Y and then from .Y to .Z reliably, which is useful when there is no converter that goes directly from .X to .Z). As soon as we get all of this stuff
We have a mac for the summer! We will be working on getting this bad boy up and running on it as soon as possible and our next release should have a mac version as well!
That’s all for now,
We’re working hard to get another release going. There are a few more things we’re finalizing to make that happen:
- Finish adding multi-threaded plugin loading — This will make the GUI start up faster while simultaneously fixing other issues such as crashes that could occur as a result of a converter crashing. The feature is implemented as of now on the “threadedPluginLoading” branch, it just needs to be thoroughly tested and optimized. For example, currently the GUI just reloads tabs when a new plugin is detected (from scratch). This should be optimized to cleanly and unobtrusively insert the new plugin into the existing tabs when appropriate and create a new tab if necessary.
- More GUI feedback so user’s know what it’s doing. For example, when adding large numbers of files, the GUI hangs for a while. A progress indicator of some sort should indicate it’s adding the files (or, even better, it could do this in a background thread and not obstruct the GUI at all).
- Along the same lines, we need a solution for showing progress for single conversions, possibly even when a converter doesn’t reveal how far along it is in its conversion. If this isn’t possible, we should at least show a busy signal of some sort to let the user know it is indeed working still.
- Finish GUI side implementation for Advanced options. A lot of work has gone into this already and it is almost done. There are a few minor bugs to fix with it still.
- Fix multistage conversions from not producing inefficient paths to the correct output type.
- Windows Installer and Linux Packages
Some bug fixes worth mentioning:
- There was a linux bug where since we were forking and calling “exec” to call converters, if the exec call failed the child process would continue running and we would then have 2 universal batch converters running. Einarin promptly fixed this by dividing by 0 to crash the child process when exec failed. This was clearly the only and best fix; that is, until we realized we could just call exit() instead…but that’s so much less exciting than dividing by 0.
- Fixed the first deadlock we’ve ever gotten when loading multiple plugins simultaneously.
- Many other bug fixes not worth commenting on.
Mac Support Progress
- What’s a Mac?