Inchoate Thoughts » Programming

Launching Boxee with a Windows Media Center Remote

Jacob — Fri, 04 Jun 2010 04:28:49 +0000

Boxee

Updated 10/23/2010: Based on some comments, I’ve released a new version with an installer and file for defining custom parameters. Big thanks to Joshka for showing me a neat registry trick that allowed me to create the installer. I’ve also moved the source to a subversion repository. Enjoy!

I was recently notified that Boxee might benefit from the same hack I used to get XBMC working with my Windows Media Center remote (see the post before this one). The problem was the same. While you can use a Windows Media Center remote and IR receiver (or a universal remote emulating one) to control Boxee, the green button will continue to launch Windows Media Center. I was asked to modify the little launcher I had written for launching XBMC to launch Boxee instead. About 10 seconds of coding (and another 5 minutes of testing) later, I had what appears to be a working solution.

Download BoxeeLauncher Installer
Download BoxeeLauncher Manual Install

Source code, project files, and install scripts can be found at http://inchoatethoughts.com/boxeelauncher/ (subversion repository)

Launching XBMC with a Windows Media Center Remote

Jacob — Sun, 14 Feb 2010 04:29:57 +0000

XBMC

I recently took up the task of switching my media center software from Windows 7 Media Center to the Windows version of XBMC. I found XBMC easier to get working with obscure encodings of video files (it uses mplayer instead of the normal codec engine). But, my reasons for switching are not the point of this post. The point here is that switching to XBMC from Windows Media Center has a few challenges. One such challenge is getting the Windows Media Center remote to work in a nice way. Luckily, some excellent work has been done on that front. People have already provided premade media center remote configurations for XBMC. However, the “start” button on the media center remote still had the nasty habit of launching the Windows 7 Media Center app instead of launching XBMC.

I looked around the ol’ Internet for a solution to this problem. Turns out, the behavior of that “Start” or “Green” button on the media center remote is to cause a special key combination to be pressed. This key combination is bound to launching “C:\Windows\ehome\ehshell.exe.” The quickest workaround to the problem is to change ehshell.exe to something that launches XBMC. I then saw some people had written some batch files that launched XBMC. They then used a batch-to-exe converter to make it an executable and replaced ehshell.exe. That was great, but it still had a weakness. If, for some reason, XBMC was taken out of the foreground, it wouldn’t come back. Bummer. So I fixed it!

I wrote a little application to launch XBMC. It does a few things. First, it will check if XBMC is already running. If it is, it will bring it to the foreground for you. If it isn’t running, it will launch it. It will first try using the install location in the registry to find where to launch XBMC from. If it can’t find that, it will try the default location of the XBMC.exe file (both 32-bit and 64-bit versions).

Download The Installer

Manual Install Files and Instructions

Finally, here is the (very simple) source code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

using System;
using System.Diagnostics;
using System.IO;
using System.Runtime.InteropServices;
using Microsoft.Win32;

