File Coverage

blib/lib/Mac/iPod/GNUpod.pm

Criterion	Covered	Total	%
statement	22	24	91.6
branch			n/a
condition			n/a
subroutine	8	8	100.0
pod			n/a
total	30	32	93.7

#!/usr/bin/perl

package Mac::iPod::GNUpod;

=head1 NAME

Mac::iPod::GNUpod - Add and remove songs from your iPod; read and write
databases in iTunes and GNUpod format

=head1 ABSTRACT

This is the module to do anything with your iPod, with methods for initializing
your iPod, adding and removing songs, and reading and writing databases in the
iTunes and GNUpod formats. This module was originally based on the GNUpod
script package, written and distributed by Adrian Ulrich, (pab at
blinkenlights.ch), L. However, a lot of
development has occurred since then, making the module more flexible and more
appropriate for CPAN. This module and the GNUpod scripts remain completely
interoperable--they write the same file format and work in much the same way.

=head1 SYNOPSIS

    use Mac::iPod::GNUpod;

    my $ipod = Mac::iPod::GNUpod->new(mountpoint => '/mnt/ipod');

    # Read existing databases
    $ipod->read_gnupod;
    $ipod->read_itunes;

    # Add songs
    my $id = $ipod->add_song('~/music/The Foo Brothers - All Barred Up.mp3');

    # Get paths to songs
    my $path = $ipod->get_path($id);

    # Find the id numbers of existing songs
    my @yuck = $ipod->search(artist => 'Yoko Ono');

    # Remove songs based on id
    $ipod->rm_song(@yuck);

    # Write databases
    $ipod->write_gnupod;
    $ipod->write_itunes;

=cut

# Remainder of POD after __END__

use warnings;
use warnings::register;
use strict;

use Mac::iPod::GNUpod::Utils;
use File::Copy;
use File::Spec;
use File::Spec::Mac;
use XML::Parser;
use Carp qw/carp croak/;
our @CARP_NOT = qw/XML::Parser XML::Parser::Expat Mac::iPod::GNUpod/;

our $VERSION = '1.24';

# Global variables

sub new {
    my ($class, %opt) = @_;

    my $self = {
        mnt => '',          # Mountpoint
        itunes_db => '',    # iTunes DB
        gnupod_db => '',    # GNUpod DB
        allow_dup => 0,     # Whether duplicates are allowed
        move_files => 1,    # Whether to actually move files on add or rm
        files => [],        # List of file hrefs
        idx => {},          # Indices of song properties (for searching)
        plorder => [],      # List of playlists in order
        pl_idx => {},       # Playlists by name
        spl_idx => {}       # Smartplaylists by name
    };

    bless $self, $class;

    if ($opt{mountpoint}) {
        $self->mountpoint($opt{mountpoint});
    }
    elsif ($opt{itunes_db} && $opt{gnupod_db}) {
        $self->itunes_db($opt{itunes_db});
        $self->gnupod_db($opt{gnupod_db});
    }
    else {
        croak "You must specify either the mountpoint or both the itunes_db and gnupod_db options";
    }

    return $self;
}

sub mountpoint {
    my $self = shift;
    if (@_) {
        $self->{mnt} = File::Spec->canonpath(shift);
        $self->{itunes_db} = File::Spec->catfile($self->{mnt}, "iPod_Control", "iTunes", "iTunesDB");
        $self->{gnupod_db} = File::Spec->catfile($self->{mnt}, "iPod_Control", ".gnupod", "GNUtunesDB");
    }
    return $self->{mnt};
}

# Here we define the template get-set funcs
my @flags = qw/itunes_db gnupod_db allow_dup move_files/;
for my $flag (@flags) {
    no strict 'refs';
    *$flag = sub {
        my $self = shift;
        if (@_) {
            $self->{$flag} = shift;
        }
        return $self->{$flag};
    };
}

# Format a new iPod, create directory structure, prepare for GNUpod
sub init {
    my ($self, %opts) = @_;

    if (not $self->{mnt}) {
        croak "Can't init iPod without the mountpoint set";
    }

    # Folder structure
    for my $path( ('Calendars', 'Contacts', 'Notes', 'iPod_Control', 'iPod_Control/Music',
             'iPod_Control/iTunes', 'iPod_Control/Device', 'iPod_Control/.gnupod') ) {
        my @path = split('/', $path);
        my $path = File::Spec->catdir($self->{mnt}, @path);
        next if -d $path;
        mkdir $path or croak "Could not create $path ($!)";
    }

    # Music folders
    for(0..19) {
        my $path = File::Spec->catdir($self->{mnt}, "iPod_Control", "Music", sprintf("f%02d", $_));
        next if -d $path;
        mkdir $path or croak "Could not create $path ($!)";
    }

    # Convert iTunes db if allowed
    if(-e $self->{itunes_db} && !$opts{'noconvert'}) {
        $self->read_itunes;
    }

    # Make empty db otherwise
    else {
        open(ITUNES, ">", $self->{itunes_db}) or croak "Could not create $self->{itunes_db}: $!";
        print ITUNES "";
        close(ITUNES);
    }

    $self->write_gnupod;

    return 1;
}

# Convert iTunesDB to GNUpodDB
#
# This function almost entirely copyright (C) 2002-2003 Adrian Ulrich. Adapted
# from tunes2pod.pl in the GNUpod toolset
sub read_itunes {
    my ($self) = @_;

    require Mac::iPod::GNUpod::iTunesDBread or die;

    $self->_clear;

    Mac::iPod::GNUpod::iTunesDBread::open_itunesdb($self->{itunes_db})
        or croak "Could not open $self->{itunes_db}";

    #Check where the FILES and PLAYLIST part starts..
    #..and how many files are in this iTunesDB
    my $itinfo = Mac::iPod::GNUpod::iTunesDBread::get_starts();

    # These 2 will change while running..
    my $pos = $itinfo->{position};
    my $pdi = $itinfo->{pdi};

    #Get all files
    for my $i (0 .. ($itinfo->{songs} - 1)) {
        ($pos, my $href) = Mac::iPod::GNUpod::iTunesDBread::get_mhits($pos); #get the mhit + all child mhods
        #Seek failed.. this shouldn't happen..
        if($pos == -1) {
            croak "Expected to find $itinfo->{data} files, failed to get file $i";
        }
        $self->_addfile($href);
    }

    #Now get each playlist
    for my $i (0 .. ($itinfo->{playlists} - 1)) {
        ($pdi, my $href) = Mac::iPod::GNUpod::iTunesDBread::get_pl($pdi); #Get an mhyp + all child mhods
        if($pdi == -1) {
            croak "Expected to find $itinfo->{playlists} playlists, I failed to get playlist $i";
        }
        next if $href->{type}; #Don't list the MPL
        $href->{name} = "NONAME" unless($href->{name}); #Don't create an empty pl

        #SPL Data present
        if(ref($href->{splpref}) eq "HASH" && ref($href->{spldata}) eq "ARRAY") {
            $self->_render_spl($href->{name}, $href->{splpref}, $href->{spldata}, $href->{matchrule}, $href->{content});
        }

        #Normal playlist
        else {
            $self->_addpl($href->{name});
            # Render iPod pls in GNUpod format
            $self->_addtopl($self->{cur_pl}, { add => { id => $_ } }) foreach @{$href->{content}};
        }
    }

    # Close the db
    Mac::iPod::GNUpod::iTunesDBread::close_itunesdb();
}

# Parse the GNUpod db (in XML)
sub read_gnupod {
    my ($self, %opts) = shift;
    unless (-r $self->{gnupod_db}) {
        croak "Can't read GNUpod database at $self->{gnupod_db}";
    }

    $self->_clear;

    # Call _eventer as a method
    my $wrapper = sub { $self->_eventer(@_) };

    my $p = new XML::Parser( Handlers => { Start => $wrapper });
    # Save this value to be our overall return value
    my $rv = $p->parsefile($self->gnupod_db);

    # At end of file parsing unset cur_pl
    $self->{cur_pl} = undef;

    # Return value from parsefile
    return $rv;
}

