First – this video by tekserv is a good introduction on some of the possibilities to get MIDI working as well as how to [...]]]> I’ve been experimenting with various methods to control the iPad via MIDI as well as getting pro-audio out of it, and now I’d like to share my results.

First – this video by tekserv is a good introduction on some of the possibilities to get MIDI working as well as how to get clean audio out, and is worth viewing:

But, what if you wanted to do both MIDI in/out and pro-audio out at the same time?  You can – read on as I run through a few options you have, starting simple and going into full DAW integration:

Options with MIDI, Audio and the iPad:

First, for any of this stuff to work you’ll need to go out and buy a Camera Connection Kit ($29), which confusingly can do much more than connect to cameras – in fact it can get USB digital audio out as well as MIDI in and out.  With that out of the way:

• How to control the iPad with a USB MIDI Keyboard:

This setup will allow you to control an iPad soft synth, like Animoog, with a physical MIDI controller keyboard.  If your lucky you should be able to plug up your USB MIDI Keyboard into the CCK directly and it should “just work.”  It will “just work” based on two factors: first, your keyboard should be CoreMIDI compliant (in other words, it follows the MIDI specification and doesn’t do anything “weird” or proprietary. Lucky for you you can visit iosmidi.com for more information on supported keyboards). Second, your device can’t draw too much power as the iPad is stingy with how much power it’ll give connected devices.  The good news is that if your keyboard is power hungry you can plug it up to a powered USB hub and connect the powered USB hub to the CCK, as shown above.

• How to control the iPad with an old-school MIDI Keyboard:

You can also control the iPad with MIDI via a USB/MIDI interface.  Again you’ll need to make sure it’s CoreMIDI comptable and you may need to plug it in via a powered USB hub if it draws too much power.  I’ve used E-MU interfaces, which I like (and work happily with CoreMIDI).  In the diagram above I show a 1×1 interface, but really any CoreMIDI-supported MIDI interface will work.

• How to capture digital audio from the iPad:

By using a USB Audio interface/DAC plugged into the CCK you can capture pure digital audio out directly from an iPad app which you can then plug into a mixer (as in this diagram), or to a four track, cassette player, or whatever analog input you want.  Since I record everything on my laptop I’m showing off my setup, which is iPad audio to a Firewire mixer, than back into my computer.

• How to capture digital audio while controlling the iPad with a MIDI Keyboard:

This is where the real fun begins.  The CCK will send out both USB MIDI and USB Audio just fine, and your hub will do all the work!

• Incorporating an iPad into a DAW controlled studio as another instrument (aka building a ghetto Alesis IO Dock):

Now we’re talking.  With this setup you can add in the iPad as another instrument in your studio.  The idea is to send/recieve MIDI data to/from the iPad via a DAW (I’m using Logic Studio) as well as capturing pro-audio out via the DAC at the same time.  To do this, you’ll need the following:

• A powered USB Hub – I’m using one I got from Staples.  You might want to avoid any dirt cheap $5 questionable Chinese hubs. (~$30)
• The Apple Camera Connection Kit ($30)
• A 1×1 USB/MIDI Interface (Male USB to Male MIDI) (~$20)
• Another USB/MIDI Interface (Female MIDI to Male USB) – See note below (~$30)
• A USB Audio Interface – I’m using the Beringer UCA202 - See end of this post for more info (~$30)
• RCA cables and a project box (~$10)
• Total cost: ~$120 assuming you already have a USB/MIDI interface, ~$150 otherwise.

By cramming all of this in a project box, you get this (mine complete with crude Sharpie graphics):

A few notes:

• Since I have a bedroom studio thing going on I had some of this stuff lying around already (making it a fun experiment to try).  If you don’t have any of this stuff need to buy everything on this list you should consider an Alesis iO Dock which basically is this plus some more output options and around $40 more.  If there is a benefit to its ghetto clone, though, it’s that you don’t need to keep the iPad sloped downwards locked into position and you can use it in portrait mode.
• If you notice in the diagram I have a MIDI/USB interface going into a MIDI/USB interface which seems redundant.  Unfortunately – working with off-the-shelf parts like this – I wasn’t able to plug a USB cable from the CCK or from the USB hub to my laptop and have OS X recognize that I plugged up a MIDI capable device.  There may be an app to workaround this (or this may work on a Windows machine) so if you find it out let me know!

