#! /usr/bin/env perl

# $Id$
# $URL$

=head1 NAME

B<fa-flacd> - archive CDs to single FLAC files

=head1 SYNOPSIS

B<fa-flacd> [B<-j> I<jobs>] [B<-v>]

=cut

use strict;
use warnings;

use File::Basename;
use Getopt::Long qw(:config gnu_getopt no_ignore_case);
use POSIX ':sys_wait_h';
use Pod::Usage;

my $verbose;
my @jobs;
my @finished;

sub verbose {
    $verbose and print(STDERR $_) for @_;
}

# Return the ARTIST, ALBUM, and DATE followed by a list of all the
# lines in the file FN.
sub get_tags {
    my $fn = shift;
    my $tag;
    my $value;
    my $artist;
    my $album;
    my @tags;

    verbose("Opening tags file $fn\n");
    open(TAGS, $fn) or die("open($fn): $!");
    while (<TAGS>) {
        chomp;
        push(@tags, $_);

        ($tag, $value) = split(/=/, $_, 2);

        if (/^ARTIST=/) {
            $artist = $value;
            verbose("ARTIST $artist from $fn\n");
        } elsif (/^ALBUM=/) {
            $album = $value;
            verbose("ALBUM $album from $fn\n");
        }
    }
    close(TAGS) or die("close($fn): $!");

    return ($artist, $album, @tags);
}

# Process the fa-rip output in the directory DIR.
sub flac {
    my $dir = shift;
    my $artist;
    my $album;
    my @tags;
    my $outfile;
    my $status;

    verbose("Renaming $dir/tags\n");
    rename("$dir/tags", "$dir/using-tags")
      or die("rename($dir/tags, $dir/using-tags): $!");

    ($artist, $album, @tags) = get_tags("$dir/using-tags");

    verbose("mkdir($artist)\n");
    -d $artist or mkdir($artist) or die("mkdir($artist): $!");

    verbose("chdir($dir)\n");
    chdir($dir) or die("chdir($dir): $!");

    $outfile = "$album";
    $outfile =~ s/\//_/g;

    verbose("Running flac\n");
    $status = system('flac', '-o', "../$artist/$outfile.flac-tmp",
                     '--delete-input-file', '-V', '--cuesheet',
                     'cue', '--no-padding', '--best',
                     map({ ('-T', $_) } @tags),
                     'wav');
    if (WIFEXITED($status)) {
        if (($status = WEXITSTATUS($status)) != 0) {
            die("flac exited with status $status");
        }
    } elsif (WIFSIGNALED($status)) {
        die("flac killed with signal ", WTERMSIG($status));
    } elsif (WIFSTOPPED($status)) {
        die("flac stopped with signal ", WSTOPSIG($status));
    } else {
        die("Major horkage on system(flac): \$? = $? \$! = $!");
    }

    verbose("Cleaning up $dir\n");
    unlink('using-tags') or die("unlink(using-tags): $!");
    unlink('cue') or die("unlink(cue): $!");
    rename('log', "../$artist/$outfile.log")
      or die("rename(log, ../$artist/$outfile.log): $!");
    chdir('..') or die("chdir(..): $!");

    rename("$artist/$outfile.flac-tmp", "$artist/$outfile.flac")
      or die("rename($artist/$outfile.flac-tmp, $artist/$outfile.flac): $!");

    if (-x "$dir/post-processor") {
        verbose("Running './$dir/post-processor $artist/$outfile.flac'\n");
        system("./$dir/post-processor", "$artist/$outfile.flac");
        unlink("$dir/post-processor") or die("unlink($dir/post-processor): $!");
    }

    rmdir($dir) or die("rmdir($dir): $!");

    return 0;
}

sub reaper {
    my $pid;

    while (($pid = waitpid(-1, WNOHANG)) > 0) {
        push(@finished, [$pid, $?]);
    }

    $SIG{CHLD} = \&reaper;
}

sub newjob {
    my $dir = shift;
    my $pid;

    $pid = fork();
    if (not defined($pid)) {
        die("fork: $!");
    } elsif ($pid == 0) {
        $SIG{CHLD} = 'IGNORE';
        open(STDERR, ">$dir/log") or die("open(STDERR, >$dir/log): $!");
        exit(flac($dir));
    }

    verbose("new job $pid for $dir\n");
    return $pid;
}