# Write the iTunes Db
#
# This code adapted from the mktunes.pl script, copyright (C) 2002-2003 Adrian
# Ulrich.
sub write_itunes {
    my $self = shift;

    require Mac::iPod::GNUpod::iTunesDBwrite or die;

    # Undocumented, used only for debugging
    my %opt = @_;
    $opt{name} = 'GNUpod' unless $opt{name};

    my ($num, %data, %length, %ids);
    my @newfiles = (undef); # Will become $self->{files} at end

    # Create mhits and mhods for all files
    for (@{$self->{files}}) {
        next if not $_ or not keys %$_;
        # iTunes ID and GNUpod ID are NOT necessarily the same!  So we build a
        # hash of GNUpod => iTunes ids for translating playlists
        $ids{$_->{id}} = ++$num;
        $_->{id} = $num;
        push @newfiles, $_;

        $data{mhit} .= Mac::iPod::GNUpod::iTunesDBwrite::render_mhit($_, $num);
    }
    $length{mhit} = length($data{mhit});

    # Here, after remaking all files, we remake our indexes and playlists
    $self->_remake(\@newfiles, \%ids);

    # Create header for mhits
    $data{mhlt} = Mac::iPod::GNUpod::iTunesDBwrite::mk_mhlt({ songs => $num });
    $length{mhlt} = length($data{mhlt});

    # Create header for the mhlt
    $data{mhsd_1} = Mac::iPod::GNUpod::iTunesDBwrite::mk_mhsd({
        size => $length{mhit} + $length{mhlt},
        type => 1
    });
    $length{mhsd_1} = length($data{mhsd_1});

    # Create the master playlist
    ($data{playlist}, $num) = Mac::iPod::GNUpod::iTunesDBwrite::r_mpl(
        name => $opt{name},
        ids => [ 1 .. $num ],
        type => 1,
        curid => $num
    );

    # Create child playlists
    for my $plname (@{$self->{plorder}}) {
        my %common = ( name => $plname, type => 0, curid => $num );
        if (my $spl = $self->get_spl($plname)) {
            (my $dat, $num) = Mac::iPod::GNUpod::iTunesDBwrite::r_mpl(
                %common,
                splprefs => $spl->{pref},
                spldata => $spl->{data}
            );
            $data{playlist} .= $dat;
        }
        else {
            (my $dat, $num) = Mac::iPod::GNUpod::iTunesDBwrite::r_mpl(
                %common,
                ids => [ $self->render_pl($plname) ]
            );
            $data{playlist} .= $dat;
        }
    }
    $data{playlist} = Mac::iPod::GNUpod::iTunesDBwrite::mk_mhlp({ playlists => scalar @{$self->{plorder}} + 1  }) . $data{playlist};
    $length{playlist} = length($data{playlist});

    # Make pl headers
    $data{mhsd_2} = Mac::iPod::GNUpod::iTunesDBwrite::mk_mhsd({ size => $length{playlist}, type => 2 });
    $length{mhsd_2} = length($data{mhsd_2});

    # Calculate total file length
    my $totlength = 0;
    $totlength += $_ for values %length;

    # Make master header
    $data{mhbd} = Mac::iPod::GNUpod::iTunesDBwrite::mk_mhbd({ size => $totlength });

    # Debug me!
    if ($opt{dump}) {
        use Data::Dumper;
        open DUMP, '>', $opt{dump} or croak "Couldn't open dump file: $!";
        print DUMP Dumper(\%data);
        close DUMP;
    }

    # Write it all
    open IT, '>', $self->{itunes_db} or croak "Couldn't write iTunes DB: $!";
    binmode IT;
    for ('mhbd', 'mhsd_1', 'mhlt', 'mhit', 'mhsd_2', 'playlist') {
        no warnings 'uninitialized'; # In case one of these is empty
        print IT $data{$_};
    }
    close IT;
}

sub _remake {
    my ($self, $newfiles, $ids) = @_;

    # Set new files
    $self->{files} = $newfiles;

    # Update playlists
    for (@{$self->{plorder}}) {
        my $pl = $self->get_pl($_);
        if ($pl) {
            for (@$pl) {
                if ($_ eq int $_) {
                    $_ = $ids->{$_};
                }
            }
        }
    }

    # Update index
    for (values %{$self->{idx}}) { # Fields
        for (values %$_) { # Values
            for (@$_) { # Id numbers
                $_ = $ids->{$_};
            }
        }
    }
}