namespace XbmcLauncher
{
static class Program
{
[DllImport("user32.dll")]
private static extern bool SetForegroundWindow(IntPtr hWnd);

[DllImport("user32.dll")]
private static extern bool ShowWindow(IntPtr hWnd, int cmdShow);

private const int SW_SHOWMAXIMIZED = 3;

///

/// The main entry point for the application.
///

static void Main()
{
// Attempt to bring an existing XBMC to the foreground.
// If none exists, open XBMC.
if(!BringProcessToForeground())
OpenXbmc();
}

private static bool BringProcessToForeground()
{
Process[] processes = Process.GetProcessesByName("XBMC");
if (processes.Length != 0)
{
// If XBMC is currently running, bring it to the foreground
IntPtr hWnd = processes[0].MainWindowHandle;
ShowWindow(hWnd, SW_SHOWMAXIMIZED);
SetForegroundWindow(hWnd);
return true;
}
return false;
}

private static void OpenXbmc()
{
string xbmcPath = null;

// Attempt to find the XBMC executable location via the registry
RegistryKey key = Registry.CurrentUser.OpenSubKey(@"Software\XBMC");

if (key != null) // If the path is in the registry use it to open XBMC
{
xbmcPath = key.GetValue("") as string;
if (LaunchXbmcProcess(xbmcPath + @"\XBMC.exe"))
return;
}
else // Otherwise, we'll try to use the default locations
{
string x86Path = @"C:\Program Files\XBMC\XBMC.exe";
string x64Path = @"C:\Program Files (x86)\XBMC\XBMC.exe";

if (LaunchXbmcProcess(x86Path))
return;
else
LaunchXbmcProcess(x64Path);
}
}

private static bool LaunchXbmcProcess(string path)
{
if (path != null && File.Exists(path))
{
string args = "";
Process proc = new Process();

if(File.Exists("XBMCLaunchArgs.txt"))
{
using (StreamReader argStream = File.OpenText("XBMCLaunchArgs.txt"))
{
args = argStream.ReadLine();
argStream.Close();
}
}

proc.StartInfo = new ProcessStartInfo(path, args);
proc.Start();
BringProcessToForeground();
return true;
}
return false;
}
}
}

Get the full source, project files, and install scripts at http://inchoatethoughts.com/xbmclauncher/ (subversion)

foo_g15lcd 0.3c

Jacob — Wed, 27 Jan 2010 00:29:20 +0000

foo_g15lcd 0.3c

This is just a quick little update to let everyone know I’ve recompiled the foo_g15lcd component against the latest release version of Foobar 1.0. No new features, but everything still seems to be in excellent working order!

Grab it here: Download foo_g15lcd 0.3c

Extending ZenLibrary – Creating New Rules

Jacob — Sun, 13 Sep 2009 19:56:20 +0000

Hello everyone, this is an article about my ZenLibrary program aimed at those programmers who wish to either extend it or just know more about what’s going on behind the scenes. If you’re just interested in obtaining the program, click here.

I’ve *attempted* to make it easy for any programmer to extend the rules in ZenLibrary. Since I’m releasing this tutorial at roughly the same time as the actual program, I haven’t actually had a chance to get any feedback on how I might improve the extensibility interface. I do, however, want to make it clear I have no interest in making an elaborate end-user based rule scripting engine. Doing so would a.) screw up the simplicity of the program and b.) drastically change the scope of this software. Throwing in some user-defined regular expressions is about as far as I am willing to go.

Part 0 – Getting Set Up and Getting The Source

Creating new rules in ZenLibrary does NOT require getting the source code. One simply needs to reference “ZenLibrary.RuleBase.dll” that comes with the program (version 0.3 and later). However, I think having the source on hand will make debugging things a bit easier on your part. But, it’s all your call.

This project was done in C#, using WPF, and in Visual Studio 2008. Hopefully none of that made you too uncomfortable. You’ll pretty much need Visual Studio 2008 to deal with this solution. I suppose the Express edition of C# could work, but I haven’t tried it.

The source code is controlled in subversion. Everyone has read permissions on the repository. If you’d like to contribute to the project and need write access, drop me a line. This is an open source project, released using the LGPL.

ZenLibrary SVN Host: http://inchoatethoughts.com/zenlibrarysvn

Part 1 – How It Works

Before we get into how to add our own rules, let’s talk a bit about how this program runs. First, the user chooses a directory to scan through and the rules he wants to test against, and then he presses start. The program now launches a new thread (as to not stall the user interface thread) and begins to scan each directory. This is where our first set of tests begins to run. There are two different types of tests, or “rules” (I’ll be using the terms interchangeably). There are “per-directory” rules. These rules run on any directory with music files. These sorts of rules are useful for doing things like checking for the existence of a particular image file (e.g. album artwork) inside the directory. After the “per-directory” tests run, a set of “per-file” tests will be run against each of the MP3 files in the directory. The “per-files” are useful for checking the content of specific tags, checking for proper file name, etc.

Rule Scanning Flow