sub deljob {
    my $i = shift;
    my $j;
    my $pid;
    my $status;

    $pid = $finished[$i][0];
    $status = $finished[$i][1];

    verbose("$pid finished (");
    if (WIFEXITED($status)) {
        verbose('exited with status ', WEXITSTATUS($status));
    } elsif (WIFSIGNALED($status)) {
        verbose('killed with signal ', WTERMSIG($status));
    } elsif (WIFSTOPPED($status)) {
        verbose('stopped with signal ', WSTOPSIG($status));
    }
    verbose(")\n");

    for ($j = 0; $j <= $#jobs; $j++) {
        $pid == $jobs[$j] and splice(@jobs, $j, 1) and last;
    }

    splice(@finished, $i, 1);
}

sub flacloop {
    my $MAXJOBS = shift;
    my $i;
    my $j;


    $SIG{CHLD} = \&reaper;
    while (1) {
        if (scalar(@jobs) <= $MAXJOBS) {
            foreach $i (glob('*/tags')) {
                push(@jobs, newjob(dirname($i))) <= $MAXJOBS or last;
            }
        }

        for ($i = 0; $i <= $#finished; $i++) {
            deljob($i);
        }

        verbose(scalar(@jobs), " jobs\n");
        sleep(5);
    }
}

MAIN: {
    my $jobs;
    my $help;

    $jobs = 4;
    GetOptions(
               'jobs|j=i' => \$jobs,
               'verbose|v' => \$verbose,
               'help|h|?' => \$help,
              ) or pod2usage();
    $help and pod2usage(-exitstatus=>0, -verbose=>1);

    flacloop($jobs);
}


__END__

=head1 DESCRIPTION

B<fa-flacd> and B<fa-rip> together comprise B<flac-archive>, a system
for archiving audio CDs to single FLAC files.  B<fa-flacd> is the guts
of the system.  It runs in the directory where the audio archives are
stored, scanning for new ripped CDs to encode and rename; it never
exits.  B<fa-rip> generates the inputs for B<fa-flacd>: the ripped WAV
file, Vorbis tags, and a cuesheet.

Both programs expect to be run from the same directory.  They use that
directory to manage directories named by artist.  Intermediate files
are written to temporary directories here.  B<fa-flacd> processes the
temporary directories into per-album files in the artist directories.

Every 5 seconds, B<fa-flacd> scans its current directory for
directories with a file called "tags" and creates a processing job for
each one.  The number of jobs B<fa-flacd> attempts to run is
controlled by the B<-j> option and defaults to 4.  B<fa-flacd> will
print diagnostic output when the B<-v> option is given.

A processing job first renames the directory's "tags" file to
"using-tags" so that B<ra-flacd> will not try to start another job for
this directory.  This file is left as is when an error is encountered,
so a new job will not be started until the user corrects the error
condition and renames "using-tags" back to "tags".  Next, it encodes
the "wav" file to a FLAC file, using the "cue" file for the cuesheet
and "using-tags" for Vorbis tags.  Any diagnostic output is saved in
the "log" file.  Finally, B<fa-flacd> moves the "cue" and "log" files
to the artist directory (named by album) and removes the temporary
directory.

If the temporary directory contains an executable file named
"post-processor", B<fa-flacd> executes that file with the relative
path to the output FLAC file as an argument.  The output files are in
their final location when "post-processor" starts.  Possible uses are
running B<flac2mp3>, moving the output files to a different location,
removing the lock file, or adding to a database.  The standard input,
output, and error streams are inherited from B<fa-flacd>, so they may
be connected to anything from a tty to /dev/null.  This means that you
may want to redirect these streams, if you want to save them or do any
logging.

=head1 OPTIONS

=over 4

=item B<-j> [B<--jobs>] I<jobs>

Run up to I<jobs> jobs instead of the default 4.

=item B<-v> [B<--verbose>]

Print diagnostic information.

=back

=head1 AUTHORS

Written by Eric Gillespie <epg@pretzelnet.org>.

flac-archive is free software; you may redistribute it and/or modify
it under the same terms as Perl itself.

=cut

# Local variables:
# cperl-indent-level: 4
# perl-indent-level: 4
# indent-tabs-mode: nil
# End:

# vi: set tabstop=4 expandtab: