WordPress Feature Request: A Universal Video Player

As any of you who have been following my screen casts know, I’ve been using Vimeo to host and share my videos.

However, Vimeo as it is is slightly restrictive: 500Mb uploads a week, and one HD video a week. for screen casts, HD is essential. So I’m limited to one video a week, if that.

Now that I’d love to do is to upload my videos to Windows Azure blobs. Blobs is comply format agnostic, so I could upload any format I wanted to: it doesn’t have to be Silverlight Adaptive Streaming (or whatever the term is). The CDN capability of Blobs is also very helpful.

Now nothing is stopping me from moving away from WordPress and being able to customise what every blogging system i’d run to load videos from Windows Azure Blobs. However, that’s a little more trouble that’s it worth right now.

(I’m actually thinking of eventually moving to Windows Azure utilising the extra small instance, but that’s a ways off)

So what I’d love is a video player that you can just point at a URL and it will play the video. It doesn’t have to be Silverlight or Widows Media specific. It could be H.264 files (an iffy proposition with Google yanking H.264 support from Chromium to be sure).

So in other words, WordPress can provide the player in whatever form it wants to. I just provide the player with the URL to the file to be played.

I would think that the HTML5 spec would make this a fairly trivial undertaking.

In fact, now that I think of it. Couldn’t one simply insert a tag in the HTML view of posts??

Windows Azure Feedreader Episode 8

Apologies for the long delay between episodes. I do these in my spare time and my spare time doesn’t always coincide with a quite environment to record the screencast.

But safe to say, I’m super excited to be back and doing these once again.

So, to it!!

This week we follow straight on from what we did in week 7, and modify our backend code to take account of user subscriptions when adding RSS feeds and RSS feeds from OPML files.

Additionally, we lay the ground work for next weeks episode where we will be writing the code that will update the feeds every couple of hours.

And finally, and perhaps most importantly, this week we start using the Windows Azure SDK 1.3. So if you haven’t downloaded and installed it, now is  the time.

There are some slight code modifications to take account of some breaking changes in 1.3 that are detailed in Steve Marx’s post on the subject.

Finally, I’ve just realised that the episode contains the wrong changeset information. The correct changeset is: 84039 (I’ll be correcting this slight oversight. Perfectionism demands it)

So, enjoy the show:

Remember, you can head over to vimeo.com to see the show in all its HD glory.

As I said, next week, We’ll be writing the update code that will automatically update all RSS feeds being tracked by the application.

Windows Azure Feedreader Episode 7: User Subscriptions

Episode 7 is up. I somehow found time to do it over several days.

There are some audio issues, but they are minor. There is some humming noises for most of the show. I’ve yet to figure out where they came from. Apologies for that.


This week we

  • clear up our HTML Views
  • implement user subscriptions

We aren’t finished with user subscriptions by any means. We need to modify our OPML handling code to take account of the logged in user.



Remember, you can head over to vimeo.com to see the show in all its HD glory.

Next week we’ll finished up that user subscriptions  code in the OPML handling code. 

And we’ll start our update code as well.

Windows Azure Feedreader Episode 6: Eat Your Vegetables

A strange title, no doubt, but I’ll explain in a moment.

Firstly, apologies for the delay. I’ve been busy with some other projects that couldn’t be delayed. And yes, I have been using Windows Azure Storage for that.

I’m doing some interesting work with Tropo, the cloud communications platform. It’s similar to Twillo. So, at some point I’ll do a screencast – my contribution to the lack of documentation for Tropo’s C# library.

This weeks episode had the stated intention of testing the Opml upload and storage routine we wrote back in Week 4.

We manage this, reading in the contents of the OPML file, storing the blog metadata in Windows Azure tables and the posts in Blob Storage.

However, in getting there, we have to tackle a number of bugs. Truthfully speaking, a few could have been avoid earlier – such as the fact that calling UrlPathEncode does not remove the ‘+’, and so IIS7 freaks out as a result (e.g. when blob names are used in URLs).  Others, I had no idea about – like the requirement for only lowercase blob container and queue names.

Which brings me to why I’ve named this episode as such. Dave Winer wrote a brilliant post earlier this week about working with Open Formats. To quote him:

1. If it hurts when you do it, stop doing it.

2. Shut up and eat your vegetables.

3. Assume people have common sense.

Number 2 says you have to choose between being a person who hangs out on mail lists talking foul about people and their work, or plowing ahead and making software anyway even though you’re dealing with imperfection. If you’re serious about software, at some point you just do what you have to do. You accept that the format won’t do everything anyone could ever want it to do. Realize that’s how they were able to ship it, by deciding they had done enough and not pushing it any further.