Gotchas:

• There are a few cases where USB MIDI or USB Audio will stop working suddenly.  The fact is it is still somewhat temperamental (I suspect a combination of the closed nature of the iPad and the lack of CoreMIDI documentation).
• I noticed that whenever I changed the MIDI setup of my studio Sunrizer started to silently fail and stopped receiving MIDI data.  Force quitting the faulty app fixes this (To force quit: Exit to the home screen, then double tap the home button to bring up the multitask tray, hold down on the problematic app, then click its “X” button).  This is always a good thing to try in general if things aren’t working.
• Plugging up the USB hub via the CCK and then plugging in the AC adapter caused the iPad to declare that the device was using too much power.  However, plugging up the AC adapter, then plugging the USB hub in to the CCK was fine.  My guess is that doing this in the wrong order sends a voltage spike that causes the iPad to reject whatever is plugged into it.
• Attempting to use the full setup just flat-out stopped working for me when the iPad got to around 20-15% battery life (In my case the light on the hub was no longer illuminating, meaning the USB hub wasn’t actually on).  Trying again with more battery life fixed this.

Why USB Audio? Why not just use the headphone port?

USB Audio is going to be your cleanest audio source from the iPad, since you’ll be getting digital audio direct from the iPad app to your own DAC.  I’m using a Beringer UCA202 which is cheap and works great.  NwAvGuy has an amazingly thorough anlaysis on the Beringer - tl;dr version: It’s a damn good DAC considering the price.

Your next best option for pro-audio is to get line audio out from the iPad pin connector, but this means two things. First, your audio will be colored by the iPad’s DAC.  I admit that I don’t know the quality of the built in iPad DAC, and it’s highly possible that the difference between the iPad’s DAC and an external DAC is reasonably negligible.  Still – by using an external DAC you are giving yourself the option to upgrade the DAC if you wanted.  Second, you’d need to solder up a connector for this to work that would essentially be a hybrid of the CCK (for MIDI) and the line audio out.

For pro-audio you absolutely don’t want the headphone port since that is colored by both the iPad’s DAC and its headphone amp circuitry.  The headphone audio out is made to be good enough for you to listen to but not something you’d want to commit to a recording.

What about the Line 6 MIDI Mobilizer?

Well, I don’t own one, so I can’t speak to how well it works, but I think the CCK is definitely the way to go here.  Any app that supports CoreMIDI (from iOS 4.x and up) should work with the CCK, whereas apps have to add in support for the MIDI Mobilizer which is non-standard.  Plus, the CCK is cheaper!

What about the iRig MIDI?

Thanks to Will in the comments who pointed me towards the iRig MIDI.  I also don’t own an iRig, but from what I can read online the iRig will remove the need for you to buy a MIDI interface and a Camera Connection Kit, instead you can just get the iRig and get MIDI in and out.  What I don’t know is if  you can connect the iRig’s USB cable into an external DAC like the Beringer and get USB Audio out or if your confined to the noisy headphone port.  If any iRig MIDI owners want to experiment with this please reply back and let me know.

Andy Lemay made a very useful post on how to use fluid to run Amazon CloudPlayer as its own app. In a nutshell: You can download an excellent application called Fluid to create a desktop version of a webpage – in this case, the [...]]]> …Sorta. :) Code is at GitHub! Explanation below:

Andy Lemay made a very useful post on how to use fluid to run Amazon CloudPlayer as its own app. In a nutshell: You can download an excellent application called Fluid to create a desktop version of a webpage – in this case, the newly released Amazon Cloud Player. This worked great, however I was hoping to get keyboard shortcuts and Growl notifications working. Luckily, Fluid has a UserScript API to allow you to write UserScripts (essentially just js files) which can be loaded into the web application.

Now to poke around! Digging into the page and js files in Amazon CloudPlayer revealed a nice API that I figured I could hack into. TextMate’s ‘Reformat Document’ was a huge help here to turn the minimized js files into something human readable.

The resulting UserScript I wrote polls amznMusic.widgets.player.getCurrent (which returns a lot of metadata on the current song playing) to display growl notifications when the metadata that it returns changes. The script also adds dock menu items to play/pause, play the previous song and play the next song. After some searching, I found that it’s possible to get keyboard shortcuts working with this, but it’s quite a hack. Keyboard triggers can be defined in Quicksilver to run AppleScripts, which in turn do some UI Scripting to “click” the dock menu items. There are a number of problems with this – it can be quite slow initially (taking up to a few seconds), you’ll see the dock menu flash on screen for a brief period, and you can’t use the media keys. It may be possible to overcome this by building a Cocoa plugin for Fluid, however I don’t have the Cocoa chops for that.

Get the code on the GitHubs. The README has a full rundown of all the steps you’ll need.

-> Begin call to AS: getSelectedItems()
Begin AS external [...]]]> I use a tail command alias (from FlashApe) to constantly output the contents of my flashlog file to the terminal which makes reading output very useful. However, if you use FlexBuilder/FlashBuilder at all, you’ll notice it will dump millions of useless comments such as

-> Begin call to AS: getSelectedItems()
<- End call to AS: getSelectedItems, Result = Text23
==> Begin AS external call: designViewComplete()
<== End AS external call: designViewComplete, Result =

Just resizing the design view is enough to dump tons of these statements into your trace output, which gets very annoying. While working on a project, a friend of mine had the idea of somehow removing these statements, which got me thinking. The dirty solution I came up with is to grep -v the flashlog before you send it to the tail command using a regex that will match any line starting with one of the four arrow characters (->, <-, ==>, <==). As a consequence, you will also remove any traces that begin with these characters, so be mindful of how you write your trace statements. I'm sure there's a way to modify this to search for 'Begin call to AS' and so on.

Anyway, the command is a bash alias called trace. How-to:

1. First, you'll need the Flash debug player if you don't already have it. Go to playerversion.com - if you don't see (Debug Player) by the version number, go here, and download the appropriate debug players for your browser/OS.

2. Next, go to the terminal and open your ~/.bash_profile

nano ~/.bash_profile

3. Then, add the following line somewhere within the file:

alias trace='tail -f /Users/YOUR-USER/Library/Preferences/Macromedia/Flash\ Player/Logs/flashlog.txt | grep -v "^\->\|^<\-\|^\=\=>\|^<\=\="'

4. Be sure to replace YOUR-USER with your username, or, if your flashlog.txt file is in a different location (I'm using OS X, linux will be different) change the command to point wherever your flashlog.txt file is located. If you don't have a flashlog.txt file, you can create one.

5. If you don't have it, create a file in your home directory called 'mm.cfg'. Add the following:

TraceOutPutFileName=/Users/YOUR-USER/Library/Preferences/Macromedia/Flash Player/Logs/flashlog.txt
ErrorReportingEnable=1
TraceOutputFileEnable=1
MaxWarnings=9999


6. Make sure TraceOutPutFileName is the same as the directory you put in your .bash_profile.

Now you should be able to type trace in the terminal to see the trace output, minus the pesky FlashBuilder comments! Yay!

Being somewhat of an audiophile, I’ve been encoding my music in lossless FLAC format for a while now – which is great, except when you want to put them on an [...]]]> Disclaimer: These instructions are for Ubuntu (or other Linux distro) – I will be doing an updated post later on to cover OS X.

Being somewhat of an audiophile, I’ve been encoding my music in lossless FLAC format for a while now – which is great, except when you want to put them on an iPod (which of course, won’t play FLAC files). One option would be to convert these files to Apple Lossless, however, I don’t mind sacrificing some quality to be able to put more music on my iPod. Plus, I probably couldn’t tell the difference while I’m listening to the iPod anyway.

Therefore, I wanted a shell script that I could run that would find out which files I had recently added to my collection and convert them to mp3s (preserving metadata). Then, I could grab those mp3s and put them into gtkpod or iTunes.

I created the shell script below borrowing liberally from other similar scripts I found online. The key thing about this script is that it keeps a simple flat text file database so that it can remember which files it has already converted.