# Write the GNUpod DB XML File
sub write_gnupod {
    my($self) = @_;
    open(OUT, ">$self->{gnupod_db}") or croak "Could not write $self->{gnupod_db}: $!\n";
    binmode OUT ;

    # In this section all printing goes to OUT
    my $oldfh = select OUT;

    # Values throughout this code are Unicode::String objects, and we want to
    # make sure that these stringify as utf8
    Unicode::String::stringify_as('utf8');

    print "\n";
    print "\n";

    # Write the files section
    print "\t\n";
    for (@{$self->{files}}) {
        next if not $_ or not keys %$_;
        my %filehash = %$_; # Work with a copy, not orig hashref

        # A few keys that don't need to be written to disk
        for my $del ('notorig', 'uniq') {
            delete $filehash{$del};
        }

        print "\t\t", mktag("file", \%filehash), "\n";
    }
    print "\t\n";

    #Print all playlists
    foreach (@{$self->{plorder}}) {
        my $name;
        # Smartplaylists
        if (my $ref = $self->get_spl($_)) {
            print "\t" . mktag("smartplaylist", $ref->{pref}, noend => 1) . "\n";
            for my $item (@{$ref->{data}}) {
                for (keys %$item) {
                    next if not keys %{$item->{$_}};
                    print "\t\t", mktag($_, $item->{$_}), "\n";
                }
            }
            print "";
        }

        # Regular playlists
        elsif ($ref = $self->get_pl($_)) {
            print "\t" . mktag("playlist", { name => $_ }, noend => 1) . "\n";
            for (@$ref) {
                print "\t\t";
                if ($_ eq int $_) {
                    print mktag("add", { id => $_ });
                }
                elsif ($_->{exact}) {
                    my %write = %$_;
                    delete $write{exact};
                    print mktag("add", \%write);
                }
                elsif ($_->{nocase}) {
                    my %write =  %$_;
                    delete $write{nocase};
                    print mktag("iregex", \%write);
                }
                else {
                    print mktag("regex", $_);
                }
                print "\n";
            }
            print "\t\n";
        }

        # Bad playlist entry--can't happen
        else {
            warnings::warnif("Unknown playlist $name");
            next;
        }

    }
    print "\n";
    close OUT ;

    # Restore original value of filehandle and stringify
    select $oldfh;
}

# Restore an iPod w/ corrupted dbs
sub restore {
    my ($self, %opts) = @_;
    if (not defined $self->{mnt}) {
        croak "Can't restore iPod without mountpoint set";
    }

    local $self->{move_files} = 0;
    local $self->{allow_dup} = 1;
    local $self->{restore} = 1;
    $self->_clear;
    $self->add_song(glob(File::Spec->catpath($self->{mnt}, "iPod_Control", "Music", "*", "*")));
}

# Add a song to the ipod
sub add_song {
    my ($self, @songs) = @_;
    my @newids;

    foreach my $song (@songs) {
        my $filename;
        if (ref($song) eq 'HASH') {
            $filename = $song->{filename};
        }
        else {
            $filename = $song;
        }
        if (not defined $filename) {
            warnings::warnif "Undefined filename";
            next;
        }

        # Get the magic hashref
        my $fh = Mac::iPod::GNUpod::Utils::wtf_is($filename);
        if (not $fh) {
            warnings::warnif "$@, skipping '$song'";
            next;
        }

        # Update hashref w/ user-supplied info (if needed)
        if (ref($song) eq 'HASH') {
            $fh->{$_} = $song->{$_} for (keys %$song);
        }

        # Get the path, etc.
        ($fh->{path}, my $target) = $self->_getpath($filename);

        # Check for duplicates
        unless ($self->allow_dup) {
            if (my $dup = $self->_chkdup($fh)) {
                warnings::warnif "'$song' is a duplicate of song $dup, skipping";
                next;
            }
        }

        # Copy the file
        if (defined $self->{mnt} and $self->move_files) {
            File::Copy::copy($filename, $target) or do {
                warnings::warnif "Couldn't copy $song to $target: $!, skipping";
                next;
            }
        }

        # Add this to our list of files
        push @newids, $self->_newfile($fh);
    }

    return @newids if wantarray;
    return $newids[0];
}

# Remove a song from the ipod
sub rm_song {
    my ($self, @songs) = @_;
    my $rmcount = 0;

    foreach my $id (@songs) {
        if (not exists $self->{files}->[$id]) {
            warnings::warnif "No song with id $id";
            next;
        }

        if (defined $self->{mnt} and $self->move_files) {
            my $path = $self->_realpath($self->{files}->[$id]->{path});
            unless (unlink $path) {
                warnings::warnif "Remove failed for song $id ($path): $!";
                next;
            }
        }


        my $gone = delete $self->{files}->[$id];
        $rmcount++;

        # Get rid of index entries, dupdb
        no warnings 'uninitialized';
        delete $self->{dupdb}->{"$gone->{bitrate}/$gone->{time}/$gone->{filesize}"};
        for (keys %{$self->{idx}}) {
            my @list;
            if (exists $self->{idx}{$_}{$gone->{$_}}) {
                @list = @{$self->{idx}{$_}{$gone->{$_}}};
                for (my $i = 0; $i < @list; $i++) {
                    if ($list[$i] eq $id) {
                        splice @list, $i, 1;
                    }
                }
            }
            if (@list) {
                $self->{idx}{$_}{$gone->{$_}} = \@list;
            }
            else {
                delete $self->{idx}{$_}{$gone->{$_}};
            }
        }
    }

    return $rmcount;
}

# Get a song by id
sub get_song {
    my ($self, @ids) = @_;
    # Must make new hash to prevent tampering w/ internals
    my @rv;
    for (@ids) {
        my $song = $self->{files}[$_];
        if (ref $song eq 'HASH') {
            my %song = %$song;
            push @rv, \%song;
        }
        else {
            push @rv, undef;
        }
    }
    if (wantarray) {
        return @rv;
    }
    else {
        return $rv[0];
    }
}

# Get possible duplicates of a song by ID
sub get_dup {
    my $self = shift;
    my $fh = Mac::iPod::GNUpod::Utils::wtf_is(shift);
    return $self->_chkdup($fh);
}

sub _chkdup {
    my ($self, $fh) = @_;
    no warnings 'uninitialized';
    return $self->{dupdb}->{"$fh->{bitrate}/$fh->{time}/$fh->{filesize}"};
}

# Get the real path to a song by id
sub get_path {
    my ($self, @ids) = @_;
    return unless defined $self->{mnt};
    return map { $self->_realpath($self->{files}->[$_]->{path}) } @ids if wantarray;
    return $self->_realpath($self->{files}->[$ids[0]]->{path});
}

# Get all songs
sub all_songs {
    my $self = shift;
    return grep { defined $self->{files}->[$_] } 1 .. $#{$self->{files}};
}

# Add a pl to the ipod
sub add_pl {
    my ($self, $name, @songs) = @_;
    $name = Mac::iPod::GNUpod::Utils::getutf8($name);
    warnings::warnif $@ if not defined $name;

    # Sets $self->{cur_pl}
    $self->_addpl($name);

    $self->_addtopl($self->{cur_pl}, $_) for (@songs);

    # Prevent others from accidentally writing to this pl
    $self->{cur_pl} = undef;

    return 1;
}

# Get a pl by name
sub get_pl {
    my ($self, @names) = @_;
    my @rv;
    for (@names) {
        if (exists $self->{pl_idx}->{$_}) {
            push @rv, $self->{pl_idx}->{$_};
        }
        else {
            push @rv, undef;
        }
    }
    return @rv if wantarray;
    return $rv[0];
}

# Get all playlists
sub all_pls {
    my $self = shift;
    return grep { defined $_ } @{$self->{plorder}};
}

# Remove a pl by name
sub rm_pl {
    my ($self, @names) = @_;
    my $count;
    for (@names) {
        if (delete $self->{pl_idx}->{$_}) {
            $count++;
            for my $i (0 .. $#{$self->{plorder}}) {
                no warnings 'uninitialized';
                if ($self->{plorder}->[$i] eq $_) {
                    splice(@{$self->{plorder}}, $i, 1);
                }
            }
        }
    }
    return $count;
}

# Get an spl by name
sub get_spl {
    my ($self, @names) = @_;
    return @{$self->{spl_idx}}{@names} if wantarray;
    return $self->{spl_idx}->{$names[0]};
}

# Get a list of ids by search terms
sub search {
    my ($self, %terms) = @_;

    # Pick opts out from terms
    my %opts;
    for ('nocase', 'nometachar', 'exact') {
        $opts{$_} = delete $terms{$_};
    }

    # Main searches
    my %count;
    my $term = 0;
    while (my ($key, $val) = each %terms) {
        for my $idxval (keys %{$self->{idx}->{$key}}) {
            if (matches($idxval, $val, %opts)) {
                $count{$_}++ for @{$self->{idx}->{$key}->{$idxval}};
            }
        }
        $term++;
    }

    # Get the list of everyone that matched
    # Sort by Artist > Album > Cdnum > Songnum > Title
    return
        sort {
            $self->{files}->[$a]->{uniq} cmp $self->{files}->[$b]->{uniq}
        } grep {
            $count{$_} == $term
        } keys %count;
}