Forgive the terrible flowchart. Continuing on. This is a .NET program, so anyone extending this software will have the full .NET library at their disposal, which is pretty powerful in and of itself. However, since this is an audio library scanner, the program also makes use of TagLib#. TagLib, for those who aren’t already familiar, is a pretty powerful tag reader. It actually works on all sorts of media, not just MP3s with ID3 tags. TagLib# is then a .NET version of TagLib. It’s released under the LGPL, much like ZenLibrary, so packaging it and distributing it with this software is not a problem. ZenLibrary references TagLib, so when designing rules, don’t forget you have a good hunk of tagging technology to make us of. If you’re looking to do things with tags, just add a reference to “taglib-sharp.dll” as well.

Part 2 – Creating a Rule

Our task today is to essentially create one of the rules/tests that make up the meat of this program. I’ve done some work to make this as easy as possible. Here is what you’ll need to do:

Inherit from the “Rule” class
Give the rule a name (overload the Name property)
Define the TestType (“per-file” or “per-directory”)
Give it some test logic

That’s it! If you want a more elaborate rule with configurations that are persisted between application sessions, there is a ConfigurableRule class to inherit from and a few more overloads you’ll need to provide. But, let’s ignore that for now. We’re going to create a very simple rule. It’s purpose will be to detect for the presence of the “discnumber” tag in all of our music files.

Diagram for Abstract Rule Classes

Set Up The Project

First order of business is getting our add-in project created. Open up Visual Studio and create a new “Class Library” project. It doesn’t really matter what you name it, but you may want to indicate your name and that it is a file with ZenLibrary Rules in it. Pretend your name is Billy Bob. You might name the project “ZenLibrary.BillyBobsRules.” I’ve named my project “SampleRuleLibray.” Once you’ve created the Class Library project, go to your references folder, right click and select “Add Reference,” click the browse tab and go find “ZenLibrary.RuleBase.dll” (it comes packaged with ZenLibrary releases). For this particular “Discnumber” tag rule, we’re also going to be using the TagLib# library as well. Once again, add a reference using “Browse” and select “taglib-sharp.dll,” which should also be in the ZenLibrary directory.

References Defined

Inherit From The Rule Class

Now that we have our project set up, we can go ahead and create our rule class. Create a new class file (I called mine “SampleRule.cs”). This class should inherit from “ZenLibrary.RuleBase.Rule.”

1
2
3
4
5
6
7
8
9

using ZenLibrary.RuleBase;

namespace SampleRuleLibrary
{
public class SampleRule : Rule
{

}
}

Give The Rule A Name

The rule needs a name. The name shows up in ZenLibrary’s rule panel on the left side and is how the user will identify your rule from the other rules. To specify a name, just override the “Name” property’s get. Pretty simple!

1
2
3
4
5
6
7
8
9
10
11
12

using ZenLibrary.RuleBase;

namespace SampleRuleLibrary
{
public class SampleRule : Rule
{
public override string Name
{
get { return "Discnumber Tag"; }
}
}
}

Define The Test Type

The test type determines if your test will be run per music directory or per file. It’s just a simple optimization effort, really. The per-directory test exists so that we don’t have to check for the existence of “folder.jpg” in the directory on every file scan. Conversely, the per-file test exists so we don’t have to rewrite logic to scan all of the files every time we run on a music directory. To define our Test Type, we override the “TestType” property’s get and specify “TestType.FileScan” for per-file and “TestType.DirectoryScan” for per-directory. Our test case is something that needs to be done a per-file basis, so we’ll use “TestType.FileScan” in the example.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

Give The Test Some Logic