The biggest problem I stumbled on was handling genres. For whatever reason, many command line and GUI tools refuse to let you write in your own genres – you pick from a pre-defined list. This boggles my mind – it seems presumptuous to me that some group would be tasked with coming up with all of the possible labels to all music. I listen to a lot of Electronic music, which alone covers ‘Drum and Bass’, ‘House’, ‘Techno’, ‘Electro’, ‘Progressive Trance’, ‘Microhouse’ and a trillion other tiny genres. In addition to sub-genres, you also have the problem of your cousins band which plays an Acoustic Goth-Country “experience” that defies categorization, and cannot simply be lumped into ‘Alternative’.

I found two solutions to this problem. For ripping from CDs to FLAC, I use EasyTag which will let you enter in genres by hand. EasyTag’s not my favorite program in the world, but it gets the job done and you can get it from your package manager. For decoding the FLAC files and encoding them to mp3s, I found id3 mass tagger by squell. My script below uses this program (simply called id3), so you’ll need to install that first.

In addition to the id3 mass tagger, you’ll need to have lame (for encoding mp3s), flac (for decoding flacs) and metaflac (for handling the flac metadata). On linux, all of these should be obtainable through your package manager.

Next, grab this script and save it somewhere that is in your path (for example, /usr/bin). Personally, I like making a bin folder in my home directory to keep all of my scripts. You do whatever tickles your fancy. Make sure to give the script executable permissions:

chmod 755 name-of-the-script

The script:

#!/bin/bash

#flac-to-mp3 will search FLAC_SOURCE_DIR for all flac files added since last time you've run flac-to-mp3.  These files will be converted to mp3s and placed in MP3_OUTPUT_DIR.  This script can be useful when maintaining a flac music collection along with a mp3 player like the iPod.

#Dependencies: lame, flac, metaflac, ID3 mass tagger (id3)

#Directory settings:
FLAC_SOURCE_DIR=/path/to/your/flac/files
MP3_OUTPUT_DIR=/path/to/where/you/want/to/output/the/mp3s
DB_DIR=/home/YOUR-USER-NAME/.flac-to-mp3

#You probably don't need to set these.  These specify the files that keep track of changes:
CURRENT="$DB_DIR"/current
INDEXED="$DB_DIR"/indexed
DIFF=/tmp/flac-to-mp3-dif
TMP_FILE="$DB_DIR"/tmp.tmp

IFS=" ";

if [ ! -d "$DB_DIR" ]; then
	mkdir "$DB_DIR"
fi

if [ ! -f "$CURRENT" ]; then
	touch "$CURRENT"
fi

if [ ! -f "$INDEXED" ]; then
	touch "$INDEXED"
fi

#Update index of flac files
find "$FLAC_SOURCE_DIR" -type f -name "*flac" > "$CURRENT"

#Get a list of files that have been newly added
if [ -f "$DIFF" ]; then
	rm "$DIFF"
fi

#Sort the database files so the diff won't have problems with files being in a different order:
sort "$INDEXED" > "$TMP_FILE"
cat "$TMP_FILE" > "$INDEXED"
sort "$CURRENT" > "$TMP_FILE"
cat "$TMP_FILE" > "$CURRENT"

touch "$DIFF"
diff "$INDEXED" "$CURRENT" | grep ">" | cut -c 3- > "$DIFF"

#Reset IFS so that our for loop won't die on spaces
IFS="
";

