renamed after almost 20 years: psycmp3 turns to psycamp

1 files changed, 1258 insertions, 0 deletions

diff --git a/bin/psycamp b/bin/psycamp
new file mode 100755
index 0000000..0972f70
--- /dev/null
+++ b/bin/psycamp
@@ -0,0 +1,1258 @@
+#!/usr/bin/perl -I/usr/depot/lib/perl5
+use Term::ANSIColor qw( :constants );
+#
+# been around as 'psycmp3' for almost twenty years, but since 2017 it
+# can also play other formats.. so i shalt rename it to 'psycamp'
+#
+sub head { return <<X; }
+=============================================================================
+PSYC media console 3.2                  by the symbolic lynX\@psycamp.pages.de
+-----------------------------------------------------------------------------
+X
+# command line front-end to audio engines with PSYC remote control
+#
+# this media player is over a decade old, but it still is my tool of
+# choice. i gave it functions i didn't find in any other.. like,
+# how useful is a media player if you can't easily reorganize or at
+# least delete files you don't want to consume ever again?
+#
+# uses 'mplayer' - the most popular media player on linux with the
+# worst scripting API ever seen in a lifetime. it is documented
+# in mplayer's source distribution in DOC/tech/slave.txt.
+#
+# can alternatively be configured back to use the 'rxaudio' server
+# engine from http://www.mpeg.org/xaudio/ which has a lot more
+# reasonable API, but it only plays mp3 - the copy that I have 
+# been using since 1997 or so has a sha256sum of
+# ddb096ad42d9b6b543db8a3a6d9b4a9d52943e75e96697dbbadbc779140c498e.
+# although the general public never saw any source codes to it, it is
+# viable to assume that it didn't ship any backdoors. grab a copy from 
+# http://mp3.pages.de/files/rxaudio
+#
+# furthermore psycamp requires the Net/PSYC.pm module since it uses its 
+# event multiplexing abilities, not just to receive PSYC messages, but
+# also to handle stdin and engine input in parallel.
+#
+# you can use the 'psyccmd' script to remote control this script, which 
+# therefore can act as a music jukebox or media player daemon. also,
+# psycamp can obviously generate 'playing now' notifications.
+
+# since perl has no native preprocessor, this code is
+# managed by the 'jaggler' preprocessor.
+#
+# list of available jaggler flags:
+#  'T' := "time" - activates output of access and modification time
+#  'O' := "org" - enable shift-key functions to reorganize collection
+#  'X' := "rxaudio" - use the old mp3 engine instead of mplayer
+#
+# psycamp in 'distribution' default mode
+#       jaggler -x -c# -j% psycamp
+# psycamp supporting 'T' and 'O' extras:
+#       jaggler -x -c# -j% -DOT psycamp
+
+# things still in "makenoise":  cdrom-file-caching, des-decoding,
+#                               marks, volumes, support for non-mp3s.
+#
+# HINTS & HACKS:
+# in order to play only high quality files from a folder, you can use
+# "lm -Lb 193 >/tmp/playlist-$USER.m3u; psycamp"
+# lm is available from http://perl.pages.de. such functionality could
+# obviously be integrated into here, allowing us also to remove file
+# type guessing - but in exchange we slow down the playlist creation
+# process if every file were thrown at ffmpeg to discover its media
+# properties.
+
+sub help { print BOLD, BLACK, &head, RESET, <<X; }
+
+basics: (q)uit (h)elp
+
+motion: (p)lay (s)top pa(u)se
+      [ j(ump) ] <mm:ss>                jump to an absolute point in the song
+      [ (g)oto ] <pos> [<range>]         can do smart guessing of range value
+ (for example you can simply type '0' thru '9' to jump to a point in the song)
+
+files:  (o)pen <file>                          immediately load this new song
+        <file>              a filename by itself will first fade current song
+        (l)ist [<dir>]                                       simply calls 'ls'
+        (n)ext                                        next file from playlist
+        '?'                      show a list of the next 9 songs in the queue
+        (w)rite or (e)dit playlist
+        e(x)it                                  exit without updating playlist
+
+volume: (v)olume [0..100]                           default is maximum volume
+        (f)ade [<volume> [<psecs>]]          psecs: time between volume steps
+        (r)ise [<volume> [<psecs>]]                    (example: fade 33 0.1)
+
+extra commands for scripting:
+        sleep <time>    wait for <time> before executing next command
+
+type (H)elp for organizing commands
+=============================================================================
+X
+# FIXME: volume commands
+
+# when organizing mode has been activated in psycamp, you can reorganize
+# your media files as follows:
+sub help2 { print BOLD, BLACK, &head, RESET, <<X; }
+
+whenever media is in a directory like INCOMING, NEW or TODO - it can be
+moved into a different subdirectory on the same hierarchy level by using
+the following uppercase commands:
+
+        J = send to DEEJAY folder
+        U = send to USE
+        K = send to KEEP
+        X = send to EXPORT
+        S = send to SECONDARY
+        R = send to REPERTOIRE
+
+if you prefer to execute the command *after* having finished playing it,
+you can schedule the move for later by doubling the command letter. so
+you type 'KK' if you want to keep the file after having listened to it.
+the commands for deleting items are similar:
+
+        D = delete the file now
+        DD = delete the file after having played it
+        T = delete the file and mark as trash
+        TT = mark as trash and delete later
+
+type (h)elp for regular commands
+=============================================================================
+X
+
+# default PSYC address for this service, UDP port 1144 on this host.
+# can be overridden with -b
+#
+$UNI = 'psyc://127.0.0.1:1144d/';
+#
+# be mindful that if you use outgoing -M the receiving side can send
+# remote control commands back to you, even if you bind localhost here.
+# you may like to have such chat-based remote control, or you may not..
+
+# volume values, since volume doesn't seem to be linear as it should
+# at least not my soundcard, check for yourself..
+#
+@VV = ( 0,2,5,8,11,14,17,20,24,28,33,38,43,49,56,64,72,81,90,100 );
+
+# when running rxaudio, psycamp can only handle .mp3 and .sdj
+#   "part" and "dl" are the temporary filenames of some download tools
+$FILETYPES =
+#%      "(mp3|sdj|part|dl)";                                         #? X
+        "(mp\\d|sdj|part|dl|flac|wav|aif|aiff|ogg|m4a|aac|opus|au)"; #? !X
+# "(sea|mod|gz|lha|Z|lzh|zip|s3m)"; # |med|mmd0)";
+# should also be able to handle .pls
+#
+# would prefer not to enumerate media formats understood by mplayer,
+# but it is tricky to sort out non-media files when recursively
+# spidering input directories.
+
+# starting pcm volume. system volume is kept at maximum anyway.
+#%$VOL = 0;     #? X
+$VOL = 100;     #? !X
+
+# allow 'D' key to delete the file currently being listened to (!!)
+# ignored if -DO was not provided in jaggler
+$ALLOW_DELETE_KEY = 1;
+
+# string contained in path for files that are deleted in -d mode
+$VOLATILE = 'VOLATILE';
+
+# string contained in path for files that are kept even when in -D mode
+$KEEP = 'LOCAL';
+
+# debugging (inline macro, if undefined all debugging code is removed)
+#       1: examine progress
+#       2: debug file recursion
+#       4: debug randomizer
+#       8: show playlist order
+#       16: debug PSYC transactions
+#       32: weird things that shouldn't happen
+#       64: show server pid
+#       128: show songs of same size when using -s S
+#       256: show all output from media engine
+#       512: watch only engine parse
+#       1024: watch timer events (timeout simulation)
+#       2048: show engine debug messages
+sub DEBUG () { 32 + 128 }
+
+# also activate PSYC debugging
+#Net::PSYC::setDEBUG(3);
+
+# used by randomize algorithm - how much of the path is compared?
+# would be smart to choose this value dynamically..
+sub PATHMATCH () { 12 }
+
+# file to put media information into about files that got trashed
+sub HATEINDEX () { "$ENV{HOME}/.media/TRASH-$ENV{HOST}.ix" }
+
+$tmpdir='/temp';
+$tmpdir='/tmp' unless -d $tmpdir and -w _;
+$tmpdir='.' unless -d $tmpdir and -w _;
+# $tmplock="$tmpdir/.psycamp-copylock";
+$playlist="$tmpdir/playlist-$ENV{USER}.m3u";
+
+        use Getopt::Std;
+        use File::Find ();
+        use FileHandle;
+        use Carp;
+        #use MPEG::MP3Info;     # no longer necessary
+        use Date::Format qw( time2str );    ## T
+        use IPC::Open3 qw( open3 );
+        use Net::PSYC qw( :event );
+
+        *name   = *File::Find::name;    # ugly style works
+        $scan = 0;
+
+MAIN: {
+        if ($#ARGV >= 0) {
+                getopt('bMns');
+        }
+        $nick = $opt_n
+             || $ENV{'PSYCNICK'}
+             || $ENV{'NICK'}    # this one should work with any chat system
+             || $ENV{'IRCNICK'}
+             || $ENV{'USER'}
+             || $ENV{'HOST'}
+             || 'unixer';
+
+        print "Using playlist: $playlist\n" if $opt_v;
+        if ($opt_h) {
+                print BOLD, BLACK, &head, YELLOW, <<X, BOLD, BLUE, &sorthelp, RESET;
+
+usage: $0 [<flags>] [-b <uniform>] [-s <mode>] [-M <UNI>] [<files|dirs>]
+
+        [-b]ind PSYC uniform and accept commands from both PSYC and stdin
+        [-M] sends currently playing title to a monitoring entity via PSYC
+        [-n]ickname to use for monitoring, otherwise '$nick' will be used
+        [-s] provides for several sort options, see below
+flags:
+        [-H] shows an explanation what this tool is good for, try it!
+        [-r]andomize using a smart shuffle algorithm, much better than "-s r"
+        [-m]ono output
+        [-v]erbose: shows some output from rxaudio
+        [-q]uiet: shows close to no output
+        [-c]alculate cumulative duration of selections
+        [-L]oad the tracks in the playlist only if they really exist
+        [-x] will terminate perl and exec xaudio, use only when short on memory
+        [-I]nitialize rxaudio anew for each song, special hack
+        [-d]elete files after playing if the path contains the word '$VOLATILE'.
+        [-D]elete files after playing unless the path contains the word '$KEEP'.
+        [-S]kip files if the path contains the word '$KEEP', dont play them.
+
+    without arguments psycamp resumes from last run´s playlist.
+X
+#       [-l]ist filenames, sizes and bitrates (for archive documentation)
+#         ... broken and prolly useless
+                exit;
+        }
+        # initialize randomizer
+#       my $a = time() ^ $$; $a = reverse $a; srand($a);
+        # no longer necessary with newer perls,
+        # even the following is optional:
+        srand;
+
+ #{ X
+#%      print <<X unless $has_rxaudio = &which('rxaudio');
+#%cannot find rxaudio. cannot play any mp3s without
+#%rxaudio from http://www.mpeg.org/xaudio/
+#%or, just for friends, from http://mp3.pages.de/files/ (old linux binary)
+#%of course you are welcome to update psycamp to work with xmms or mplayer or..
+#%
+#%X
+#%      # aoss: Wrapper to facilitate use of the ALSA OSS compatibility library.
+#%      # in case you do not have it in form of kernel modules (snd-pcm-oss etc)
+#%      # padsp: Wrapper to do the same with pulseaudio.
+#%      $wrapper = &which('aoss') || &which('padsp') || "";
+#%      print "Using wrapper: $wrapper\n" if $opt_v;
+ #: X
+        print <<X unless $has_mplayer = &which('mplayer');
+cannot find mplayer. cannot play media without it.
+
+X
+ #} X
+        if ($opt_H ||
+#%          !$has_rxaudio       #? X
+            !$has_mplayer       #? !X
+        ) {
+                print BOLD, BLACK, &head, RESET, <<X;
+
+This media player brings you a threefold functionality which you may combine
+at will:
+
+1. a command line media player which gives you possibilities to navigate
+   media and similar functions by entering commands on the keyboard, so you
+   don't need a GUI to achieve the same effects.
+
+2. the player can be remote controlled with UDP messages according to the
+   PSYC protocol for synchronous conferencing - an upcoming chat protocol
+   which can be used for all sorts of messaging, so it's fine for this
+   purpose too. This enables you to implement CGI-based remote controls
+   or suchlike. the _request_execute method family is understood via PSYC.
+   unless you specify the -b option, $UNI will be used
+   as PSYC address for reception of commands. currently no authentication
+   is requested, so it is generally good to bind to localhost. a message
+   can contain several lines of instructions. no further input will be
+   accepted while processing these instructions.
+
+3. this player is scriptable by "scripting deejay" files (extension .sdj),
+   they allow you to automate operations on media files, even simulate
+   simple remixes without actually modifying the source material.
+
+see '$0 -h' for usage instructions
+X
+                exit;
+        }
+        &enqueue(@ARGV);
+        if ($NS) {              # global var for number of enqueued songs
+            do {
+                @order = $opt_r ? &randomize : &sortsongs($opt_s);
+                print STDERR "\r[order] ", join(' ', @order), "\n\n" if DEBUG & 8;
+                foreach my $i (@order) {
+                    unless ($i) {
+                        print STDERR " (weird bug encountered)\n" if DEBUG & 32;
+                        undef @order;
+                        next;
+                    }
+                }
+            } until (@order && $order[0]);
+            &save(-1);
+        } elsif (-r $playlist) {
+            &load unless $opt_x;
+            system "$ENV{EDITOR} $playlist;clear" if $opt_e;
+        }
+        #exec "xaudio `cat $playlist`" if $opt_x;
+        exec 'mplayer "`cat $playlist`"' if $opt_x;
+        #exec "mpg123 --remain --aggressive -@ $playlist" if $opt_x;
+
+        print STDERR BOLD, YELLOW, "binding to $opt_b ...\n", RESET if DEBUG & 16 && $opt_b;
+        bind_uniform( $opt_b || $UNI );
+        register_uniform();
+        $rc = sendmsg ($opt_M, '_notice_summary_play_music',
+"[_nick_application]: [_nick] is going to listen to [_amount_tracks] tracks.",
+              { _nick => $nick, _nick_application => 'psycamp',
+                _amount_tracks => $NS } ) if $opt_M;
+        print STDERR BOLD, YELLOW, "sent greeting to $opt_M ...\n", RESET if DEBUG & 16 && $opt_M;
+        add( \*STDIN, 'r', \&stdread );
+        &ginstart;
+
+        # use Cwd; # also used by &save()
+        use Cwd qw(chdir);  # maintains PWD in ENV
+        print STDERR $ENV{PWD} . " = PWD\n" if DEBUG & 1;
+        if ($opt_d) {
+                print STDERR BOLD, RED, ($Volatile = $ENV{PWD}
+                    =~ /\b$VOLATILE\b/oi) ? <<X : <<Y, RESET;
+Warning: ALL files will be deleted after consumption.
+X
+Warning: Files tagged $VOLATILE will be deleted after consumption.
+Y
+        }
+        if ($opt_D) {
+                print STDERR ($Keep = $ENV{PWD} =~ /\b$KEEP\b/oi) ?<<X:<<Y;
+Warning: NO files will be deleted.
+X
+Warning: All files not tagged $KEEP will be deleted after consumption.
+Y
+        }
+        print BOLD, BLACK, &head, <<X, RESET unless $opt_q;
+enter (h) for help
+
+X
+        &gin('channels mono') if $opt_m;
+        $CS = -1;       # global var for current song
+
+        &next(0);
+#       &vol(100);
+        $|=1;
+
+        # Net::PSYC::Event doesn't support idle events yet.. TODO
+        add(3, 'i', \&timeout, 1);
+        # higher frequency necessary to detect timeouts this way..
+        # then again, if it's too high timer is sometimes faster
+        # than rxaudio and produces an erroneous kick..
+        start_loop();
+}
+
+
+### SUBS & SANDWICHES ###
+
+sub timeout {
+    if (!$paused) {
+        # HACK for rxaudio which sometimes gets enchanted
+        #y $trick = rand(2)>1 ? 'pause' : 'seek 1 1';
+        #y $trick = ('pause', 'seek 1 1', 'play')[rand(3)];
+        #y $trick = 'seek 1 1';
+#                   print " (kicking rxaudio with '$trick')\n" if DEBUG & 32;
+#                   &gin( $trick );
+        print RED, "\n\t\t(kick) ", RESET if DEBUG & 32;
+#%      &gin('seek 1 1'); #? X
+        &gin('seek 0 1'); #? !X
+        &gin('pause'); #? !X
+    }
+    return 3;
+}
+
+sub ginread {
+    $_ = <R>;
+    print STDERR BOLD, BLUE, $_, RESET if DEBUG & 256;
+ #{ X
+#%    # example: MSG notify position [offset=20, range=400]
+#%    if ( /^MSG notify position / ) {
+#%      /\boffset=(\d+), range=(\d+)\b/;
+#%      # HACK! HACK!
+#%      # send something that will flush the EOF to us
+#%      print W "get_player_mode\n" if 5+$1 > $2;
+#%    } else
+ #} X
+    {
+        $_ = &ginparse( $_ );
+# ds_fill_buffer: EOF reached (stream: audio)
+# "EOF code: 2" happens when we ask to load a different file
+        if (
+#%          /^MSG notify player state \[EOF\]$/     #? X
+            /^EOF code: 1\b/                        #? !X
+        ) {
+                # &progress('');
+                if ($deleteLater eq $CurrentFile) {
+                    print RED, unlink ($deleteLater) ?
+                            "\r***" : "\r - ", BOLD, GREEN, "[\n", RESET;
+                    $deleteLater = undef;
+                } elsif ($moveLater) {
+                    &moveFile($moveLater);
+                    $moveLater = undef;
+                } elsif ($opt_d && ($Volatile ||
+                    $CurrentFile =~ /\b$VOLATILE\b/oi)) {
+                        print RED, unlink ($CurrentFile) ?
+                            "\r***" : "\r - ", BOLD, GREEN, "[\n", RESET;
+# [could not delete $CurrentFile]
+                } elsif ($opt_D && !$Keep &&
+                    $CurrentFile !~ /\b$KEEP\b/oi) {
+                        print RED, unlink ($CurrentFile) ?
+                            "\r***" : "\r - ", BOLD, GREEN, "[\n", RESET;
+                } else {
+                        my $m = $date[$order[$CS]];
+                        # touch the access time of the file
+#       print "\rto be accessed: ", isotime(time),
+#               "\tto be changed: ", isotime($m), "\n";
+                        utime time, $m, $CurrentFile;
+ #{ T
+#%#     ($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,
+#%#        $atime,$mtime,$ctime,$blksize,$blocks) = lstat($CurrentFile);
+#%#     print "\rset accessed: ", isotime($atime),
+#%#             "\tset changed: ", isotime($mtime), "\n";
+ #} T
+                        print BOLD, GREEN, "\r   [\n", RESET unless $opt_q;
+                }
+                &ginstop if $opt_I;
+                &next(0);
+        }
+    }
+}
+
+sub stdread {
+    $_ = scalar <STDIN>;
+    &parse( $_ );
+}
+
+sub msg {
+    my ($source, $mc, $data, $vars) = @_;
+    return if $mc =~ /_circuit/;
+    unless ($opt_q) {
+            my $tx = psyctext($data, $vars);
+            print BOLD, YELLOW, <<X, RESET;
+
+>> $source ($mc) >>>>>> $tx <<<<<<
+
+X
+    }
+    # disable when using -M... hmm, why?
+    return if $opt_M;
+    &parse($data) if $mc =~
+        /^(_request_execute|_command|_message)/;
+}
+
+ #{ T
+#%sub isotime {
+#%        my $t = shift;
+#%        return time2str('%Y-%m-%d %T', $t);
+#%}
+ #} T
+
+sub open {
+        my $file = shift;
+        return unless $file;
+ #{ T
+#%      my $m = $date[$order[$CS]];
+#%      my $a = $adate[$order[$CS]];
+#%      print "\rlast accessed: ", isotime($a),
+#%              "\tlast changed: ", isotime($m), "\n";
+ #} T
+#       &ginopen if $opt_I;
+        &ginstart if $opt_I;
+        if ($file =~ /\.sdj$/i and -T $file) {
+                # calling a script from a script is like a "skip"..
+                $SCRIPT = $file;
+                print "[executing script $SCRIPT]\n" unless $opt_q;
+                open(F, $file) || die "$file: $!";
+                while(<F>) {
+                        &parse($_);
+                }
+                close F;
+                print "[script terminated]\n" unless $opt_q;
+                undef $SCRIPT;
+                &next(0);               # hmmmm?
+        } elsif (! -r $file) {
+                print RED, "[oh! $file has disappeared]\n", RESET unless $opt_q;
+                &next(0);               # hmmmm?
+        } else {
+                # xaudio does this for us now
+#               if (defined( &get_mp3info )) {
+#                       $mp3 = get_mp3info($file);
+#                       printf "$file length is %02d:%02d\n",
+#                         $mp3->{MM}, $mp3->{SS};
+#               }
+ #{ X
+#%              $TC = '[--:--:--:--]';
+#%              &gin("open $file");
+ #: X
+                $TC = '[--:--:--]';
+                &gin("pause");
+                # will fail when encountering a filename containing
+                # a doublequote. could use urlquote instead.. FIXME
+                &gin("loadfile \"$file\"");
+                # wicked hacks described in api spec
+                &gin("pausing_keep_force pt_step 1");
+                &gin("get_property pause");     # ANS_pause=no
+ #} X
+                $DUR = 0;
+                &sleep(0.3);    # have to wait for file to load?
+                $scan=0, &seek(5) if $scan;
+#               &seek(@_) if @_;
+#               &vol(100);
+        }
+}
+sub next {
+        my $a = shift;
+        &fade(43, $a) if $a and $VOL > 50;
+        my $n = $file[$order[++$CS]]; # || $file[$CS];
+        &exit(0) if !$n or ($n eq '') or !$NS or $CS >= $NS;
+        return &next(0) if $opt_S and $n =~ /\b$KEEP\b/oi;
+        &open( $n );
+ #      if (!$a or $opt_I) {
+ #              print "(not waiting) " if DEBUG & 32;
+#               &sleep(.4);
+ #              &gin('play');
+ #      }
+#%      &gin('play');   #? X
+        if ($opt_M) {
+                undef $!;
+                $rc = sendmsg ($opt_M, '_notice_play_music_title',
+                     "[_nick] is listening to: [_music_title]",
+                         { _nick => $nick, _music_title => $n
+                 } );
+                die "sendmsg $rc: $!" if $!;
+                print STDERR BOLD, YELLOW, "sent to $opt_M!\n", RESET if DEBUG & 16;
+        }
+        &vol($Volume) if $Volume;
+        $paused = 0;
+        # next;
+}
+
+sub parse {
+        $_ = shift;
+        s/^\s+//;
+        chomp;
+        if ($SKIP) {
+                next unless /^:$SKIP/;
+                undef $SKIP;
+                next;
+        }
+        if (/^\?$/) {
+                my $any = 0;
+                print YELLOW, <<X, RESET;
+
+currently playing: $CurrentFile
+X
+                my $max = $NS-$CS > 9 ? $CS+9 : $NS-1;
+                for ($i = $CS+1; $i <= $max; $i++) {
+                        my $f = $file[$order[$i]];
+                        my $s = $size[$order[$i]] || -s $f;
+#                       my $a = $adate[$order[$i]];
+                        $f =~ s/\.\S+$//i;
+                        $f = '..'.substr($f,length($p)-61) if
+                                length($f) > 63;
+                        $any++;
+                        printf "%3d.%8d %s\n", $i, $s, $f;
+                }
+                print $any ? "\n" : "<no more songs in playlist>\n\n";
+                next;
+        }
+        next unless /^\w/;
+        print "> $_\n" if $opt_v and $SCRIPT;
+
+        # techniques to seek in media file
+        /^([\d:']+)$/ and &seek($1), next;
+        /^(\d+)\s+(\d+)$/ and &seek($1,$2), next;
+        /^(g|go|goto|seek)\b\s*(\S*)(.*)$/ and &seek($2,$3), next;
+        /^(j|jump)\b\s*(\S*)$/ and &jump($2), next;
+
+        /^skip\s(\w+)$/ and $SKIP=$1, next;
+        # /^open\s+(\S*)\s*\b(\S*)\s*\b(\S*)\s*$/ and &open($1,$2,$3), next;
+        /^o\s+(.*)\s*$/ and &open($1), next;
+        /^scan\s+(.*)\s*$/ and $scan=1, &open($1), next;
+        /^(n|next)\b\s*(\S*)$/ and &next($2 || .05), next;
+ #{ O
+        if ( $ALLOW_DELETE_KEY ) {
+            if ( /^T(T?)\s*$/ ) {
+                # 'T' deletes song and remembers it in the index of trash music
+  #{ L
+                use MP3::List;          # terrible dependency FIXME!
+                my ($out, $dur) = &MP3::List::format($CurrentFile);
+  #} :
+#%              $out = "$CurrentFile\n";
+  #} L
+                if ($out and open(HATE, ">>", HATEINDEX)) {
+                        print HATE $out;
+                        close HATE;
+                        print RED, ">> $CurrentFile marked as trash\n", RESET;
+                } else {
+                        print RED, "*** Failed to write to ", HATEINDEX, ":\n", RESET, $out;
+                }
+                # dirty way to fall through into one of the following ifs
+                $_ = $1? 'DD': 'D';
+            }
+            if ( /^(_|DD)\s*$/ ) {
+                $deleteLater = $CurrentFile;
+                print BOLD, BLUE, ">> scheduled for removal\n", RESET;
+                next;
+            }
+            if ( /^D\s*$/ ) {
+                my $f = $CurrentFile;
+                &ginclose;
+                print BOLD, RED, ">> deleted: $f\n***", RESET if unlink $f;
+                &ginopen;
+                &next(0);
+                next;
+            }
+        }
+        if ( /^(J|U|K|E|M|X|C|S|R)(\w?)\s*$/ ) {
+                my $r = $2;
+                if ($r and $r ne $1) {
+                        print BOLD, RED, ">> command $1$r not defined\n", RESET;
+                        next;
+                }
+                my $t = $1 eq 'J' ? 'DEEJAY' :
+                        $1 eq 'U' ? 'USE' :
+                        $1 eq 'K' ? 'KEEP' :
+                        $1 eq 'E' ? 'EDITABLE' :
+                        $1 eq 'M' ? 'REMASTER' :
+                        $1 eq 'X' ? 'EXPORT' :
+                        $1 eq 'C' ? 'CRITICIZE' :
+                        $1 eq 'S' ? 'SECONDARY' : 'REPERTOIRE';
+                my $f = $CurrentFile;
+                $f = $ENV{PWD}. '/'. $f unless $f =~ m!^/!;
+                unless ($f =~ s:\b(SHARE|T|COMPLETE|KEEP|EDITABLE|SECONDARY|REPERTOIRE|NEW|SEEK|TODO|USE|DEEJAY|REMASTER|INCOMING)\b:$t:i)
+                {
+                        print BOLD, RED, ">> not applicable for $f\n", RESET;
+                        next;
+                }
+                if ($r) {
+                        $moveLater = $f;
+                        print BOLD, BLUE, ">> scheduled to move to $t\n", RESET;
+                } else {
+                        &moveFile($f);
+                        &next(0);
+                }
+                next;
+        }
+ #} O
+        # NEW: relative volume changes, only with mplayer
+        # FIXME: why does it only work with leading v?
+        /^v\+\s*$/ and &gin('volume 9'), next;  #? !X
+        /^v\-\s*$/ and &gin('volume -9'), next; #? !X
+        /^(v|vol|volume)\b\s*(\d+)$/ and &vol($Volume = $2), next;
+        /^(f|fade)\b\s*(\S*)(.*)$/ and &fade($2,$3), next;
+        /^(r|rise)\b\s*(\S*)(.*)$/ and &rise($2,$3), next;
+        /^sleep\b\s*(\S*)$/ and &sleep($1), next;
+        /^(d|duration)\b\s*(\S*)$/ and &duration($2), next;
+        /^(l|list)\b\s*(\S*)$/ and system("ls $2"), next;
+        /^(h|help)\b/ and &help, next;
+        /^H\b/ and &help2, next;
+        /^(e|edit)\b/ and &edit($CS), next;
+
+        if ( /^\s*(.....+)\s*\b(\S*)\s*\b(\S*)\s*$/ and -r $1 ) {
+                &fade(33, .1) if $VOL > 50;
+                &open($1, $2, $3);
+        #       &sleep(.2);
+        #       &gin('play');
+        #       &vol(100);
+                next;
+
+                # &gin("open $1");
+                # &sleep(.4);
+                # &sleep;
+        }
+#       if ( s/^(\S+\.mp3)\s+(\d+)\b// ) {
+#               &gin("open $1");
+#               &sleep;
+#               &gin("seek $2 1000");
+#               &sleep;
+#               &gin('play');
+#       }
+#       &gin("open $_") if s!\b(\S+\.mp3)\b!!;
+#       if ( s/\b(\d+)\s+(\d+)\b// ) {
+#               &gin("seek $1 $2");
+#       }
+
+        /^(q|quit)\b/ and &save($CS-1), &exit(0);
+        /^(x|exit)\b/ and &exit(0);
+        /^(w|write)\b/ and &save($CS-1), next;
+        # s/^o\b/open/;
+        s/^p\b/play/ and $paused = 0;
+        s/^s\b/stop/ and $paused = 1;
+        s/^u\b/pause/ and $paused = !$paused;
+        &gin($_) if $_;
+}
+
+sub moveFile {
+        my $f = shift;
+        my $d = $f;
+        $d =~ s:/[^/]+$::;
+        use File::Path;
+        mkpath $d;
+#       unless (mkpath($d)) {
+#               print ">> could not mkdirhier $d\n";
+#               next;
+#       }
+        unless (rename ($CurrentFile, $f)) {
+                print BOLD, RED, ">> could not move file to $d\n", RESET;
+                next;
+        }
+        print BOLD, BLUE, ">> moved to $d\n", RESET;
+}
+
+sub sleep {
+        my $t = shift;
+        if ($t) {
+                if ( $t =~ /(\d+)(:|')(\S+)/ ) {
+                        $t = $1*60+$3;
+                }
+        }
+        else {
+                $t = 0.1;
+        }
+        print "[sleeping $t secs]\n" unless $opt_q or $t < 1;
+        select (undef,undef,undef,$t);
+        return $t;
+}
+
+# stuff being sent to the engine
+sub gin {
+        my $p = shift;
+        print YELLOW, "==> $p\n", RESET if $opt_v;
+        print W $p, "\n";
+        &sleep(0.1);
+}
+
+sub fade {
+        my $s = shift;
+#%      $s = 33 unless $s;      #? X
+        $s = 12 unless $s;      #? !X
+        my $p = shift;
+        $p = 0.4 unless $p;
+        foreach $i ( reverse @VV ) {
+                next if $i >= $VOL;
+                last if $i <= $s;
+                &vol($i);
+                &sleep($p);
+        }
+        if ($s) {
+                &vol($s);
+        } else {
+                &gin( 'pause' );
+                $paused = !$paused;
+        }
+        &sleep($p);
+        return 1;
+}
+sub rise {
+        my $s = shift;
+        $s = 100 unless $s;
+        my $p = shift;
+        $p = 0.2 unless $p;
+        &gin( 'play' ) unless $VOL;
+        foreach $i ( @VV ) {
+                next if $i <= $VOL;
+                last if $i >= $s;
+                &vol($i);
+                &sleep($p);
+        }
+        if ($s) {
+                &vol($s);
+                &sleep(0.5);
+        }
+        $paused = 0;
+        return 1;
+}
+
+sub vol {
+        $VOL = shift;
+        # &gin( "volume 100 $VOL 50" );
+        #rint W "volume 100 $VOL 50\n";
+        &gin( "volume $VOL $VOL 50" );
+        #rint W "volume $VOL $VOL 50\n";    # bypasses debug
+        return 1;
+}
+
+sub seek {
+        my $p = shift;
+        my $r = shift;
+
+        &duration($r) if $r =~ /[:']/;
+        return &jump($p) if $p =~ /[:']/;
+
+        $p = $1 if $p =~ /(\d+)/;
+ #{ X
+#%      $r = 10 ** length($p) unless ($r);
+#%      &gin( "seek $p $r" );
+ #: X
+        $p = 11 * $p if $p < 10;
+        &gin( "seek $p 1" );
+        ## $r not supported in mplayer version.. yet?
+ #} X
+        return 1;
+}
+
+sub duration {
+        my $t = shift;
+
+        if ( $t =~ /(\d*)(:|')(\S+)/ ) {
+                $t = $1 ? $1*60+$3 : $3;
+        }
+        $DUR = $t * 1000;
+        print YELLOW, "[duration is $t secs]\n", RESET unless $opt_q;
+        return 1;
+}
+
+sub jump {
+        my $t = shift;
+        unless ($DUR) {
+                print STDERR "[you must specify the song duration first]\n";
+                return 1;
+        }
+        if ( $t =~ /(\d*)(:|')(\S*)/ ) {
+                $t = $1 ? $1*60+$3 : $3;
+        }
+        &gin( "seek ". $t*1000 .' '. $DUR );
+        return 1;
+}
+
+# if your system doesn't have "which" we're in trouble
+sub which {
+        my $cmd = shift;
+        $_ = `which $cmd 2>&1`;
+        print STDERR "which $cmd: $_" if DEBUG & 1;
+        /^(\S+)\s*$/;
+        return $1;
+}
+
+sub sortsongs {
+        my $style = shift;
+        return (1 .. $NS) unless $style;
+        lc $style;
+        my @order;
+        eval "\@order = sort by_$style 1 .. $NS";
+        croak <<X, &sorthelp if $@;
+invalid sort option '$style'
+X
+        return @order;
+}
+sub sorthelp { return <<X; }
+
+available sort algorithms:
+        n(ame)          # sorts by file path (directory first)
+        N(ame)          # sorts by file ending (reverse of -n)
+        nr              # gives an order by name a slight shuffle
+        cr              # gives the order given on commandline a slight shuffle
+        s(ize)          # hear silly small sound snippets first
+        S(ize)          # hear big epic pieces first
+        m(odification)  # hear newest tracks first
+        M(odification)  # hear oldest tracks first
+        a(ccessTime)    # hear tracks you haven't heard in a long time first
+        A(ccessTime)    # hear tracks you recently accessed first
+X
+        # r(andom)      # bad randomizer algorithm (use -r instead)
+sub by_n { $file[$a] cmp $file[$b]; }
+sub by_N { reverse($file[$a]) cmp reverse($file[$b]); }
+# this actually produces VERY pseudo random results, says randal
+# see http://www.perlmonks.org/?node_id=199901
+sub by_r { rand(10) < 5; }
+sub by_nr { rand(9) > 3 ? &by_n : &by_r; }
+sub by_cr { rand(9) > 3 ? $a <=> $b : &by_r; }
+sub by_m { $date[$a] <=> $date[$b]; }
+sub by_M { $date[$b] <=> $date[$a]; }
+sub by_a { $adate[$a] <=> $adate[$b]; }
+sub by_A { $adate[$b] <=> $adate[$a]; }
+sub by_s {
+        # one side of this if/else clause gets optimized away at compilation
+        if (DEBUG & 128) {
+                my $B = $size[$b]; my $A = $size[$a];
+                if ($A == $B) {
+                        my ($ad, $ai) = stat $a;
+                        my ($bd, $bi) = stat $b;
+                        # inform of duplicate files in file system
+                        # unless they are hard- or softlinked
+                        print MAGENTA, <<X, RESET
+                            unless $ai == $bi and $ad == $bd;
+Same file size $B:
+        $file[$a] and
+        $file[$b]
+X
+                        # we could also be calling cmp, but then we
+                        # are doing a different job than playing music
+                }
+                return $A <=> $B;
+        } else {
+                return $size[$a] <=> $size[$b];
+        }
+}
+sub by_S {
+        # one side of this if/else clause gets optimized away at compilation
+        if (DEBUG & 128) {
+                my $B = $size[$b]; my $A = $size[$a];
+                print MAGENTA, <<X, RESET if $A == $B;
+Same file size $B:
+        $file[$a] and
+        $file[$b]
+X
+                return $B <=> $A;
+        } else {
+                return $size[$b] <=> $size[$a];
+        }
+}
+
+# FIXME: maybe update to use List::Util 'shuffle';
+# or maybe this is fine because it does NOT use sort+rand
+sub randomize {
+        my @tmp = 1 .. $NS;
+        my @order = ();
+        my $lr = -99;
+        for my $j (1 .. $NS) {
+                my $r = int(rand($#tmp));
+                my $ir = $tmp[$r];
+
+                # this tries to avoid items being too near
+                # even if randomizer suggests so -
+                # in particular try not to play the same artist
+                # in a row, that's why we look at the filename
+                if ($#tmp>7 and abs($lr-$ir)<23 and
+                   substr($file[$lr],0,PATHMATCH) eq
+                   substr($file[$ir],0,PATHMATCH)) {
+                        print STDERR <<X if DEBUG & 4;
+last=$lr\t[$file[$lr]]
+near=$ir\t[$file[$ir]] ($r)
+X
+                        $r = int(rand($#tmp));
+                        $ir = $tmp[$r];
+                        if (substr($file[$lr],0,PATHMATCH) eq
+                            substr($file[$ir],0,PATHMATCH)) {
+                                print STDERR <<X if DEBUG & 4;
+new =$ir\t[$file[$ir]] ($r)
+\t\tno good, one more try:
+X
+                                $r = int(rand($#tmp));
+                                $ir = $tmp[$r];
+                        }
+                        print STDERR <<X if DEBUG & 4;
+new =$ir\t[$file[$ir]] ($r)
+
+X
+                }
+                $lr = splice @tmp, $r, 1;
+                push @order, $lr;
+        }
+        return @order;
+}
+
+sub enqueue {
+        my $saveNS = $NS;
+        for $_ (@_) {
+                if (-d $_ && -x _ && -r _) {
+                        print STDERR "\n[finddepth: $_]\n" if DEBUG & 2;
+                        &File::Find::finddepth(\&wanted, $_);
+                        next;   # $_ is corrupted after finddepth
+                }
+                $name = $_;
+                print STDERR "\n[file wanted: $_]\n" if DEBUG & 2;
+                &wanted;
+        }
+        if (my $new = $NS - $saveNS) {
+               &progress($new, ' songs found');
+               print "\n";
+        }
+}
+sub wanted {
+        ($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,
+           $atime,$mtime,$ctime,$blksize,$blocks) = lstat($_);
+        my $neat = length($name)>70 ? "...".substr($name,-67) : $name
+            unless $opt_q;
+        if (-f _ && -r _ && -s _ > 9999 && /\.$FILETYPES$/io) {
+                $file[++$NS] = $name;
+                $size[$NS] = $size || -s _;
+                $date[$NS] = $mtime || -M _;
+                $adate[$NS] = $atime;
+                &progress('yes: ', $neat);
+        } elsif ( -d _ && -e "$_/.prune" ) {
+                $prune = 1;
+                &progress('pruned: ', $name);
+                print "\n";
+#       } elsif ( $decode && -f _ && /\bindex\.etx$/i ) {
+#               open(I, "$decode <$_ |")
+#                 and @index = (@index, <I>) and close I;
+#               &progress('inf: ', $neat);
+        } else {
+                &progress('no : ', $neat) if -f _;
+        }
+}
+sub progress {
+        return if $opt_q;
+        my $tx = join('', @_);
+        my $len = length $tx;
+        print "\r", GREEN, $tx, RESET, ' ';
+        print '_' x (74-$len), ' ' if $len < 74;
+        print "\n" if DEBUG & 1;
+}
+
+sub ginxpect {
+        local($match) = @_; 
+
+        while(<R>) {
+                last if /$match/i;      # not /o!
+                &ginparse($_);
+        }
+        # print "\n";
+}
+sub ginparse {
+        # most frequent events first!
+        if (
+#%          /^MSG notify timecode (\S+)/    #? X
+            /^A:\s+([\d]+\.\d)\s/           #? !X
+        ) {
+                unless (
+#%                  $TC eq $1   #? X
+                    $tc == $1   #? !X
+                ) {
+#%                      $TC = $1;                       #? X
+                        $tc = $1;                       #? !X
+                        $TC = time2str('[%T]', $tc, 0); #? !X
+                        print BOLD, GREEN, "\r$TC ", RESET unless $opt_q;
+                }
+                return 0;
+        }
+        print STDERR BOLD, BLUE, $_, RESET if $opt_V or DEBUG & 512;
+ #{ X
+#%      if (/^MSG notify duration \[(\d+)\]/) {
+#%              # kludge to get around a bug in xaudio (duration output twice)
+#%              if ($1 != $LDUR) {
+#%                      $LDUR = $DUR = $1;
+#%                      $DUR *= 1000 if $DUR < 1000;
+#%                      $CDUR += $DUR;  # cumulative duration
+#%              }
+#%              return 0;
+#%      } 
+#%      if (/ stream info \[(.+)\]/) {
+#%              %I = split /[=,\s]+/, $1;
+#%              my $d = $DUR / 1000;
+#%              $I{duration} = sprintf("%02d:%02d", $d / 60, $d % 60);
+#%#             if ($opt_l) {
+#%#                     my $f = $file[$order[$CS]];
+#%#                     my $s = $CurrentFile eq $f ? -$size[$order[$CS]] : -s $f;
+#%#                     printf ("%9d %5s %3s\t%s\n", $s,
+#%#                             $I{duration}, $I{bitrate}, $CurrentFile);
+#%#             }
+#%              $I{mode} = lc $I{mode};
+#%              if ($opt_c) {
+#%                      my $d = $CDUR / 1000;
+#%                      $I{cumulative} = sprintf("%02d:%02d", $d / 60, $d % 60);
+#%                      &progress("$TC   -> [$I{duration}] {$I{cumulative}} $I{bitrate} mp$I{layer}.$I{level} $I{frequency} $I{mode} ");
+#%              } else {
+#%                      &progress("$TC   -> [$I{duration}] mp$I{layer}.$I{level} with $I{frequency} Hz at $I{bitrate} kbps in $I{mode}");
+#%              }
+#%              return $_;
+#%      }
+#%#     if ($opt_l and / ack \[XA_MSG_COMMAND_INPUT_OPEN\]/) {
+#%#             my $f = $file[$order[$CS]];
+#%#             my $s = $CurrentFile eq $f ? -$size[$order[$CS]] : -s $f;
+#%#             printf ("%9d\t%s\n", $s, $CurrentFile);
+#%#     }
+ #: X
+        if ( /^\[file\] File size is (\d+) bytes$/ ) {
+            $size = $1;
+            print STDERR "Got size: $size\n" if DEBUG & 512;
+            return 0;
+        }
+# [lavf] stream 0: audio (opus), -aid 0, -alang eng
+# INFO: libavcodec "aac" init OK!
+# Selected audio codec: [ffaac] afm: ffmpeg (FFmpeg AAC (MPEG-2/MPEG-4 Audio))
+        if ( /^\[lavf\] .* audio \((\S+)\),/ ) {
+            $codec = $1;
+            print STDERR "Got codec: $codec\n" if DEBUG & 512;
+            return 0;
+        }
+ #} X
+        if (
+#%          / input name \[(.+)\]/              #? X
+#           /^Playing (.+)\.$/                  #? !X
+            /^STREAM: \[file\] (.+)$/           #? !X
+        ) {
+                # global vars for current filename
+                my $nf = $1;
+                # we do indeed not receive a proper info for mp2, mp3...
+                $CurrentCodec = $codec;
+                $CurrentSize = $size || -s $nf;
+                if ($CurrentFile ne $nf) {
+                        $moveLater = undef;
+                        $deleteLater = undef;
+                        $size = undef;
+                        $codec = undef;
+                }
+                $CurrentFile = $nf;
+                return $_;
+        }
+ #{ X
+#%      #return 0 if /^(play|close|open|volume)/;
+#%      return 0 if /^(play|volume|get_player_mode)/;
+#%      return $_ if $opt_q or / notify (position|ack|play|state|can seek)/;
+#%      if ( /^MSG notify debug \[.* message=\"no audio device found\"\]/ ) {
+#%              print "\n\r", <<X;
+#%*** No audio device accessible. Try modprobe snd-pcm-oss!
+#%X
+#%              &exit(-1);
+#%      }
+#%      if (DEBUG & 2048 and /^MSG notify debug \[.* message=\"(.+)\"\]/) {
+#%              print "\r*** ", $1, "\n";
+#%              return 0;
+#%      }
+#%      return $_ if !$opt_v && /notify (debug|output|input|nack)/;
+#%      # my $o = $_;
+#%      s/^MSG notify //i;
+#%      print BOLD, MAGENTA, "\r*** ", $_, RESET;
+ #: X
+        if ( /^AUDIO: (\d+) Hz, (\d+) ch, \S+ (\d+)\.\d kbit/ ) {
+                $I{frequency} = $1;
+                $I{channels} = $2;
+                $I{bitrate} = $3;
+                return 0;
+        }
+        if ( /^Starting playback/ ) {
+                my $nf = $CurrentFile;
+                $nf =~ s/\.(\S+)$//i;
+                $codec = $1 unless $codec;
+                $PrintCurrentFile = $codec? "<$codec> $CurrentSize " : $CurrentSize .' ';
+                $PrintCurrentFile .= (length($PrintCurrentFile)+length($nf)>74)
+                    ? ("...".substr($nf,length($PrintCurrentFile)-72)) : $nf;
+                print "\r$PrintCurrentFile\n";
+                my $txt = "$TC   -> [$I{duration}] $I{frequency} Hz at $I{bitrate} kbps with $I{channels} channels";
+                &progress($txt) unless $opt_v;
+                print GREEN, $txt, RESET, "\n" if $opt_v;
+                return 0;
+        }
+        return if / supported but disabled$/; # unimportant
+        return if /^Configuration: --prefix/; # useless ffmpeg compilation infos
+ #} X
+        return $_;
+}
+
+sub ginstart {
+        return if $pid;
+        if ($opt_I) {
+                system("soundoff");
+                system("soundon");
+                system("clear");
+        }
+        $R = new FileHandle; $R->autoflush;
+        $W = new FileHandle; $W->autoflush;
+ #{ X
+#%      $pid = open3( \*W, \*R, \*R, "$wrapper $has_rxaudio");
+#%      $pid || die "$wrapper $has_rxaudio: $!";
+#%      &ginxpect('ready');
+ #: X
+        # -v is needed to receive the EOF!
+        $pid = open3( \*W, \*R, \*R, $has_mplayer, '-slave', '-idle', '-v', '-fs', '-osdlevel', '3', '-zoom' );
+        R->blocking(0);
+        $pid || die "$has_mplayer: $!";
+        &ginxpect('^MPlayer');
+        &gin('use_master');
+ #} X
+        print STDERR <<X if DEBUG & 64;
+audio engine running as $pid
+X
+        add( \*R, 'r', \&ginread );
+        $output_open = 1;
+}
+sub ginstop {
+        remove( \*R );
+ #{ X
+#%      gin('exit');
+ #: X
+        gin('quit');
+ #} X
+        close R;
+        undef $pid;
+        $output_open = 0;
+}
+sub ginclose {
+#%      gin('output_drain');  #? X
+        $output_open = 0;
+#%      gin('output_close');  #? X
+}
+sub ginopen {
+        return if $output_open;
+        if ($opt_I) {
+                system("soundoff");
+                system("soundon");
+                system("clear");
+        }
+#%      gin('output_open');   #? X
+        $output_open = 1;
+}
+
+sub exit { &ginstop, exit(shift); }
+
+sub load {
+        my $songs = $opt_L? 'songs': 'entries';
+        local *L;
+        return unless open (L, $playlist);
+        for ($NS=0; <L>;) {
+                chomp;
+                if ($opt_L and not -r $_) {
+                        print "Skipping $_\n";
+                        next;
+                }
+                $order[$NS] = $NS;
+                $file[$NS++] = $_;
+        }
+        close L;
+        print YELLOW, "\rLoaded $NS $songs from $playlist\n\n", RESET
+            unless $opt_q;
+}
+sub save {
+        my $cs = shift;
+        local *L;
+        umask 077;
+        return unless open (L, ">$playlist");
+        print YELLOW, "\rSaving playlist into $playlist\n\n", RESET
+            unless $opt_q;
+        foreach my $i ($cs+1 .. $NS-1) {
+                my $f = $file[$order[$i]];
+                print L $ENV{PWD}, '/' unless $f =~ m!^/!;
+                print L $f, "\n";
+        }
+        close L;
+}
+sub edit {
+        &save(shift);
+        system "$ENV{EDITOR} $playlist;clear";
+        &load;
+        $CS = -1;
+        print "$PrintCurrentFile\n";
+}