# Clear the ipod db
sub _clear {
    my $self = shift;
    $self->{files} = [];
    $self->{idx} = {};
    $self->{plorder} = [];
    $self->{pl_idx} = {};
    $self->{spl_idx} = {};
}

# Add a new file to db, create indices
sub _newfile {
    my ($self, $file) = @_;

    # Find the first open index slot
    my $idx = 1;
    $idx++ while defined $self->{files}->[$idx];
    $file->{id} = $idx;

    $self->_addfile($file);
}

# Add info from a file in the db
sub _addfile {
    my ($self, $file) = @_;
    no warnings 'uninitialized';

    # Check for bad path
    {
        # Get the real path
        my $rpath;
        if ($self->{mnt} && $self->move_files) {
            $rpath = $self->_realpath($file->{path});

        }
        last if not $rpath;

        my $errst;
        if (not -e $rpath) {
            $errst = "File does not exist ($rpath)";
        }
        if (-d $rpath) {
            $errst = "Path is a directory ($rpath)";
        }
        if ($errst) {
            warnings::warnif $errst;
            return;
        }

    }


    # Check for bad ids
    {
        my $badid;
        my $errstr;
        if ($file->{id} < 1) {
            $file->{id} = 'MISSING' if not exists $file->{id};
            warnings::warnif "Bad id ($file->{id}) for file";
            $badid = 1;
        }
        elsif (defined $self->{files}->[$file->{id}]) {
            warnings::warnif "Duplicate song id ($file->{id})";
            $badid = 1;
        }

        if ($badid) {
            # Attempt to rescue w/ newfile (which re-assigns id)
            if (my $r = $self->_newfile($file)) {
                warnings::warnif " ...fixed";
                # Note that this song does not have its original id
                $self->{files}->[$r]->{notorig} = 1;
                return $r;
            }
            # Getting here is bad failure
            return;
        }
    }

    # Make duplicate index
    $self->{dupdb}->{"$file->{bitrate}/$file->{time}/$file->{filesize}"} = $file->{id};

    # Add a uniq for sorting
    $file->{uniq} = sprintf "%s|%s|%02d|%02d|%s|%s",
        $file->{artist}, $file->{album}, $file->{cdnum}, $file->{songnum}, $file->{title}, $file->{path};

    # Make indexes, convert to utf8
    for (keys %$file) {
        # Don't index the id or uniq (redundant!)
        next if $_ eq 'id' or $_ eq 'uniq';
        push @{$self->{idx}->{$_}->{$file->{$_}}}, $file->{id};
        $file->{$_} = Mac::iPod::GNUpod::Utils::getutf8($file->{$_});
        warnings::warnif $@ if not defined $file->{$_};
    }

    # Add to file index
    $self->{files}->[$file->{id}] = $file;

    return $file->{id};
}

# Add a playlist
sub _addpl {
    my($self, $name, $opt) = @_;

    if($self->get_pl($name)) {
        warnings::warnif "Playlist '$name' is a duplicate, not adding it";
        return;
    }
    $self->{cur_pl} = $self->{pl_idx}->{$name} = [];
    push(@{$self->{plorder}}, $name);
}

# Add a smart playlist
sub _addspl {
    my($self, $name, $opt) = @_;


    if($self->get_spl($name)) {
        warnings::warnif "Playlist '$name' is a duplicate, not adding it";
        return;
    }
    $self->{spl_idx}->{$name}->{pref} = $opt;
    $self->{cur_pl} = $self->{spl_idx}->{$name}->{data} = [];
    push(@{$self->{plorder}}, $name);
}

# Add a file to a playlist
sub _addtopl {
    my ($self, $pl, $href) = @_;

    # ids added from add_pl
    if (ref $href ne 'HASH') {
        push @$pl, $href;
    }
    #  tags from db
    elsif (exists $href->{add}) {
        if (exists $href->{add}->{id}) {
            push @$pl, $href->{add}->{id};
        }
        else {
            push @$pl, { %{$href->{add}}, exact => 1 };
        }
    }
    #  tags from db
    elsif (exists $href->{regex}) {
        push @$pl, $href->{regex};
    }
    #  tags from db
    elsif (exists $href->{iregex}) {
        push @$pl, { %{$href->{iregex}}, nocase => 1 };
    }
    # Hash references from add_pl
    else {
        push @$pl, $href;
    }
}