So, this episode is about doing exactly that – shutting up about the bugs and getting the software to work.

The fact is that every episode so far has been about writing the foundations upon which we can build. The bugs solved in this episode, mean we have few problems down the road. We have been immersed in the nitty gritty details, rather than build with out having to worry if our feed details are really being read and stored, or if our tables are being created correctly, or if blobs are being stored in the right containers.

Enjoy (or not) my bug fixing:

Remember to head over to Vimeo.com to see the episode in all its HD glory.

A word about user Authentication. While I don’t cover it in the video, I’ll be moving to use Google Federated Authentication over Windows Live ID. So for next week, I’ll have the Windows Live Stuff removed, and we’ll be using Google and the Forms Authentication integration the dontnetopenauth library provides.

Next week, the order of business is as follows:

  1. Clean up our view HTML
  2. ViewData doesn’t work in a couple of places – so we need to fix that
  3. Store user subscriptions.
  4. Make a start on our update code

PS. I added new pre-roll this week as an experiment. Hope you like it.

Creating Video Pre-Roll with Expression Design, Blend and Encoder

The only part of Expression Studio 3 I’ve really had a chance to work with is Expression Encoder 3 for the screencast work. So I thought I’d have some fun with the other parts of Expression Studio, namely Design and Blend.

Now, it took a bit to time to figure out, but its much easier designing your assets in Design than it is in Blend. Blend is for the animation. Its actually pretty easy to use, its well though out and all. So, once I figured that out, things were much easier.

Now, I really didn’t do anything too adventurous. Just making basic shapes on a canvas and animating them. No events, triggers or anything like that.

So I decided to do a pre-roll for the screen casts. Heres what I came up with:

If you want to do your own, its really easy.

  1. Using Expression Design, design the assets on the canvas. Make sure the canvas dimensions are the same as the resolution of the video (800 x 600, 1280 x 720, etc). This is important.
  2. Go to File->Export and chose “XAML WPF Canvas” as the format under Export Properties.
  3. In Blend, create a new WPF Application. Right click on the solution file and select “Link to Existing File”. Navigate to and select the file your exported earlier.
  4. Animate it by creating a new Storyboard. This will turn on recording.
  5. Save your file.

We now have our XAML canvas for our pre-roll. Now, using Expression Encoder, we can add this as a visual overlay to any video of our choice. However, we need video to overlay the XAML on to – as far as I know, you can’t add it any other way.

So go to Windows Live Movie Maker. Add credits to your new project. Delete the text. Choose a clip length – I chose 5 seconds. But This should be the same length as your Animation. Save your video. Make sure its the same resolution as your XAML Canvas.

  1. Go to Expression Encoder, Import the video from Windows Live Movie Maker.
  2. Got to Timeline->Add Visual Overlay. Navigate to the XAML file.
  3. Resize the overlay till it covers the entire screen.
  4. If you want to, add sound by going to Timeline->Add Audio Overlay.
  5. Hit encode.

It should be noted that you can only Import a XAML canvas as a visual overlay on Expression Encoder. And thats why we chose “XAML WPF Canvas” when we exported from Design.

If I have any upload quota left after this weeks Windows Azure Feedreader Screencast, I’ll add a short screencast demonstrating this.

Have fun.

Windows Azure Feedreader Episode 5: User Authentication

Firstly, apologies for being late with  this episode. Real life presented some challenges over the weekend.

This weeks episode focuses on the choice of user authentication systems. As I mentioned last week, there is a choice to be made between Google Federated login and Windows Live ID.

So, this week, I implement both systems.

It should be noted that I only do the basics for Google Federated Login – that is, only the openID part of the process. We’ll leave OAuth till later.

If you read my earlier post, I was still deliberating on which to use. Having actually worked with the dontnetopenauth library in an application centric manner, it does seem to be more appealing. Because it integrates nicely with Forms authentication, it lends itself to MVC. Also, because of this, having dual login systems isn’t going to be possible. So we have to choose one of them.

So next week, we’ll be removing the code  for the loser. As i said above, I’m leaning toward Google Federated Login.

So this week we cover:

Here’s the show:

And remember, you’ll have to go to vimeo.com to see the full HD version.

I had planed to test our OPML code that we wrote last week instead, but we’ll do that for next weeks episode. As  bonus, we can do it properly with full integration with user information.

About next weeks episode, I’m busy all weekend. The next episode may or may not appear on time next tuesday.