#Encode the flac files that are new into mp3s into the MP3_OUTPUT_DIR directory.
for FLAC in `cat "$DIFF"`
do
	#We first have to detect for duplicates.  If an mp3 file of the same name exists in the MP3_OUTPUT_DIR then we should append (2), (3), and so on to the filename.  Otherwise mp3 files would be overwritten.  This situation arises when there are two or more flac files with the same name.
	echo "${FLAC%.flac}" | sed 's/.*\///' > "$TMP_FILE"
	TMP=`cat "$TMP_FILE"`
	NUM_FILES=`ls "$MP3_OUTPUT_DIR" | sed 's/.mp3//' | grep "$TMP" | wc -l`

	if [ "$NUM_FILES" -gt 0 ]; then
		V=`expr $NUM_FILES + 1`
		MP3_PATH="${FLAC%.flac} ($V).mp3"
	else
		MP3_PATH="${FLAC%.flac}.mp3"
	fi

	#Encode flac file to mp3 file.
	echo "$MP3_PATH" | sed s/^.*\\///g > "$TMP_FILE"
	MP3=`cat "$TMP_FILE"`

	[ -r "$FLAC" ] || { echo can not read file \"$FLAC\" >&1 ; exit 1 ; } ;
	metaflac --export-tags-to=- "$FLAC" | sed 's/=\(.*\)/="\1"/' >"$TMP_FILE"
	cat "$TMP_FILE" > /dev/null 2>&1
	. "$TMP_FILE"
	flac -dc "$FLAC" | lame --preset standard --tt "$TITLE" \
	--tn "$TRACKNUMBER" \
	--ty "$DATE" \
	--tc "$COMMENT" \
	--ta "$ARTIST" \
	--tl "$ALBUM" \
	--add-id3v2 \
	- "$MP3_OUTPUT_DIR"/"$MP3"

	#We use ID3 mass tagger to write the genre tag - this will allow us to write non-standard genres.  ID3 can be found at http://home.wanadoo.nl/squell/id3.html
	id3 -2 -g "$GENRE" "$MP3_OUTPUT_DIR"/"$MP3"

	#Update the database:
	echo "$FLAC" >> "$INDEXED"
done

#Cleanup
rm "$DIFF"
rm "$TMP_FILE"

IFS=" "
MP3_PATH=
MP3=
FLAC=
FLAC_SOURCE_DIR=
MP3_OUTPUT_DIR=
CURRENT=
INDEXED=
DIFF=
DB_DIR=
NUM_FILES=
TMP=
V=
TMP_FILE=

Note that you’ll need to edit a few things, namely, the first three lines. FLAC_SOURCE_DIR should point to where you store your flac files. MP3_OUTPUT_DIR should point to a folder where you want the encoded mp3 files will end up. DB_DIR will be the folder that will hold the flat file databases. My script has a folder (.flac-to-mp3) in my home directory.

You may also want to modify the encoding options. Line 72 uses the –preset standard option – you might want to change this.

Outside of that, you probably don’t need to modify the script much. Read on if you want to know more about the inner workings of the script.

The script keeps two flat text database files – indexed and current. indexed lists all of the files that you have already encoded. When you run the script, current is rebuilt which is simply a list of all of the flac files in your FLAC_SOURCE_DIR. These two files are sorted, then a diff is performed to see which files exist in current that are missing from indexed. These are the files that (assumed) you have added since you last ran the script.

Next, a check is performed to make sure that a file of the same name doesn’t already exist in the MP3_OUTPUT_DIR. If it does, then a (2), (3) and so on are appended to the file name. After that, the script exports the flac metadata into a temporary file. Then, it decodes the flac file (line 72: flac -dc) and pipes that into lame. Next, id3 (the id3 mass tagger application) writes the id3 tag information into the newly created mp3. If all of these steps work, then the indexed file is appended with the name of the file (since it has already been encoded).

One final mega disclaimer: You’re at your own risk. I wrote this for my personal use and I haven’t tested it thoroughly, so backup your files or run the script on a small sample to make sure it works first!

Since I’m starting a blog, I have to get the introductions out of the way. I’m Zachary Berry, a web developer with a leaning towards Flex and Flash work. Since the end of 2004 I’ve been working as a Web Application Designer & Developer at the University of Central Florida under the New Media [...]]]> Jello!

Since I’m starting a blog, I have to get the introductions out of the way. I’m Zachary Berry, a web developer with a leaning towards Flex and Flash work. Since the end of 2004 I’ve been working as a Web Application Designer & Developer at the University of Central Florida under the New Media team. Before that, all of my web development work was simply various experiments, home-pages, angelfire sites, and the like.

I also enjoy synthesizers, music and long walks on the beach. Two of those passions will also drive some of the content for the blog.

There, now that that’s out of the way, we can get to the rest of the blog! :)