This would require a jailbroken phone, since Apple and AT&T don’t like apps messing with phone calls, but I’d jailbreak mine this instant if there was an app like that.

You can see one of the radio towers on top of the peak in this picture (click to embiggen), which is from right about where I turned around.  I’d done 2000 feet of elevation gain at this point, and the peak would’ve been another 1000 and several more miles.

The highlight of the hike was Holy Jim falls.  Who knew there was an actual waterfall in Orange County?  And it even flows in the middle of summer! At least this year when there was lots of rain.

This was my favorite sight of the whole trip though, from the drive out to the trail on a very, very bumpy road.  The mist rolling over the valley and the sun just starting to peak through was spectacular.  I had to stop and get out to take pictures.  I don’t think they turned out very well though.  This is the best of the bunch, it’s the only one where you can really see all the hills going back.

I’m also using this post to test geotagging features on the site.  There should be an embedded Google Map below with the bridge’s location, and the new Map page for the site should show markers for all geo-tagged posts, including this one and a few random others I went and tagged.

Yet for all that complexity, there is STILL no way built into iTunes to make a Smart Playlist that can precisely select between High-def and standard-def TV Shows and movies.

My compromise is making a playlist that selects shows between 20 and 31 minutes that are greater than 500MB, and shows 39 minutes or longer that are greater than 900MB. Those numbers aren’t very precisely chosen, but they seemed to work properly for all but one episode in my library, there was one hour long episode that says it’s “HD” but is only 600MB, I ignored that one, but it illustrates why this is such a bad solution. There are standard def shows that are nearly 600MB in my library too.

The compromise some people come to is manually adding an HD Tag to the composer, description, comments, or some other field, but the whole point here is that I’m trying to avoid manually doing anything to differentiate them. I could just as easily add all the HD videos to a dumb playlist, and then select on that playlist in a smart playlist.

I’ve had this frustration for at least a year, since we first got an Apple TV. When, when, when will Apple fix it? Or if they have, then when, when, when someone on the internet figure out how to do it?

Since the thing I wanted this playlist for is already an Applescript that’s iterating TV Shows from a playlist, I suppose the “solution” in this case is to make the Applescript able to differentiate. The filename actually has an “(HD)” in it for HD episodes, and Applescript does have access to filenames, but iTunes proper can’t select on filename contents.

On the other hand, the horror of having to actually write more than a few lines of Applescript caused me to write just enough to be able to call out to a python script instead. So there’s a whole ‘nother rant about crappy Apple “programming languages” right there. I do realize that Python can use Applescript interfaces directly, but then it’s harder to just Download a script that almost does what I want and fix the parts that don’t.

None of it as easy or as fast as it would be at a “real” computer, but I’m pretty happy I was able to do it.

I guess that’s hundreds of dollars spent in order to emulate a 32 year old dumb terminal. Sounds like a bargain to me!

The hardest part of all of the above? Getting the links and pictures in this post. The WordPress software for iPad really kind of sucks. I did this via the web based HTML Editor. I probably should’ve used emacs.

Things Facebook used to know about me include:
I work at Blizzard
I live in San Clemente, CA
I attended UC Riverside and Dana Hills High School
I “like” Rock Sugar (the band), Bruce Campbell, Have’a Corn Chips, Swiss Army Knives, and half a dozen other random things
You can find various ways to contact me over there on the About/Contact page.

Also, this is my first post from an iPad. Typing on it really doesn’t suck!

The hardest (though not tallest) hill, had already walked down it, this picture was on the way back. The trail on the left and all along the ridge in the background to the hill at the right.

I’ve now switched back to software encoding using Handbrake.  To that end, I wrote a tiny little daemon that watches for files in one directory, encodes them, then moves them to the folder that iFlicks is watching and trashes the original.  iFlicks will then add meta-data (it searches thetvdb.com based on the file name), and finally send the file off to iTunes (which will then sync it to AppleTV.  WHEW that’s a lot of steps, you see why I need to write myself things to help?)

iFlicks can do software encoding itself, but it just uses Quicktime, which is a whole hell of a lot slower than Handbrake. Handbrake still doesn’t do 720p at real-time on a Mac Mini, but it’s only about half real-time, as opposed to Quicktime, which was taking 4-8 hours to encode an hour of video.

The script also gives me Growl notifications, and I have the Prowl app on my phone, so I get push notifications when encodings start and finish too.

Code after the jump.

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

#!/usr/bin/env python
 
# Normal usage: movieconverter /Users/ogre/HDDownloads
 
HANDBRAKE='/Users/ogre/bin/HandBrakeCLI'
DESTDIR='/Users/ogre/SBDownloads'
TRASH='/Users/ogre/.Trash'
ERRORS='/Users/ogre/Movies/Errors'
 
import sys
import os
import shutil
import time
import glob
 
ENCODING_DONE = 'Encoding Done'
ENCODING_STARTED = 'Encoding Started'
 
try:
    import Growl
    useGrowl = True
    print 'Using growl for notifications'
except:
    print 'NOT using growl for notifications, could not import Growl'
    useGrowl = False
 
if useGrowl:
    growl = Growl.GrowlNotifier(applicationName="Movie Encoder",
                                notifications=[ENCODING_DONE, ENCODING_STARTED])
    growl.register()
 
print 'Watching %s for movies' %( sys.argv[1])
 
while 1:
    files = glob.glob('%s/*.mkv' % (sys.argv[1]))
    for f in files:
        (name,ext) = os.path.splitext(f)
        output = name + '.m4v'
        cmd = '%s -i "%s" -o "%s" --preset=AppleTV' %(HANDBRAKE, f, output)
        print 'Found %s, running %s' % (f, cmd)
        if useGrowl:
            growl.notify(ENCODING_STARTED, ENCODING_STARTED,
                         'Starting encode: %s => %s' % (f, output))
        result = os.system(cmd)
        if result == 0:
            print 'Handbrake complete, moving %s to %s' % (output, DESTDIR)
            # iFlicks gets stuck when moving the file this way??
            #shutil.move(output, DESTDIR)
            os.system('mv "%s" "%s/"' % (output, DESTDIR))
            print 'Moving %s to trash' % (f)
            shutil.move(f, TRASH)
            if useGrowl:
                growl.notify(ENCODING_DONE, ENCODING_DONE,
                             'Finished encoding %s => %s' % (f, output))
        else:
            print 'Handbrake returned error code %d, moving file %s to %s' % (result)
            shutil.move(f, ERRORS)
 
    time.sleep(10)

I’m not going to link to any of the actual tools here, but they shouldn’t be too hard to find. My contribution is an SConstruct file for the SCons build system that automatically copies all my books to my computer and removes the DRM all in one step.  It’s not your typical use of a build system, but when I thought about what I was trying to do, I realized it was really just a simple dependency graph, something SCons is perfect for.

The complete process is:

1. Plug Kindle into computer via USB
2. In a shell, cd <path/where/this/file/lives>
3. scons

This will automatically get any new books, and remove the DRM (and in Topaz’s case, convert them into svg files viewable in a browser)

Installation is not difficult either:

1. Install SCons
2. Put this SConstruct file in the directory where you want to save your books
3. Get your Kindle’s PID and put it in the SConstruct file (the DRM tools will tell you how to do that)
4. Edit the location your Kindle gets mounted to. The one I have in there is for a Mac, but except for that path I don’t see any reason this won’t all work on any OS
5. Put the DRM tools in a tools subdirectory

SConstruct file after the jump

import os
 
env = Environment()
 
# Put your Kindle's PID here
env['KINDLECODE'] = '1234567890'
 
# Put the path to your Kindle when attached via USB
# (This is where it shows up on a Mac)
env['DEVICEDIR'] = '/Volumes/Kindle/documents'
 
# Topaz dedrm only wants the first 8 chars of the kindle PID
env['SHORTKINDLECODE'] = env['KINDLECODE'][:8]
 
env['MOBIDEDRM'] = 'tools/MOBI/MobiDeDrm09.py'
topazprogs='tools/TOPAZ/'
env['TOPAZDEDRM'] = topazprogs + 'cmbtc_dump_nonK4PC.py'
env['TOPAZ2SVG'] = topazprogs + 'gensvg.py'
env['TOPAZ2HTML'] = topazprogs + 'genhtml.py'
 
if os.path.exists(env['DEVICEDIR']):
    kindle = Glob(env['DEVICEDIR'] + '/*.azw') + Glob(env['DEVICEDIR'] + '/*.azw1')
    for k in kindle:
        Command('DRM/'+k.name, k, Copy("$TARGET", "$SOURCE"))
 
azw = Glob('DRM/*.azw')
mobi = []
 
for a in azw:
    base,ext = os.path.splitext(a.name)
    mobi += env.Command('#Mobi/'+base+'.mobi', a,
                        '$MOBIDEDRM $SOURCE $TARGET "$KINDLECODE"')
Ignore(mobi, env['MOBIDEDRM'])
 
azw1 = Glob('DRM/*.azw1')
topaz = []
for a in azw1:
    base,ext = os.path.splitext(a.name)
    topazdir = env.Dir('#Topaz/'+base+'/')
    dat = env.Command(topazdir.File('dict0000.dat'), a,
                      '$TOPAZDEDRM -v -v -d -o "'+topazdir.path+'" -p "$SHORTKINDLECODE" $SOURCE')
    svg = env.Command(topazdir.Dir('svg'), dat,
                      '$TOPAZ2SVG "'+topazdir.path+'"')
    topaz += svg
    #html = env.Command('#Topaz/'+base+'/book.html', topazdir,
    #                   '$TOPAZ2HTML $SOURCE')
    #topaz += html
    #env.Depends(html, svg)
 
env.Alias('all', mobi)
env.Alias('all', topaz)
 
env.Alias('mobi', mobi)
env.Alias('topaz', topaz)