# create a spl
sub _render_spl {
    my($self, $name, $pref, $data, $mr, $content) = @_;
    my $of = {};
    $of->{liveupdate} = $pref->{live};
    $of->{moselected} = $pref->{mos};
    $of->{matchany}   = $mr;
    $of->{limitsort} = $pref->{isort};
    $of->{limitval}  = $pref->{value};
    $of->{limititem} = $pref->{iitem};
    $of->{checkrule} = $pref->{checkrule};

    #create this playlist
    $self->_addspl($name, $of);
}

# Create a filled-out pl (replacing 'add' and 'regex' entries w/ ids)
sub render_pl {
    my ($self, $name) = @_;
    my @list;

    for my $item (@{$self->{pl_idx}->{$name}}) {
        # Exact id numbers
        if (int $item eq $item) {
            push @list, $item;
        }
        else {
            push @list, $self->search(%$item);
        }
    }
    return @list;
}

#Get all playlists
sub _getpl_names {
    my $self = shift;
    return @{$self->{plorder}};
}

# Call events (event handler for XML::Parser)
sub _eventer {
    my $self = shift;
    my($href, $el, %it) = @_;
    no warnings 'uninitialized';

    return undef unless $href->{Context}[0] eq "gnuPod";

    # Warnings for elements that should have attributes
    if ( (     $href->{Context}[1] eq 'files'
            || $href->{Context}[1] eq 'playlist'
            || $href->{Context}[1] eq 'smartplaylist')
            && not keys %it) {
        warnings::warnif "No attributes found for <$el /> tag";
        return;
    }

    # Convert all to utf8
    for (keys %it) {
        $it{$_} = Unicode::String::utf8($it{$_})->utf8;
    }

    #  tags
    if($href->{Context}[1] eq "files") {
        if ($el eq 'file') {
            $self->_addfile(\%it);
        }
        else {
            warnings::warnif "Found improper <$el> tag inside  tag";
        }
    }

    #  tags
    elsif($href->{Context}[1] eq "" && $el eq "playlist") {
        $it{name} = "NONAME" unless $it{name};
        $self->_addpl($it{name});
    }

    #  tags inside playlist
    elsif($href->{Context}[1] eq "playlist") {
        $self->_addtopl($self->{cur_pl}, { $el => \%it });
    }

    #  tags
    elsif($href->{Context}[1] eq "" && $el eq "smartplaylist") {
        $it{name} = "NONAME" unless $it{name};
        $self->_addspl($it{name}, \%it);
    }

    #  tags inside smartplaylist
    elsif($href->{Context}[1] eq "smartplaylist") {
        if (not keys %it) {
            warnings::warnif "No attributes found for <$el /> tag";
            return;
        }
        $self->_addtopl($self->{cur_pl}, { $el => \%it });
    }
}

# Get an iPod-safe path for filename
sub _getpath {
    my($self, $filename) = @_;
    my $path;

    if (not $self->move_files) { #Don't create a new filename..
        $path = $filename;
    }

    else { #Default action.. new filename to create
        my $name = (File::Spec->splitpath($filename))[2];
        $name =~ tr/a-zA-Z0-9\./_/c;
        #Search a place for the MP3 file
        for(my $i = 0;; $i++) {
            my $dir = sprintf("f%02d", int(rand(20)));
            my $fname = sprintf("%d_$name", $i);
            $path = File::Spec->catfile($self->{mnt}, "iPod_Control", "Music", $dir, $fname);
            last unless -e $path;
        }
    }

    # Now break the $ipath into pieces and remake it Mac style Make a path
    # Get the ipod-relative path
    my $relpath = File::Spec->abs2rel($path, $self->{mnt});
    my @pieces = File::Spec->splitpath($relpath);
    my @dirs = File::Spec->splitdir($pieces[1]);
    my $ipath = File::Spec::Mac->catfile(@dirs, $pieces[2]);

    return ($ipath, $path);
}

# Convert an ipod path to Unix
sub _realpath {
    my ($self, $ipath) = @_;
    no warnings 'uninitialized';
    my @list = split /:/, $ipath;
    return File::Spec->catfile($self->{mnt}, @list);
}

1;

__END__