Finally, the meat of the program. Our test. This is where the magic happens. The magic that you define, that is. Anything can happen here, really. Override the “RunTest()” method. You’ll be provided with either a “System.IO.FileInfo” for the file you’re scanning (on a per-file scan) or a “System.IO.DirectoryInfo” for the scanning directory (on a per-directory scan). If the scan is per-file, the DirectoryInfo parameter will be the directory where the file is. If the scan is per-directory, the FileInfo parameter will be null. From here on out, it’s up to you what to do with them. All that matters now is that you return a “RuleTestResult” at the end indicating whether the test has passed or failed. If the test has passed, mark “TestPassed” in the “RuleTestResult.IsPassed” property to true and return it. If it is has failed, mark “RuleTestResult.IsPassed” as false. Also, assign the “RuleTestResult.RuleTestFailedString.” This string is the message that will be displayed in the results box on the ZenLibrary UI. Additionally, you’ll want to specify the location where it failed by assigning “RuleTestResult.ResultPath.” This can pretty much always be the “FullName” property of the provided “DirectoryInfo.”

For the sample test case, I’ve added some logic, using TagLib#, to check whether the “Discnumber” tag is “0.” This is an indication that the “Discnumber” tag has not been assigned, and thus, fails our test.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

using ZenLibrary.RuleBase;

namespace SampleRuleLibrary
{
public class SampleRule : Rule
{
public override string Name
{
get { return "Discnumber Tag"; }
}

public override TestType TestType
{
get { return TestType.FileScan; }
}

public override RuleTestResult RunTest(System.IO.DirectoryInfo directoryInfo, System.IO.FileInfo fileInfo)
{
TagLib.File file = TagLib.File.Create(fileInfo.FullName);
RuleTestResult result = new RuleTestResult();
if (file.Tag.Disc != 0)
{
result.TestPassed = true;
return result;
}
result.ResultPath = directoryInfo.FullName;
result.RuleTestFailedString = string.Format("File \"{0}\" does not have the discnumber tag defined.", fileInfo.FullName);
result.TestPassed = false;
return result;
}
}
}

Boom! We’re done! Yep, that’s really all there is to it. Compile your Class Library and drop the output DLL in the same directory as ZenLibrary.exe. You don’t need to register it or anything. ZenLibrary will automatically detect its presence and instantiate any rules within.

The Sample Rule Running!

If you want to see more elaborate rules with custom configuration dialogs and the likes, you can grab the source code from the subversion repository and check out the included rules in the ZenLibrary.RuleBase assembly. You may also want to check out how to write a light plug-in infrastructure via reflection by taking a look in “RuleSet.cs” to see how I instantiate all the rules without programmers having to manually register them.

You can also download the sample rule project here.

Thanks for reading!

ZenLibrary – Cleanse Your Music Library (And Thus Your Soul)

Jacob — Fri, 11 Sep 2009 04:49:01 +0000

ZenLibrary's Main Screen

Here’s my latest “weekend project.” It was supposed to be a little tool I wrote for myself on a lazy Sunday afternoon. Then I decided I would release it to you all, and that causes a project to really balloon in scope. I had to worry about it crashing, clean up my code so no one could blackmail me with it later, restructure the architecture to be generic, blah, blah, blah. But, I’ll save all those boring details for the next blog post aimed at programmers. This is supposed to be the post where I tell you what this project does.

Thus, I present to you: ZenLibrary. It’s a simple tool for all of you people as obsessed with sanitizing your media library as I am. You give it your music library, and it tells you all the things wrong with it (presumably so you can fix them). Step 1, you tell it where your music library is. Step 2, you choose what rules you want to test against your music library. Step 3, you fix the problems it finds.

Here’s the feature list:

Simple, streamlined UI.
Comes with a set of common criteria for sanitizing a music library
Easily extensible rule architecture
User preferences saved between sessions.
Integrates with MP3Tag to quickly launch an editor on any errors it finds.
Double clicking any result takes you straight to that folder (again, for easy editing)

Requirements:

.NET Framework 3.5 SP1

Download ZenLibrary 0.4

For people interested in extending it or getting their hands on the source code, be sure to check out my next post on doing just that.

Version Updates:

9-14-2009: Release 0.4

- Fixed icon error causing crashes in Windows XP and Vista
- Moved included rules out to their own assembly.

9-13-2009: Release 0.3

- Created ZenLibrary.Rulebase.dll for plugin support

9-12-2009: Release 0.2

- Added initial support for M4A, OGG, and FLAC files.
- Added detailed error information for tests that are unable to complete (red exclamation circles).
- Changed “Stereo” test method to a simple check on the number of audio channels.
- Fixed bug in album art directory scanning
- Disabled rule options while scanning (to prevent thread collisions)

Custom Drawing Controls in C# – Manual Double Buffering

Jacob — Sat, 15 Aug 2009 18:43:10 +0000

I feel like this article is about four years too late. All the cool kids have moved on to WPF or something really awesome, like XNA, for their graphics needs. However, there are still a lot of us playing around in the .NET 2.0 mucky muck for various reasons. Of those still doing .NET 2.0 / WinForms / GDI+ programming, I’m surprised to see how many people draw their custom controls the wrong way. Yep, I said “wrong.” I blame the majority of the C# books out there. Most of them, in the chapter on System.Drawing, just tell everyone to draw their stuff in OnPaint() or in response to a paint event. PLEASE, STOP DOING THIS. I’ll explain why.

One should not have a lot going on in one’s OnPaint method. It should be very small, very straight forward. In 95% of my custom controls, my paint event looks something like this:

1
2
3
4
5

protected override void OnPaint(PaintEventArgs e)
{
if (!isDisposing && backbufferGraphics != null)
backbufferGraphics.Render(e.Graphics);
}

That’s it. Just two lines. Here’s what’s going on. OnPaint is the .NET equivalent of the Win32 WM_PAINT message being raised. It happens when a region of your control is “invalidated.” Invalidation occurs when Windows thinks your control needs to be redrawn for some reason. Examples include your control being resized, another window moving in front of it, your window losing and regaining focus, etc. Because OnPaint() is called so frequently and unpredictably, it is not wise to have a lot of complex and CPU-intensive operations going on inside of it.

You may be wondering what we do instead. You be smart and efficient about it. Because the drawing logic is often complex and expensive, you’ll want to do it only as often as necessary. This means having an off-screen buffer that you draw to. When it comes time to actually paint your control on to the screen, your control can just go take a look at our off-screen buffer and copy it to the display. Pretty simple. Now, there is added complexity when you consider that you may be drawing to this buffer at the exact same time your control needs to draw it to the screen. In this scenario, your control would have to site around and wait with an invalidated region until you’ve finished drawing to your buffer. What this usually looks like to the end user is an irritating flicker on the control. The flicker they see is a rapid switch between invalidated control regions (which are usually painted pure white, black, or some other random bit of color) and the drawn buffer.

A quick look around the net will reveal that the solution to flicker is “double buffering.” Now, mind you, none of this is a new concept. People have been doing this for about as long as computer graphics have existed. The difference is, it’s a lot easier now. .NET literally makes it as easy as setting a property on your forms or controls. Beyond that, a programmer used to have to actually manage two buffers manually and swap between them. This is more automated with the introduction of the BufferedGraphics and BufferedGraphicsContext classes. Basically, you draw to the BufferedGraphics class, and it takes care of the double buffering for you. Here is an example constructor and buffer creation routine.

Constructor setting up the form’s double buffering properties:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

public DoubleBufferedControl()
{
InitializeComponent();

// Set the control style to double buffer.
this.SetStyle(ControlStyles.AllPaintingInWmPaint | ControlStyles.UserPaint, true);
this.SetStyle(ControlStyles.SupportsTransparentBackColor, false);
this.SetStyle(ControlStyles.OptimizedDoubleBuffer, true);

// Assign our buffer context.
backbufferContext = BufferedGraphicsManager.Current;
initializationComplete = true;

RecreateBuffers();

Redraw();
}

And here is an example of creating the buffers

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

private void RecreateBuffers()
{
// Check initialization has completed so we know backbufferContext has been assigned.
// Check that we aren't disposing or this could be invalid.
if (!initializationComplete || isDisposing)
return;

// We recreate the buffer with a width and height of the control. The "+ 1"
// guarantees we never have a buffer with a width or height of 0.
backbufferContext.MaximumBuffer = new Size(this.Width + 1, this.Height + 1);

// Dispose of old backbufferGraphics (if one has been created already)
if (backbufferGraphics != null)
backbufferGraphics.Dispose();

// Create new backbufferGrpahics that matches the current size of buffer.
backbufferGraphics = backbufferContext.Allocate(this.CreateGraphics(),
new Rectangle(0, 0, Math.Max(this.Width, 1), Math.Max(this.Height, 1)));

// Assign the Graphics object on backbufferGraphics to "drawingGraphics" for easy reference elsewhere.
drawingGraphics = backbufferGraphics.Graphics;

// This is a good place to assign drawingGraphics.SmoothingMode if you want a better anti-aliasing technique.

// Invalidate the control so a repaint gets called somewhere down the line.
this.Invalidate();
}

Now, there is one critical place where we make sure to call RecreateBuffers(). That is when the control is resized. The buffers we create in RecreateBuffers() are all sized to match the control’s size. If the buffer wasn’t the size of the control, the control would repaint with a large region of invalid graphics. So, just make sure you have a call to RecreateBuffers in OnResize for your control:

1
2
3
4
5
6

protected override void OnResize(EventArgs e)
{
base.OnResize(e);
RecreateBuffers();
Redraw();
}

That’s pretty much all you need to get a custom double buffered control going. You may have noted that I made a few calls to “Redraw().” Redraw() is where I put my actual drawing logic. What goes in Redraw() is the meat of how you render your control. Just remember, call it only when needed. Don’t go and put the call to Redraw() in OnPaint(). That would be against everything this article tried to teach. This method of rendering is very powerful and I’ve created a number of real-time fast-rendering controls with this mechanism. I’ve been using this method for many years now, so it is tried and true. One of the first times I started double buffering on a custom control was for a custom chart and spectrogram I made for some spectrum analyzer software I was working on. Here is a screenshot:

Realtime Graph and Spectrogram

Thanks for reading. If it helps anyone, I’ve attached a very simple sample project below that contains all the code I’ve shown above. If you have any questions or comments, feel free to use the comments below.

Download Sample Project

foo_g15lcd 0.3b

Jacob — Tue, 30 Jun 2009 01:03:59 +0000

I was looking at my bandwidth logs, something I do every year and a half or so, and noticed a lot of my traffic was for something I uploaded a long time ago. Let’s take a trip back.

Title screen - before a song is played.

The year was 2006. Bell-bottoms were the height of fashion and the telephone had just caught on (we called it the “harmonic telegraph” back then). Anyone who was anyone was using the foobar2000 media player. And anyone who was anyone, but was also a huge geek, was using it with their brand new Logitech G15 keyboard. However, through some perverseness in the space-time continuum, these two things didn’t work together.

The song playing display.

Adrenaline pumping, I ducked into the nearest phone booth, donned my cape, and flexed my mighty C++ muscles (which have now all atrophied). I tossed all sorts of code together, not caring who was hurt in the process. After a good three, maybe four, hours of blood, sweat, and tears, I had a plug-in that made Foobar2000 songs show up on a G15 keyboard.

Here we are, almost 3 years later, and guess what, some people are still using this thing! Weird! I know! Turns out, however, that because I haven’t recompiled it with the latest SDK, it has some real trouble working with the latest version of Foobar. So I’ve recompiled it! Grab it below:

Recompiled for Foobar 1.0!:
Download Foo_G15LCD Component Version 0.3c

PS: It looks like some cool dude by the name of “ectotropic” has gone ahead and obsoleted my sorry ass. He wrote a plug-in that not only does what mine did, but does all sorts of cool things that I wanted to do (like a spectrum analyzer display!). I encourage you to check out his plug-in. I don’t really use a G15 keyboard anymore, so I haven’t tried it, but it certainly looks cool!