# Copyright (c) 1998-2001 Robert Woodcock <rcw@debian.org>
# Copyright (c) 2003-2006 Jesus Climent <jesus.climent@hispalinux.es>
# Copyright (c) 2009-2012 Colin Tuckley <colint@debian.org>
-# Copyright (c) 2012- Steve McIntyre <93sam@@debian.org>
-# Copyright (c) 2015-2016 Andrew Strong <andrew.david.strong@gmail.com>
+# Copyright (c) 2012-2018 Steve McIntyre <93sam@@debian.org>
+# Copyright (c) 2015-2017 Andrew Strong <andrew.david.strong@gmail.com>
# This code is hereby licensed for public consumption under either the
# GNU GPL v2 or greater, or Larry Wall's Artistic license - your choice.
#
echo "Options:"
echo "-1 Encode the whole CD in a single file"
echo "-a <action1[,action2]...>"
-echo " Actions to perform:"
-echo " cddb,read,getalbumart,normalize,encode,tag,move,replaygain,playlist,clean"
+echo " Actions to perform, comma separated:"
+echo " (cddb,read,getalbumart,embedalbumart,normalize,encode,"
+echo " tag,move,replaygain,playlist,clean)"
#echo "-A Experimental actions (retag, transcode)"
echo "-b Enable batch normalization"
+echo "-B Embed albumart (this also activates getalbumart)"
echo "-c <file>"
echo " Specify a configuration file (overrides system and user config files)"
echo "-C <discid#>"
echo "-n No lookup. Don't query CDDB, just create and use template"
echo "-N Noninteractive. Never prompt for anything"
echo "-o <type1[,type2]...>"
-echo " Output file type(s) (vorbis,mp3,flac,spx,mpc,wav,m4a,opus,mka,wv,ape,mp2,tta). Defaults to vorbis"
+echo " Output file type(s), comma separated"
+echo " (vorbis,mp3,flac,spx,mpc,wav,m4a,opus,mka,wv,ape,mp2,tta,aiff)."
+echo " Defaults to vorbis"
echo "-p Pad track numbers with 0's (if less than 10 tracks)"
echo "-P Use UNIX pipes to read+encode without wav files"
+echo "-Q CD lookup method(s), comma separated"
+echo " (musicbrainz,cddb,cdtext). Defaults to musicbrainz".
echo "-r <host1[,host2]...>"
echo " Also encode on these remote hosts"
echo "-s <field>"
addstatus ()
{
- echo "$@" >> "$ABCDETEMPDIR/status"
+ echo "$@" >> "${ABCDETEMPDIR}/status"
}
# log [level] [message]
f_seq_row ()
{
i=$1
- while [ $i -ne `expr $2 + 1` ]
+ while [ $i -le $2 ]
do
echo $i
- i=`expr $i + 1`
+ i=$(( $i + 1 ))
done
}
f_seq_line ()
{
i=$1
- if echo $i | grep "[[:digit:]]" > /dev/null 2>&1 ; then
- while [ $i -ne `expr $2 + 1` ]
+ if echo "$i" | grep "[[:digit:]]" > /dev/null 2>&1 ; then
+ while [ $i -le $2 ]
do
- printf $i" "
- i=`expr $i + 1`
+ printf "%d " "$i"
+ i=$(( $i + 1 ))
done
echo
else
# Functions to replace the need of awk {print $1} and {print $NF}
get_first()
{
-if [ X"$1" = "X" ]; then
- for first in `cat`; do
- break
- done
-else
- first=$1
-fi
-echo $first
+ if [ X"$1" = "X" ]; then
+ for first in $(cat); do
+ break
+ done
+ else
+ first=$1
+ fi
+ echo "$first"
}
get_last()
{
-if [ X"$1" = "X" ]; then
- for stdin in `cat`; do
- last=$stdin
- done
-else
- for last in $@ ; do :; done
-fi
-echo $last
+ if [ X"$1" = "X" ]; then
+ for stdin in $(cat); do
+ last=$stdin
+ done
+ else
+ for last in "$@" ; do :; done
+ fi
+ echo "$last"
}
# checkstatus [blurb]
{
# Take the last line in the status file if there's multiple matches
PATTERN="^$1(=.*)?$"
- BLURB=$(grep -E $PATTERN "$ABCDETEMPDIR/status" | tail -n 1)
+ BLURB=$(grep -E "$PATTERN" "${ABCDETEMPDIR}/status" | tail -n 1)
if [ -z "$BLURB" ]; then
# No matches found
else
# Matches found
# See if there's a = in it
- if [ "$(echo $BLURB | grep -c =)" != "0" ]; then
- echo "$(echo $BLURB | cut -f2- -d=)"
+ if ( echo "$BLURB" | grep -q '=' ); then
+ echo "$BLURB" | cut -f2- -d=
fi
return 0
fi
# Otherwise, returns "".
checkwarnings ()
{
- if [ -e "$ABCDETEMPDIR/warnings" ]; then :; else
+ if [ -e "${ABCDETEMPDIR}/warnings" ]; then :; else
return 1
fi
# Take the last line in the status file if there's multiple matches
PATTERN="^$1(:.*)?$"
- BLURB="$(grep -E $PATTERN "$ABCDETEMPDIR/warnings" | tail -n 1)"
+ BLURB=$(grep -E "$PATTERN" "${ABCDETEMPDIR}/warnings" | tail -n 1)
if [ -z "$BLURB" ]; then
# negative, we did not have a negative...
# Otherwise, returns "".
checkerrors ()
{
- if [ -e "$ABCDETEMPDIR/errors" ]; then :; else
+ if [ -e "${ABCDETEMPDIR}/errors" ]; then :; else
return 1
fi
# Take the last line in the status file if there's multiple matches
PATTERN="^$1(:.*)?$"
- BLURB="$(grep -E $PATTERN "$ABCDETEMPDIR/errors" | tail -n 1)"
+ BLURB=$(grep -E "$PATTERN" "${ABCDETEMPDIR}/errors" | tail -n 1)
if [ -z "$BLURB" ]; then
# negative, we did not have a negative...
}
# page [file]
-# Finds the right pager in the system to display a file
+# Display a file. If it's too long to fit the current terminal size,
+# find the right pager in the system and use it
page ()
{
PAGEFILE="$1"
- # Use the debian sensible-pager wrapper to pick the pager
- # user has requested via their $PAGER environment variable
- if [ -x "/usr/bin/sensible-pager" ]; then
- /usr/bin/sensible-pager "$PAGEFILE"
- elif [ -x "$PAGER" ]; then
- # That failed, try to load the preferred editor, starting
- # with their PAGER variable
- $PAGER "$PAGEFILE"
- # If that fails, check for less
- elif [ -x /usr/bin/less ]; then
- /usr/bin/less -f "$PAGEFILE"
- # more should be on all UNIX systems
- elif [ -x /bin/more ]; then
- /bin/more "$PAGEFILE"
+ local NUM_LINES=$(wc -l < "$PAGEFILE")
+
+ # Is the text long enough to need a pager?
+ if [ "$NUM_LINES" -ge $LINES ]; then
+ # Yes!
+ # Use the debian sensible-pager wrapper to pick the pager user
+ # has requested via their $PAGER environment variable
+ if [ -x "/usr/bin/sensible-pager" ]; then
+ /usr/bin/sensible-pager "$PAGEFILE"
+ elif [ -x "$PAGER" ]; then
+ # That failed, try to load the preferred pager, starting
+ # with their PAGER variable
+ $PAGER "$PAGEFILE"
+ # If that fails, check for less
+ elif [ -x /usr/bin/less ]; then
+ /usr/bin/less -f "$PAGEFILE"
+ # more should be on all UNIX systems
+ elif [ -x /bin/more ]; then
+ /bin/more "$PAGEFILE"
+ else
+ # No bananas, just cat the thing
+ cat "$PAGEFILE" >&2
+ fi
else
- # No bananas, just cat the thing
+ # No, just cat the thing
cat "$PAGEFILE" >&2
fi
}
else
# Special case for SMP, since
# encoder output is never displayed, don't mute echos
- if [ -z "$BLURB" -a "$MAXPROCS" != "1" ]; then
+ if [ -z "$BLURB" ] && [ "$MAXPROCS" != "1" ]; then
"$@" >&2
RETURN=$?
else
if [ "$BLURB" ]; then
TWEAK="$BLURB: "
fi
- echo "${TWEAK}returned code $RETURN: $@" >> "$ABCDETEMPDIR/errors"
+ echo "${TWEAK}returned code $RETURN: $@" >> "${ABCDETEMPDIR}/errors"
return $RETURN # Do not pass go, do not update the status file
fi
if [ "$BLURB" ]; then
- echo $BLURB >> "$ABCDETEMPDIR/status"
+ echo "$BLURB" >> "${ABCDETEMPDIR}/status"
fi
}
;;
esac
- echo $TO
+ echo "$TO"
}
new_checkexec ()
{
if [ ! "$@" = "" ]; then
# Cut off any command-line option we added in
- X=$(echo $@ | cut -d' ' -f2)
- if [ "$(which $X)" = "" ]; then
+ X=$(echo "$@" | cut -d' ' -f2)
+ WHICH=$(which "$X" 2>/dev/null)
+ if [ -z "$WHICH" ]; then
return 1
- elif [ ! -x $(which $X) ]; then
+ elif [ ! -x "$WHICH" ]; then
return 2
fi
fi
{
if [ ! "$@" = "" ]; then
# Cut off any command-line option we added in
- X=$(echo $@ | cut -d' ' -f2)
+ X=$(echo "$@" | cut -d' ' -f2)
# Test for built-in abcde.function
- [ "$X" != "${X#abcde.}" ] && type $X >/dev/null 2>&1 && return
- if [ "$(which $X)" = "" ]; then
+ [ "$X" != "${X#abcde.}" ] && type "$X" >/dev/null 2>&1 && return
+ WHICH=$(which "$X" 2>/dev/null)
+ if [ -z "$WHICH" ]; then
log error "$X is not in your path." >&2
log info "Define the full path to the executable if it exists on your system." >&2
- if [ -e /etc/debian_* ] ; then
+ if [ -e /etc/debian_version ] ; then
case $X in
- oggenc) MISSING_PACKAGE=vorbis-tools ;;
- lame|flac) MISSING_PACKAGE=$X ;;
+ oggenc)
+ MISSING_PACKAGE=vorbis-tools
+ ;;
+ lame|flac|cd-discid|eject|mkcue|icedax|glyrc)
+ MISSING_PACKAGE=$X
+ ;;
esac
log info "Hint: sudo apt-get install $MISSING_PACKAGE" >&2
fi
exit 1
- elif [ ! -x "$(which $X)" ]; then
+ elif [ ! -x "$WHICH" ]; then
log error "$X is not executable." >&2
exit 1
fi
shift
local CDDBDIFFCHOICE="$@"
if [ ! X"$DIFF" = "X" ]; then
- PARSECHOICE1=$(echo $CDDBDIFFCHOICE | cut -d"," -f1 | xargs printf %d 2>/dev/null)
- PARSECHOICE2=$(echo $CDDBDIFFCHOICE | cut -d"," -f2 | xargs printf %d 2>/dev/null)
- if [ $PARSECHOICE1 -lt 1 ] || [ $PARSECHOICE1 -gt $CDDBDIFFCHOICES ] || \
- [ $PARSECHOICE2 -lt 1 ] || [ $PARSECHOICE2 -gt $CDDBDIFFCHOICES ] || \
- [ $PARSECHOICE1 -eq $PARSECHOICE2 ]; then
- echo "Invalid diff range. Please select two comma-separated numbers between 1 and $CDDBDIFFCHOICES" >&2
+ PARSECHOICE1=$(echo "$CDDBDIFFCHOICE" | cut -d"," -f1 | xargs printf %d 2>/dev/null)
+ PARSECHOICE2=$(echo "$CDDBDIFFCHOICE" | cut -d"," -f2 | xargs printf %d 2>/dev/null)
+ if [ "$PARSECHOICE1" -lt 1 ] || [ "$PARSECHOICE1" -gt "$CDDBDIFFCHOICES" ] || \
+ [ "$PARSECHOICE2" -lt 1 ] || [ "$PARSECHOICE2" -gt "$CDDBDIFFCHOICES" ] || \
+ [ "$PARSECHOICE1" -eq "$PARSECHOICE2" ]; then
+ echo "Invalid diff range." >&2
+ echo "Please select two comma-separated numbers between 1 and $CDDBDIFFCHOICES" >&2
else
# We parse the 2 choices to diff, store them in temporary files and diff them.
- for PARSECHOICE in $(echo $CDDBDIFFCHOICE | tr , \ ); do
- do_cddbparse "$ABCDETEMPDIR/$FILENAME.$PARSECHOICE" > "$ABCDETEMPDIR/$FILENAME.parsechoice.$PARSECHOICE"
+ for PARSECHOICE in $(echo "$CDDBDIFFCHOICE" | tr , \ ); do
+ do_cddbparse "${ABCDETEMPDIR}/$FILENAME.$PARSECHOICE" > "${ABCDETEMPDIR}/$FILENAME.parsechoice.$PARSECHOICE"
done
- echo "Showing diff between choices $PARSECHOICE1 and $PARSECHOICE2..." > "$ABCDETEMPDIR/$FILENAME.diff"
- $DIFF $DIFFOPTS "$ABCDETEMPDIR/$FILENAME.parsechoice.$PARSECHOICE1" "$ABCDETEMPDIR/$FILENAME.parsechoice.$PARSECHOICE2" >> "$ABCDETEMPDIR/$FILENAME.diff"
- if [ $(cat "$ABCDETEMPDIR/$FILENAME.diff" | wc -l) -ge 24 ]; then
- page "$ABCDETEMPDIR/$FILENAME.diff"
- else
- cat "$ABCDETEMPDIR/$FILENAME.diff" >&2
- fi
+ echo "Showing diff between choices $PARSECHOICE1 and $PARSECHOICE2..." > "${ABCDETEMPDIR}/$FILENAME.diff"
+ $DIFF $DIFFOPTS "${ABCDETEMPDIR}/$FILENAME.parsechoice.$PARSECHOICE1" \
+ "${ABCDETEMPDIR}/$FILENAME.parsechoice.$PARSECHOICE2" >> "${ABCDETEMPDIR}/$FILENAME.diff"
+ page "${ABCDETEMPDIR}/$FILENAME.diff"
fi
else
- echo "The diff program was not found in your path. Please choose a number between 0 and $CDDBDIFFCHOICES." >&2
+ echo "The diff program was not found in your path." >&2
+ echo "Please choose a number between 0 and $CDDBDIFFCHOICES." >&2
fi
}
{
case $1 in
TRACKNAME1)
- TRACKNAME="$(grep -a ^TTITLE$CDDBTRACKNUM= "$CDDBDATA" | head -n 1 | cut -f2- -d= | tr -d \[:cntrl:\] | sed 's/\ \+$//')"
+ TRACKNAME="$(grep -a "^TTITLE$CDDBTRACKNUM=" "$CDDBDATA" | head -n 1 | cut -f2- -d= | tr -d \[:cntrl:\] | sed 's/\ \+$//')"
;;
TRACKNAME)
- TRACKNAME="$(grep -a ^TTITLE$CDDBTRACKNUM= "$CDDBDATA" | cut -f2- -d= | tr -d \[:cntrl:\] | sed 's/\ \+$//')"
+ TRACKNAME="$(grep -a "^TTITLE$CDDBTRACKNUM=" "$CDDBDATA" | cut -f2- -d= | tr -d \[:cntrl:\] | sed 's/\ \+$//')"
;;
TRACK-INFO)
- grep -a ^EXTT$CDDBTRACKNUM= "$CDDBDATA" | cut -f2- -d= | tr -d \[:cntrl:\] | sed 's/\\n/\n/g'
+ grep -a "^EXTT$CDDBTRACKNUM=" "$CDDBDATA" | cut -f2- -d= | tr -d \[:cntrl:\] | sed 's/\\n/\n/g'
;;
esac
}
{
if [ -n "$STARTTRACKNUMBER" ] ; then
# Get the trackpadding from the current track, also trim whitespace for MacOSX
- CURRENTTRACKPADDING=$(echo -n $UTRACKNUM | wc -c | tr -d ' ')
- TRACKNUM=$( printf %0.${CURRENTTRACKPADDING}d $(expr ${UTRACKNUM} + ${STARTTRACKNUMBER} - $FIRSTTRACK ))
+ CURRENTTRACKPADDING=$(echo -n "$UTRACKNUM" | wc -c | tr -d ' ')
+ TRACKNUM=$( printf %0."${CURRENTTRACKPADDING}"d $(("${UTRACKNUM}" + "${STARTTRACKNUMBER}" - "${FIRSTTRACK}")))
else
- TRACKNUM=${UTRACKNUM}
+ TRACKNUM="${UTRACKNUM}"
fi
}
CDDBCKSUM=0
COOKEDOFFSETS=""
- for OFFSET in $(echo $OFFSETS)
+ for OFFSET in $OFFSETS
do
COOKEDOFFSETS="${COOKEDOFFSETS} $(($OFFSET + $LEADIN))"
COOKEDOFFSETS="${COOKEDOFFSETS:1}" # eat the leading space
- PREGAP=$(($(echo $OFFSETS | cut -f1 -d' ')))
+ PREGAP=$(echo $OFFSETS | cut -f1 -d' ')
TOTALTIME=$(( (($LEADOUT + $LEADIN + $PREGAP) / $CDFRAMES) - (($LEADIN + $PREGAP) / $CDFRAMES)))
- case "$CDDBMETHOD" in
- cddb)
- printf -v DISCID "%08lx" $(( ($CDDBCKSUM % 0xff) * 16777216 | $TOTALTIME * 256 | $TRACKS))
- ;;
- musicbrainz)
+ vvecho "makeids: PREGAP $PREGAP, LEADIN $LEADIN, LEADOUT $LEADOUT"
+
+ # Calculate both the cddb discid *and* the musicbrainz discid
+ # now. We'll use the cddb discid for reference in most cases
+ # for consistency, but we also have the musicbrainz discid for
+ # when we need it
+ printf -v CDDBDISCID "%08lx" $(( ($CDDBCKSUM % 0xff) * 16777216 | $TOTALTIME * 256 | $TRACKS))
+ CDDBTRACKINFO="${CDDBDISCID} $((TRACKS)) ${COOKEDOFFSETS} $((($LEADOUT + $LEADIN + $IDMAGICNUM) / $CDFRAMES))"
+
+ case $CDDBMETHOD in
+ *musicbrainz*)
# FIXME: don't assume the first track is 1
- echo "dasd: 1 $TRACKS $LEADIN $LEADOUT $OFFSETS "
- DISCID=$($MUSICBRAINZ --command calcid --discinfo 1 $TRACKS $LEADIN $LEADOUT $OFFSETS)
+ MBDISCID=$($MUSICBRAINZ --command calcid --discinfo 1 $TRACKS $LEADIN $(($PREGAP + $LEADOUT)) $OFFSETS)
+ error=$?
+ if [ $error != 0 ]; then
+ log error "$MUSICBRAINZ failed to run; ABORT"
+ exit $error
+ fi
+ MBTRACKINFO="${MBDISCID} $((TRACKS)) ${COOKEDOFFSETS} $((($LEADOUT + $LEADIN + $IDMAGICNUM) / $CDFRAMES))"
;;
esac
-
- TRACKINFO="${DISCID} $((TRACKS)) ${COOKEDOFFSETS} $((($LEADOUT + $LEADIN + $IDMAGICNUM) / $CDFRAMES))"
}
do_replaygain()
{
if checkstatus replaygain; then :; else
run_command "" echo "Adding replaygain information..."
- for TMPOUTPUT in $( echo $OUTPUTTYPE | tr , \ )
+ for TMPOUTPUT in $( echo "$OUTPUTTYPE" | tr , \ )
do
case $TMPOUTPUT in
vorbis|ogg)
REPLAYINDEX=0
for UTRACKNUM in $TRACKQUEUE
do
- CDDBTRACKNUM=$(expr $UTRACKNUM - 1)
+ CDDBTRACKNUM=$(expr "$UTRACKNUM" - 1) # Unpad
getcddbinfo TRACKNAME
splitvarious
TRACKFILE="$(mungetrackname "$TRACKNAME")"
done
case "$OUTPUT" in
flac)
- run_command replaygain-flac nice $ENCNICE $METAFLAC $FLACGAINOPTS "${OUTPUTFILES[@]}"
- #run_command replaygain-flac true
+ run_command "replaygain-flac" nice $ENCNICE $METAFLAC $FLACGAINOPTS "${OUTPUTFILES[@]}"
;;
vorbis|ogg)
- run_command replaygain-vorbis nice $ENCNICE $VORBISGAIN $VORBISGAINOPTS "${OUTPUTFILES[@]}"
+ run_command "replaygain-vorbis" nice $ENCNICE $VORBISGAIN $VORBISGAINOPTS "${OUTPUTFILES[@]}"
;;
mp3)
- run_command replaygain-mp3 nice $ENCNICE $MP3GAIN $MP3GAINOPTS "${OUTPUTFILES[@]}"
+ run_command "replaygain-mp3" nice $ENCNICE $MP3GAIN $MP3GAINOPTS "${OUTPUTFILES[@]}"
;;
mpc)
- run_command replaygain-mpc nice $ENCNICE $MPCGAIN "${OUTPUTFILES[@]}"
+ run_command "replaygain-mpc" nice $ENCNICE $MPCGAIN "${OUTPUTFILES[@]}"
;;
wv)
- run_command replaygain-wv nice $ENCNICE $WVGAIN $WVGAINOPTS "${OUTPUTFILES[@]}"
+ run_command "replaygain-wv" nice $ENCNICE $WVGAIN $WVGAINOPTS "${OUTPUTFILES[@]}"
;;
*);;
esac
done
if checkerrors "replaygain-.{3,6}"; then :; else
- run_command replaygain true
+ run_command "replaygain" true
fi
fi
}
}
do_getgenreid () {
-local genre=$(echo "${@}" | tr '[A-Z]' '[a-z]')
-local id=""
+ local genre=$(echo "${@}" | tr 'A-Z' 'a-z')
+ local id=""
case ${genre} in
"blues") id=0 ;;
"classic rock") id=1 ;;
# COMMENT, DALBUM, DARTIST, CDYEAR, CDGENRE
do_tag ()
{
- COMMENTOUTPUT="$(eval echo ${COMMENT})"
+ COMMENTOUTPUT="$(eval echo "${COMMENT}")"
if [ -z "$COMMENTOUTPUT" ]; then
COMMENTOUTPUT="$(getcddbinfo TRACK-INFO)"
fi
- if [ "$CDDBMETHOD" = "cddb" ]; then
- CDDBDISCID=$(echo $TRACKINFO | cut -d' ' -f1)
- fi
- run_command '' echo "Tagging track $1 of $TRACKS: $TRACKNAME..."
+ CDDBDISCID=$(echo "$CDDBTRACKINFO" | cut -d' ' -f1)
+ run_command "" echo "Tagging track $1 of $TRACKS: $TRACKNAME..."
# If we want to start the tracks with a given number, we need to modify the
# TRACKNUM value before evaluation
if [ -n "$STARTTRACKNUMBERTAG" ] ; then
gettracknum
fi
- for OUTPUT in $(echo $OUTPUTTYPE | tr , \ )
+ for OUTPUT in $(echo "$OUTPUTTYPE" | tr , \ )
do
case "$OUTPUT" in
mp3)
case "$ID3SYNTAX" in
id3)
- run_command tagtrack-$OUTPUT-$1 nice $ENCNICE \
+ run_command "tagtrack-$OUTPUT-$1" nice $ENCNICE \
$TAGGER $TAGGEROPTS -c "$COMMENTOUTPUT" \
-A "$DALBUM" -a "$TRACKARTIST" -t "$TRACKNAME" \
-y "$CDYEAR" -g "$GENREID" \
-T "${TRACKNUM:-$1}" \
- "$ABCDETEMPDIR/track$1.$OUTPUT"
+ "${ABCDETEMPDIR}/track$1.$OUTPUT"
;;
id3v2)
# FIXME # track numbers in mp3 come with 1/10, so we cannot
# happily substitute them with $TRACKNUM
- run_command tagtrack-$OUTPUT-$1 nice $ENCNICE \
+ run_command "tagtrack-$OUTPUT-$1" nice $ENCNICE \
$TAGGER $TAGGEROPTS -c "$COMMENTOUTPUT" \
-A "$DALBUM" -a "$TRACKARTIST" -t "$TRACKNAME" \
-y "$CDYEAR" -g "$GENREID" \
-T "${TRACKNUM:-$1}/$TRACKS" \
${TPE2:+--TPE2 "$TPE2"} \
- "$ABCDETEMPDIR/track$1.$OUTPUT"
+ "${ABCDETEMPDIR}/track$1.$OUTPUT"
;;
id3tag)
# FIXME # track numbers in mp3 come with 1/10, so we cannot
# happily substitute them with $TRACKNUM
- run_command tagtrack-$OUTPUT-$1 nice $ENCNICE \
+ run_command "tagtrack-$OUTPUT-$1" nice $ENCNICE \
$TAGGER $TAGGEROPTS -c "$COMMENTOUTPUT" \
-A "$DALBUM" -a "$TRACKARTIST" -s "$TRACKNAME" \
-y "$CDYEAR" -g "$GENREID" \
-t "${TRACKNUM:-$1}" ${TRACKNUM:+-T "$TRACKS"} \
- "$ABCDETEMPDIR/track$1.$OUTPUT"
+ "${ABCDETEMPDIR}/track$1.$OUTPUT"
;;
eyed3*)
# FIXME # track numbers in mp3 come with 1/10, so we cannot
${COMMENTOUTPUT:+--comment "$COMMENTOUTPUT"} \
);;
esac
- run_command tagtrack-$OUTPUT-$1 nice $ENCNICE $TAGGER $TAGGEROPTS \
+ run_command "tagtrack-$OUTPUT-$1" nice $ENCNICE $TAGGER $TAGGEROPTS \
-A "$DALBUM" \
-a "$TRACKARTIST" -t "$TRACKNAME" \
-G "$GENREID" -n "${TRACKNUM:-$1}" \
${TRACKNUM:+-N "$TRACKS"} \
"${addopts[@]}" \
- "$ABCDETEMPDIR/track$1.$OUTPUT"
+ "${ABCDETEMPDIR}/track$1.$OUTPUT"
;;
*)
log error "Internal error: ID3SYNTAX has an illegal value"
case "$OGGENCODERSYNTAX" in
vorbize|oggenc)
# vorbiscomment can't do in-place modification, mv the file first
- if [ -f "$ABCDETEMPDIR/track$1.$OGGOUTPUTCONTAINER" -a ! -f "$ABCDETEMPDIR/track$1.uncommented.$OGGOUTPUTCONTAINER" ]; then
- mv "$ABCDETEMPDIR/track$1.$OGGOUTPUTCONTAINER" "$ABCDETEMPDIR/track$1.uncommented.$OGGOUTPUTCONTAINER"
+ if [ -f "${ABCDETEMPDIR}/track$1.$OGGOUTPUTCONTAINER" ] && \
+ [ ! -f "${ABCDETEMPDIR}/track$1.uncommented.$OGGOUTPUTCONTAINER" ]; then
+ mv "${ABCDETEMPDIR}/track$1.$OGGOUTPUTCONTAINER" \
+ "${ABCDETEMPDIR}/track$1.uncommented.$OGGOUTPUTCONTAINER"
fi
(
# These are from
if [ -n "$CDGENRE" ]; then
echo GENRE="$CDGENRE"
fi
- echo TRACKNUMBER=${TRACKNUM:-$1}
+ echo TRACKNUMBER="${TRACKNUM:-$1}"
# TRACKTOTAL is not in the proposed, minimal list of standard field names from
# xiph.org: https://www.xiph.org/vorbis/doc/v-comment.html but is in common usage
# and read by mediainfo, ffprobe, vlc, Aqualung, ogg123, Foobar. And now abcde :)
if [ -n "$DISCNUMBER" ]; then
echo DISCNUMBER="$DISCNUMBER"
fi
- echo CDDB=$CDDBDISCID
+ echo CDDB="${CDDBDISCID}"
if [ "$(eval echo ${COMMENT})" != "" ]; then
case "$COMMENTOUTPUT" in
*=*) echo "$COMMENTOUTPUT";;
*) echo COMMENT="$COMMENTOUTPUT";;
esac
fi
- ) | run_command tagtrack-$OUTPUT-$1 nice $ENCNICE \
+ ) | run_command "tagtrack-$OUTPUT-$1" nice $ENCNICE \
$VORBISCOMMENT $VORBISCOMMENTOPTS -w \
- "$ABCDETEMPDIR/track$1.uncommented.$OGGOUTPUTCONTAINER" "$ABCDETEMPDIR/track$1.$OGGOUTPUTCONTAINER"
+ "${ABCDETEMPDIR}/track$1.uncommented.$OGGOUTPUTCONTAINER" \
+ "${ABCDETEMPDIR}/track$1.$OGGOUTPUTCONTAINER"
# Doublecheck that the commented file was created
# successfully before wiping the original
- if [ -f "$ABCDETEMPDIR/track$1.$OGGOUTPUTCONTAINER" ]; then
- rm -f "$ABCDETEMPDIR/track$1.uncommented.$OGGOUTPUTCONTAINER"
+ if [ -f "${ABCDETEMPDIR}/track$1.$OGGOUTPUTCONTAINER" ]; then
+ rm -f "${ABCDETEMPDIR}/track$1.uncommented.$OGGOUTPUTCONTAINER"
else
- mv "$ABCDETEMPDIR/track$1.uncommented.$OGGOUTPUTCONTAINER" "$ABCDETEMPDIR/track$1.$OGGOUTPUTCONTAINER"
+ mv "${ABCDETEMPDIR}/track$1.uncommented.$OGGOUTPUTCONTAINER" \
+ "${ABCDETEMPDIR}/track$1.$OGGOUTPUTCONTAINER"
fi
;;
esac
;;
opus)
- run_command tagtrack-$OUTPUT-$1 true
+ run_command "tagtrack-$OUTPUT-$1" true
;;
mka)
- run_command tagtrack-$OUTPUT-$1 true
+ run_command "tagtrack-$OUTPUT-$1" true
+ ;;
+ aiff)
+ run_command "tagtrack-$OUTPUT-$1" true
;;
flac)
(
if [ -n "$DISCNUMBER" ]; then
echo DISCNUMBER="$DISCNUMBER"
fi
- echo CDDB="$CDDBDISCID"
- if [ "$(eval echo ${COMMENT})" != "" ]; then
+ echo CDDB="${CDDBDISCID}"
+ if [ -n "$(eval echo "${COMMENT}")" ]; then
case "$COMMENTOUTPUT" in
*=*) echo "$COMMENTOUTPUT";;
*) echo COMMENT="$COMMENTOUTPUT";;
esac
fi
- ) | run_command tagtrack-$OUTPUT-$1 nice $ENCNICE $METAFLAC $METAFLACOPTS ${IMPORTCUESHEET:+--import-cuesheet-from="$ABCDETEMPDIR/$CUEFILE"} \
- --import-tags-from=- "$ABCDETEMPDIR/track$1.$FLACOUTPUTCONTAINER"
+ ) | run_command "tagtrack-$OUTPUT-$1" nice $ENCNICE $METAFLAC $METAFLACOPTS \
+ ${IMPORTCUESHEET:+--import-cuesheet-from="${ABCDETEMPDIR}/$CUEFILE"} \
+ --import-tags-from=- "${ABCDETEMPDIR}/track$1.$FLACOUTPUTCONTAINER"
;;
spx)
- run_command tagtrack-$OUTPUT-$1 true
+ run_command "tagtrack-$OUTPUT-$1" true
;;
mpc)
- run_command tagtrack-$OUTPUT-$1 true
+ run_command "tagtrack-$OUTPUT-$1" true
;;
wv)
- run_command tagtrack-$OUTPUT-$1 true
+ run_command "tagtrack-$OUTPUT-$1" true
;;
ape)
# This tagging syntax is suitable for Robert Muth's application 'apetag', the Monkey's Audio
# Console port (mac) used for encoding does not have the ability to tag.
- run_command tagtrack-$OUTPUT-$1 nice $ENCNICE "$APETAG" -i "$ABCDETEMPDIR/track$1.ape" -m overwrite \
- -p artist="$TRACKARTIST" -p album="$DALBUM" -p title="$TRACKNAME" -p track=${TRACKNUM:-$1} \
- -p year="$CDYEAR" -p genre="$CDGENRE" ${COMMENTOUTPUT:+-p comment="$COMMENTOUTPUT"}
+ run_command "tagtrack-$OUTPUT-$1" nice $ENCNICE "$APETAG" -i "${ABCDETEMPDIR}/track$1.ape" -m overwrite \
+ -p artist="$TRACKARTIST" -p album="$DALBUM" -p title="$TRACKNAME" -p track="${TRACKNUM:-$1}" \
+ -p year="$CDYEAR" -p genre="$CDGENRE" ${COMMENTOUTPUT:+-p comment="$COMMENTOUTPUT"}
;;
mp2)
# Using Mutagen's mid3v2 for tagging with id3v2.4.0. Interesting enough vlc, MPlayer and XMMS ignore
# these tags but they are read by Audacious, Xine, Aqualung, mediainfo, ffplay, ffprobe. FFmpeg does
# not currently tag mp2 audio so twolame and FFmpeg will both use mid3v2...
- run_command tagtrack-$OUTPUT-$1 nice $ENCNICE "$MID3V2" --verbose -A "$DALBUM" -a "$TRACKARTIST" -t "$TRACKNAME" \
- -y "$CDYEAR" -g "$CDGENRE" -T "${TRACKNUM:-$1}/$TRACKS" ${TPE2:+--TPE2 "$TPE2"} ${COMMENTOUTPUT:+--comment="$COMMENTOUTPUT"} \
- "$ABCDETEMPDIR/track$1.mp2"
+ run_command "tagtrack-$OUTPUT-$1" nice $ENCNICE "$MID3V2" --verbose -A "$DALBUM" \
+ -a "$TRACKARTIST" -t "$TRACKNAME" -y "$CDYEAR" -g "$CDGENRE" \
+ -T "${TRACKNUM:-$1}/$TRACKS" ${TPE2:+--TPE2 "$TPE2"} \
+ ${COMMENTOUTPUT:+--comment="$COMMENTOUTPUT"} \
+ "${ABCDETEMPDIR}/track$1.mp2"
;;
aac)
- run_command tagtrack-$OUTPUT-$1 true
+ run_command "tagtrack-$OUTPUT-$1" true
;;
m4a)
case "$AACENCODERSYNTAX" in
fdkaac)
# We will use inline tagging...
- run_command tagtrack-$OUTPUT-$1 true
+ run_command "tagtrack-$OUTPUT-$1" true
;;
neroAacEnc)
# Tag post encode with neroAacTag...
- run_command tagtrack-$OUTPUT-$1 nice $ENCNICE "$NEROAACTAG" "$ABCDETEMPDIR/track$1.m4a" \
- -meta:artist="$TRACKARTIST" -meta:album="$DALBUM" -meta:title="$TRACKNAME" -meta:track=${TRACKNUM:-$1} \
- -meta:year="$CDYEAR" -meta:genre="$CDGENRE" -meta:comment="$COMMENT"
+ run_command "tagtrack-$OUTPUT-$1" nice $ENCNICE "$NEROAACTAG" \
+ "${ABCDETEMPDIR}/track$1.m4a" \
+ -meta:artist="$TRACKARTIST" -meta:album="$DALBUM" \
+ -meta:title="$TRACKNAME" -meta:track="${TRACKNUM:-$1}" \
+ -meta:year="$CDYEAR" -meta:genre="$CDGENRE" -meta:comment="$COMMENT"
;;
faac)
- run_command tagtrack-$OUTPUT-$1 true
+ run_command "tagtrack-$OUTPUT-$1" true
;;
qaac)
- run_command tagtrack-$OUTPUT-$1 true
+ run_command "tagtrack-$OUTPUT-$1" true
;;
fhgaacenc)
# Tag post encode with AtomicParsley. Note that previous problems with seg fault when using
# 'overWrite' cannot be reproduced with newer versions: https://bitbucket.org/wez/atomicparsley
- run_command tagtrack-$OUTPUT-$1 nice $ENCNICE "$ATOMICPARSLEY" "$ABCDETEMPDIR/track$1.m4a" \
- --artist="$TRACKARTIST" --album="$DALBUM" --title="$TRACKNAME" --tracknum=${TRACKNUM:-$1} \
- --year="$CDYEAR" --genre="$CDGENRE" --comment="$COMMENT" $ATOMICPARSLEYOPTS --overWrite
+ run_command "tagtrack-$OUTPUT-$1" nice $ENCNICE "$ATOMICPARSLEY" \
+ "${ABCDETEMPDIR}/track$1.m4a" --artist="$TRACKARTIST" --album="$DALBUM" \
+ --title="$TRACKNAME" --tracknum="${TRACKNUM:-$1}" \
+ --year="$CDYEAR" --genre="$CDGENRE" --comment="$COMMENT" \
+ $ATOMICPARSLEYOPTS --overWrite
;;
ffmpeg)
- run_command tagtrack-$OUTPUT-$1 true
+ run_command "tagtrack-$OUTPUT-$1" true
;;
esac
;;
tta)
# We use mid3v2 tagging for True Audio:
- run_command tagtrack-$OUTPUT-$1 nice $ENCNICE "$MID3V2" --verbose -A "$DALBUM" -a "$TRACKARTIST" -t "$TRACKNAME" \
- -y "$CDYEAR" -g "$CDGENRE" -T "${TRACKNUM:-$1}/$TRACKS" ${TPE2:+--TPE2 "$TPE2"} ${COMMENTOUTPUT:+--comment="$COMMENTOUTPUT"} \
- "$ABCDETEMPDIR/track$1.tta"
+ run_command "tagtrack-$OUTPUT-$1" nice $ENCNICE "$MID3V2" --verbose -A "$DALBUM" \
+ -a "$TRACKARTIST" -t "$TRACKNAME" -y "$CDYEAR" -g "$CDGENRE" \
+ -T "${TRACKNUM:-$1}/$TRACKS" ${TPE2:+--TPE2 "$TPE2"} \
+ ${COMMENTOUTPUT:+--comment="$COMMENTOUTPUT"} "${ABCDETEMPDIR}/track$1.tta"
;;
wav)
- run_command tagtrack-$OUTPUT-$1 true
+ run_command "tagtrack-$OUTPUT-$1" true
;;
esac
done
if checkerrors "tagtrack-(.{3,6})-$1"; then :; else
- run_command tagtrack-$1 true
+ run_command "tagtrack-$1" true
fi
}
# The commands here don't go through run_command because they're never
# supposed to be silenced
echo "Encoding gapless MP3 tracks: $TRACKQUEUE"
- for OUTPUT in $(echo $OUTPUTTYPE | tr , \ )
+ for OUTPUT in $(echo "$OUTPUTTYPE" | tr , \ )
do
case "$OUTPUT" in
mp3)
case "$MP3ENCODERSYNTAX" in
lame)
(
- cd "$ABCDETEMPDIR"
- TRACKFILES=
- for UTRACKNUM in $TRACKQUEUE
- do
- TRACKFILES="$TRACKFILES track$UTRACKNUM.wav"
- done
- nice $ENCNICE $MP3ENCODER $MP3ENCODEROPTS --nogap $TRACKFILES
- RETURN=$?
- if [ "$RETURN" != "0" ]; then
- echo "nogap-encode: $ENCODER returned code $RETURN" >> "$ABCDETEMPDIR/errors"
- else
- for UTRACKNUM in $TRACKQUEUE
+ cd "${ABCDETEMPDIR}"
+ TRACKFILES=
+ for THISTRACKNUM in $TRACKQUEUE
do
- run_command encodetrack-$OUTPUT-$UTRACKNUM true
- #run_command encodetrack-$UTRACKNUM true
+ TRACKFILES="$TRACKFILES track$THISTRACKNUM.wav"
done
- fi
+ nice $ENCNICE $MP3ENCODER $MP3ENCODEROPTS --nogap $TRACKFILES
+ RETURN=$?
+ if [ "$RETURN" != "0" ]; then
+ echo "nogap-encode: $MP3ENCODER returned code $RETURN" >> "${ABCDETEMPDIR}/errors"
+ else
+ for THISTRACKNUM in $TRACKQUEUE
+ do
+ run_command "encodetrack-$OUTPUT-$THISTRACKNUM" true
+ done
+ fi
)
;;
esac
mka)
TEMPARG="PIPE_$MKAENCODERSYNTAX"
;;
+ aiff)
+ TEMPARG="PIPE_$AIFFENCODERSYNTAX"
+ ;;
flac)
TEMPARG="PIPE_$FLACENCODERSYNTAX"
;;
esac
IN="$( eval echo "\$$TEMPARG" )"
else
- IN="$ABCDETEMPDIR/track$1.wav"
+ IN="${ABCDETEMPDIR}/track$1.wav"
fi
# We need IN to proceed, if we are not using pipes.
- if [ -s "$IN" -o X"$USEPIPES" = "Xy" ] ; then
- for TMPOUTPUT in $(echo $OUTPUTTYPE | tr , \ )
+ if [ -s "$IN" ] || [ X"$USEPIPES" = "Xy" ] ; then
+ for TMPOUTPUT in $(echo "$OUTPUTTYPE" | tr , \ )
do
case "$TMPOUTPUT" in
vorbis|ogg)
mka)
OUTPUT=$MKAOUTPUTCONTAINER
;;
+ aiff)
+ OUTPUT=$AIFFOUTPUTCONTAINER
+ ;;
flac)
OUTPUT=$FLACOUTPUTCONTAINER
;;
OUTPUT=$TMPOUTPUT
;;
esac
- OUT="$ABCDETEMPDIR/track$1.$OUTPUT"
- if [ "$NOGAP" = "y" ] && checkstatus encodetrack-$OUTPUT-$1 ; then
+ OUT="${ABCDETEMPDIR}/track$1.$OUTPUT"
+ if [ "$NOGAP" = "y" ] && checkstatus "encodetrack-$OUTPUT-$1" ; then
continue
fi
if [ X"$USEPIPES" = "Xy" ]; then
# bit the reading process.
EFFECTIVE_NICE=$READNICE
else
- run_command '' echo "Encoding track $1 of $TRACKS: $TRACKNAME..."
+ run_command "" echo "Encoding track $1 of $TRACKS: $TRACKNAME..."
RUN_COMMAND="run_command encodetrack-$OUTPUT-$1"
EFFECTIVE_NICE=$ENCNICE
fi
opusenc)
# Tag the file at encode time, as it can't be done after encoding.
if [ "$DOTAG" = "y" ]; then
- $RUN_COMMAND nice $EFFECTIVE_NICE $OPUSENCODER $OPUSENCODEROPTS --artist "$TRACKARTIST" \
- --album "$DALBUM" --title "$TRACKNAME" --genre "$CDGENRE" --date "$CDYEAR" --comment TRACKNUMBER="$1" \
- ${COMMENT:+--comment COMMENT="$COMMENT"} "$IN" "$OUT"
+ $RUN_COMMAND nice $EFFECTIVE_NICE $OPUSENCODER $OPUSENCODEROPTS \
+ --artist "$TRACKARTIST" --album "$DALBUM" --title "$TRACKNAME" \
+ --genre "$CDGENRE" --date "$CDYEAR" --comment TRACKNUMBER="$1" \
+ ${COMMENT:+--comment COMMENT="$COMMENT"} "$IN" "$OUT"
else
$RUN_COMMAND nice $EFFECTIVE_NICE $OPUSENCODER $OPUSENCODEROPTS "$IN" "$OUT"
fi
case "$MKAENCODERSYNTAX" in
ffmpeg)
if [ "$DOTAG" = "y" ]; then
- $RUN_COMMAND nice $EFFECTIVE_NICE $MKAENCODER -i "$IN" $MKAENCODEROPTS -metadata artist="$TRACKARTIST" \
- -metadata album="$DALBUM" -metadata title="$TRACKNAME" -metadata track=${TRACKNUM:-$1} -metadata date="$CDYEAR" \
- -metadata genre="$CDGENRE" -metadata comment="$COMMENT" "$OUT"
+ $RUN_COMMAND nice $EFFECTIVE_NICE $MKAENCODER -i "$IN" $MKAENCODEROPTS \
+ -metadata artist="$TRACKARTIST" -metadata album="$DALBUM" \
+ -metadata title="$TRACKNAME" -metadata track="${TRACKNUM:-$1}" \
+ -metadata date="$CDYEAR" -metadata genre="$CDGENRE" \
+ -metadata comment="$COMMENT" "$OUT"
else
$RUN_COMMAND nice $EFFECTIVE_NICE $MKAENCODER -i "$IN" $MKAENCODEROPTS "$OUT"
fi
;;
esac
;;
+ aiff)
+ case "$AIFFENCODERSYNTAX" in
+ ffmpeg)
+ if [ "$DOTAG" = "y" ]; then
+ $RUN_COMMAND nice $EFFECTIVE_NICE $AIFFENCODER -i "$IN" $AIFFENCODEROPTS \
+ -metadata artist="$TRACKARTIST" -metadata album="$DALBUM" \
+ -metadata title="$TRACKNAME" -metadata track="${TRACKNUM:-$1}" \
+ -metadata date="$CDYEAR" -metadata genre="$CDGENRE" \
+ -metadata comment="$COMMENT" "$OUT"
+ else
+ $RUN_COMMAND nice $EFFECTIVE_NICE $AIFFENCODER -i "$IN" $AIFFENCODEROPTS "$OUT"
+ fi
+ ;;
+ esac
+ ;;
flac)
case "$2" in
%local*%)
esac
;;
spx)
- if [ "$(eval echo ${COMMENT})" != "" ]; then
+ if [ -n "$(eval echo "${COMMENT}")" ]; then
case "$COMMENT" in
*=*) ;;
*) COMMENT="COMMENT=$COMMENT" ;;
fi
# Tag the file at encode time, as it can't be done after encoding.
if [ "$DOTAG" = "y" ]; then
- $RUN_COMMAND nice $EFFECTIVE_NICE $SPEEXENCODER $SPEEXENCODEROPTS --author "$TRACKARTIST" --title "$TRACKNAME" \
- ${COMMENT:+--comment "$COMMENT"} "$IN" "$OUT"
+ $RUN_COMMAND nice $EFFECTIVE_NICE $SPEEXENCODER $SPEEXENCODEROPTS \
+ --author "$TRACKARTIST" --title "$TRACKNAME" \
+ ${COMMENT:+--comment "$COMMENT"} "$IN" "$OUT"
else
$RUN_COMMAND nice $EFFECTIVE_NICE $SPEEXENCODER $SPEEXENCODEROPTS "$IN" "$OUT"
fi
mpc)
# Tag the file inline at encode time.
if [ "$DOTAG" = "y" ]; then
- $RUN_COMMAND nice $EFFECTIVE_NICE $MPCENCODER $MPCENCODEROPTS --artist "$TRACKARTIST" --album "$DALBUM" \
- --title "$TRACKNAME" --track "$1" --genre "$CDGENRE" --year "$CDYEAR" ${COMMENT:+--comment "$COMMENT"} "$IN" "$OUT"
+ $RUN_COMMAND nice $EFFECTIVE_NICE $MPCENCODER $MPCENCODEROPTS \
+ --artist "$TRACKARTIST" --album "$DALBUM" \
+ --title "$TRACKNAME" --track "$1" --genre "$CDGENRE" \
+ --year "$CDYEAR" ${COMMENT:+--comment "$COMMENT"} "$IN" "$OUT"
else
$RUN_COMMAND nice $EFFECTIVE_NICE $MPCENCODER $MPCENCODEROPTS "$IN" "$OUT"
fi
case "$WVENCODERSYNTAX" in
wavpack)
if [ "$DOTAG" = "y" ]; then
- $RUN_COMMAND nice $EFFECTIVE_NICE $WVENCODER $WVENCODEROPTS -w Artist="$TRACKARTIST" -w Album="$DALBUM" \
- -w Title="$TRACKNAME" -w Track="$1" -w Genre="$CDGENRE" -w Year="$CDYEAR" ${COMMENT:+-w Comment="$COMMENT"} "$IN" -o "$OUT"
+ $RUN_COMMAND nice $EFFECTIVE_NICE $WVENCODER $WVENCODEROPTS \
+ -w Artist="$TRACKARTIST" -w Album="$DALBUM" \
+ -w Title="$TRACKNAME" -w Track="$1" -w Genre="$CDGENRE" \
+ -w Year="$CDYEAR" ${COMMENT:+-w Comment="$COMMENT"} "$IN" -o "$OUT"
else
$RUN_COMMAND nice $EFFECTIVE_NICE $WVENCODER $WVENCODEROPTS "$IN" -o "$OUT"
fi
;;
ffmpeg)
if [ "$DOTAG" = "y" ]; then
- $RUN_COMMAND nice $EFFECTIVE_NICE $WVENCODER -i "$IN" $WVENCODEROPTS -metadata artist="$TRACKARTIST" \
- -metadata album="$DALBUM" -metadata title="$TRACKNAME" -metadata track=${TRACKNUM:-$1} -metadata date="$CDYEAR" \
- -metadata genre="$CDGENRE" -metadata comment="$COMMENT" "$OUT"
+ $RUN_COMMAND nice $EFFECTIVE_NICE $WVENCODER -i "$IN" $WVENCODEROPTS \
+ -metadata artist="$TRACKARTIST" \
+ -metadata album="$DALBUM" -metadata title="$TRACKNAME" \
+ -metadata track="${TRACKNUM:-$1}" -metadata date="$CDYEAR" \
+ -metadata genre="$CDGENRE" -metadata comment="$COMMENT" "$OUT"
else
$RUN_COMMAND nice $EFFECTIVE_NICE $WVENCODER -i "$IN" $WVENCODEROPTS "$OUT"
fi
mp2)
case "$MP2ENCODERSYNTAX" in
twolame)
- $RUN_COMMAND nice $EFFECTIVE_NICE $MP2ENCODER $MP2ENCODEROPTS "$IN" "$OUT"
- ;;
+ $RUN_COMMAND nice $EFFECTIVE_NICE $MP2ENCODER $MP2ENCODEROPTS "$IN" "$OUT"
+ ;;
ffmpeg)
- $RUN_COMMAND nice $EFFECTIVE_NICE $MP2ENCODER -i "$IN" $MP2ENCODEROPTS "$OUT"
- ;;
+ $RUN_COMMAND nice $EFFECTIVE_NICE $MP2ENCODER -i "$IN" $MP2ENCODEROPTS "$OUT"
+ ;;
esac
;;
aac)
case "$AACENCODERSYNTAX" in
faac)
if [ "$DOTAG" = "y" ]; then
- $RUN_COMMAND nice $EFFECTIVE_NICE $AACENCODER $AACENCODEROPTS --artist "$TRACKARTIST" --album "$DALBUM" \
- --title "$TRACKNAME" --track ${TRACKNUM:-$1} --year "$CDYEAR" --genre "$CDGENRE" --comment "$COMMENT" -o "$OUT" "$IN"
+ $RUN_COMMAND nice $EFFECTIVE_NICE $AACENCODER $AACENCODEROPTS \
+ --artist "$TRACKARTIST" --album "$DALBUM" \
+ --title "$TRACKNAME" --track "${TRACKNUM:-$1}" \
+ --year "$CDYEAR" --genre "$CDGENRE" --comment "$COMMENT" -o "$OUT" "$IN"
else
$RUN_COMMAND nice $EFFECTIVE_NICE $AACENCODER $AACENCODEROPTS -o "$OUT" "$IN"
fi
;;
fdkaac)
if [ "$DOTAG" = "y" ]; then
- $RUN_COMMAND nice $EFFECTIVE_NICE $AACENCODER $AACENCODEROPTS --artist "$TRACKARTIST" --album "$DALBUM" \
- --title "$TRACKNAME" --track "$1" --genre "$CDGENRE" --date "$CDYEAR" --comment "$COMMENT" "$IN" -o "$OUT"
+ $RUN_COMMAND nice $EFFECTIVE_NICE $AACENCODER $AACENCODEROPTS \
+ --artist "$TRACKARTIST" --album "$DALBUM" \
+ --title "$TRACKNAME" --track "$1" --genre "$CDGENRE" \
+ --date "$CDYEAR" --comment "$COMMENT" "$IN" -o "$OUT"
else
$RUN_COMMAND nice $EFFECTIVE_NICE $AACENCODER $AACENCODEROPTS "$IN" -o "$OUT"
fi
;;
qaac)
if [ "$DOTAG" = "y" ]; then
- $RUN_COMMAND nice $EFFECTIVE_NICE $WINE $AACENCODER $AACENCODEROPTS --artist "$TRACKARTIST" --album "$DALBUM" \
- --title "$TRACKNAME" --track ${TRACKNUM:-$1} --date "$CDYEAR" --genre "$CDGENRE" --comment "$COMMENT" -o "$OUT" "$IN"
+ $RUN_COMMAND nice $EFFECTIVE_NICE $WINE $AACENCODER $AACENCODEROPTS \
+ --artist "$TRACKARTIST" --album "$DALBUM" \
+ --title "$TRACKNAME" --track "${TRACKNUM:-$1}" \
+ --date "$CDYEAR" --genre "$CDGENRE" --comment "$COMMENT" -o "$OUT" "$IN"
else
$RUN_COMMAND nice $EFFECTIVE_NICE $WINE $AACENCODER $AACENCODEROPTS -o "$OUT" "$IN"
fi
;;
ffmpeg)
if [ "$DOTAG" = "y" ]; then
- $RUN_COMMAND nice $EFFECTIVE_NICE $AACENCODER -i "$IN" $AACENCODEROPTS -metadata artist="$TRACKARTIST" \
- -metadata album="$DALBUM" -metadata title="$TRACKNAME" -metadata track=${TRACKNUM:-$1} -metadata date="$CDYEAR" \
- -metadata genre="$CDGENRE" -metadata comment="$COMMENT" "$OUT"
+ $RUN_COMMAND nice $EFFECTIVE_NICE $AACENCODER -i "$IN" \
+ $AACENCODEROPTS -metadata artist="$TRACKARTIST" \
+ -metadata album="$DALBUM" -metadata title="$TRACKNAME" \
+ -metadata track="${TRACKNUM:-$1}" -metadata date="$CDYEAR" \
+ -metadata genre="$CDGENRE" -metadata comment="$COMMENT" "$OUT"
else
$RUN_COMMAND nice $EFFECTIVE_NICE $AACENCODER -i "$IN" $AACENCODEROPTS "$OUT"
fi
wav)
# In case of wav output we need nothing. Just keep the wavs.
# But we need the following to allow full logging and subsequent
- # successful cleaning of $ABCDETEMPDIR.
- echo "encodetrack-$OUTPUT-$UTRACKNUM" >> "$ABCDETEMPDIR/status"
+ # successful cleaning of ${ABCDETEMPDIR}.
+ echo "encodetrack-$OUTPUT-$UTRACKNUM" >> "${ABCDETEMPDIR}/status"
;;
esac
$RUN_COMMAND_PIPES
done
# Only remove .wav if the encoding succeeded
if checkerrors "encodetrack-(.{3,6})-$1"; then :; else
- run_command encodetrack-$1 true
+ run_command "encodetrack-$1" true
if [ ! "$KEEPWAVS" = "y" ] ; then
if [ ! "$KEEPWAVS" = "move" ] ; then
rm -f "$IN"
else
run_command "" echo "HEH! The file we were about to encode disappeared:"
run_command "" echo ">> $IN"
- run_command encodetrack-$1 false
+ run_command "encodetrack-$1" false
fi
}
# do_preprocess [tracknumber]
# variables used:
-# TRACKS, TRACKNAME, TRACKARTIST, DISTMP3, DISTMP3OPTS, {FOO}ENCODERSYNTAX, OUTPUTTYPE, ENCODEROPTS, DALBUM, DARTIST, ENCNICE, CDYEAR, CDGENRE, COMMENT
+# TRACKS, TRACKNAME, TRACKARTIST, DISTMP3, DISTMP3OPTS, {FOO}ENCODERSYNTAX,
+# OUTPUTTYPE, ENCODEROPTS, DALBUM, DARTIST, ENCNICE, CDYEAR, CDGENRE, COMMENT
#do_preprocess ()
#{
-# IN="$ABCDETEMPDIR/track$1.wav"
+# IN="${ABCDETEMPDIR}/track$1.wav"
# # We need IN to proceed.
# if [ -s "$IN" ] ; then
# for OUTPUT in $(echo $OUTPUTTYPE | tr , \ )
# do
-# #OUT="$ABCDETEMPDIR/track$1.$OUTPUT"
-# run_command '' echo "Pre-processing track $1 of $TRACKS..."
+# #OUT="${ABCDETEMPDIR}/track$1.$OUTPUT"
+# run_command "" echo "Pre-processing track $1 of $TRACKS..."
# case "$POSTPROCESSFORMAT" in
# all|wav*)
-# run_command preprocess-$OUTPUT-$1 nice $PRENICE $WAV_PRE $IF $OF ;;
+# run_command "preprocess-$OUTPUT-$1" nice $PRENICE $WAV_PRE $IF $OF ;;
# mp3)
-# run_command preprocess-$OUTPUT-$1 nice $PRENICE $MP3_PRE $IF $OF ;;
+# run_command "preprocess-$OUTPUT-$1" nice $PRENICE $MP3_PRE $IF $OF ;;
# ogg)
-# run_command preprocess-$OUTPUT-$1 nice $PRENICE $OGG_PRE $IF $OF ;;
+# run_command "preprocess-$OUTPUT-$1" nice $PRENICE $OGG_PRE $IF $OF ;;
# flac)
-# run_command preprocess-$OUTPUT-$1 nice $PRENICE $FLAC_PRE $IF $OF ;;
+# run_command "preprocess-$OUTPUT-$1" nice $PRENICE $FLAC_PRE $IF $OF ;;
# spx)
-# run_command preprocess-$OUTPUT-$1 nice $PRENICE $SPX_PRE $IF $OF ;;
+# run_command "preprocess-$OUTPUT-$1" nice $PRENICE $SPX_PRE $IF $OF ;;
# esac
# done
# # Only remove .wav if the encoding succeeded
# if checkerrors "preprocess-(.{3,4})-$1"; then
-# run_command preprocess-$1 false
+# run_command "preprocess-$1" false
# else
-# run_command preprocess-$1 true
+# run_command "preprocess-$1" true
# fi
# else
# if [ "$(checkstatus encode-output)" = "loud" ]; then
# echo "HEH! The file we were about to pre-process disappeared:"
# echo ">> $IN"
# fi
-# run_command preprocess-$1 false
+# run_command "preprocess-$1" false
# fi
#}
# do_postprocess [tracknumber]
# variables used:
-# TRACKS, TRACKNAME, TRACKARTIST, DISTMP3, DISTMP3OPTS, {FOO}ENCODERSYNTAX, OUTPUTTYPE, ENCODEROPTS, DALBUM, DARTIST, ENCNICE, CDYEAR, CDGENRE, COMMENT
+# TRACKS, TRACKNAME, TRACKARTIST, DISTMP3, DISTMP3OPTS, {FOO}ENCODERSYNTAX, OUTPUTTYPE, ENCODEROPTS,
+# DALBUM, DARTIST, ENCNICE, CDYEAR, CDGENRE, COMMENT
#do_postprocess ()
#{
# for POSTPROCESSFORMAT in $(echo $POSTPROCESSFORMATS | tr , \ )
# do
-# IN="$ABCDETEMPDIR/track$1.$POSTPROCESSFORMAT"
+# IN="${ABCDETEMPDIR}/track$1.$POSTPROCESSFORMAT"
# # We need IN to proceed.
# if [ -s "$IN" ] ; then
-# #OUT="$ABCDETEMPDIR/track$1.$OUTPUT"
-# run_command '' echo "Post-processing track $1 of $TRACKS..."
+# #OUT="${ABCDETEMPDIR}/track$1.$OUTPUT"
+# run_command "" echo "Post-processing track $1 of $TRACKS..."
# case "$POSTPROCESSFORMAT" in
# mp3)
-# run_command postprocess-$OUTPUT-$1 nice $POSTNICE $MP3_POST $IF $OF ;;
+# run_command "postprocess-$OUTPUT-$1" nice $POSTNICE $MP3_POST $IF $OF ;;
# ogg)
-# run_command postprocess-$OUTPUT-$1 nice $POSTNICE $OGG_POST $IF $OF ;;
+# run_command "postprocess-$OUTPUT-$1" nice $POSTNICE $OGG_POST $IF $OF ;;
# flac)
-# run_command postprocess-$OUTPUT-$1 nice $POSTNICE $FLAC_POST $IF $OF ;;
+# run_command "postprocess-$OUTPUT-$1" nice $POSTNICE $FLAC_POST $IF $OF ;;
# spx)
-# run_command postprocess-$OUTPUT-$1 nice $POSTNICE $SPX_POST $IF $OF ;;
+# run_command "postprocess-$OUTPUT-$1" nice $POSTNICE $SPX_POST $IF $OF ;;
# esac
# # Only remove .wav if the encoding succeeded
# if checkerrors "postprocess-(.{3,4})-$1"; then
-# run_command postprocess-$1 false
+# run_command "postprocess-$1" false
# else
-# run_command postprocess-$1 true
+# run_command "postprocess-$1" true
# fi
# else
# if [ "$(checkstatus encode-output)" = "loud" ]; then
# echo "HEH! The file we were about to post-process disappeared:"
# echo ">> $IN"
# fi
-# run_command postprocess-$1 false
+# run_command "postprocess-$1" false
# fi
# done
#}
# The commands here don't go through run_command because they're never supposed to be silenced
echo "Batch analizing gain in tracks: $TRACKQUEUE"
(
- cd "$ABCDETEMPDIR"
+ cd "${ABCDETEMPDIR}"
BLURB=
TRACKFILES=
for UTRACKNUM in $TRACKQUEUE
do
- MP3FILES="$TRACKFILES track$UTRACKNUM.mp3"
+ TRACKFILES="$TRACKFILES track$UTRACKNUM.mp3"
done
# FIXME # Hard-coded batch option!
$NORMALIZER -b $NORMALIZEROPTS $TRACKFILES
RETURN=$?
if [ "$RETURN" != "0" ]; then
- echo "batch-normalize: $NORMALIZER returned code $RETURN" >> "$ABCDETEMPDIR/errors"
+ echo "batch-normalize: $NORMALIZER returned code $RETURN" >> "${ABCDETEMPDIR}/errors"
else
for UTRACKNUM in $TRACKQUEUE
do
- echo "normalizetrack-$UTRACKNUM" >> "$ABCDETEMPDIR/status"
+ echo "normalizetrack-$UTRACKNUM" >> "${ABCDETEMPDIR}/status"
done
fi
)
# The commands here don't go through run_command because they're never supposed to be silenced
echo "Batch normalizing tracks: $TRACKQUEUE"
(
- cd "$ABCDETEMPDIR"
+ cd "${ABCDETEMPDIR}"
BLURB=
TRACKFILES=
for UTRACKNUM in $TRACKQUEUE
$NORMALIZER -b $NORMALIZEROPTS $TRACKFILES
RETURN=$?
if [ "$RETURN" != "0" ]; then
- echo "batch-normalize: $NORMALIZER returned code $RETURN" >> "$ABCDETEMPDIR/errors"
+ echo "batch-normalize: $NORMALIZER returned code $RETURN" >> "${ABCDETEMPDIR}/errors"
else
for UTRACKNUM in $TRACKQUEUE
do
- echo "normalizetrack-$UTRACKNUM" >> "$ABCDETEMPDIR/status"
+ echo "normalizetrack-$UTRACKNUM" >> "${ABCDETEMPDIR}/status"
done
fi
)
# TRACKS, TRACKNAME, NORMALIZER, NORMALIZEROPTS
do_normalize ()
{
- IN="$ABCDETEMPDIR/track$1.wav"
+ IN="${ABCDETEMPDIR}/track$1.wav"
if [ -e "$IN" ] ; then
- run_command '' echo "Normalizing track $1 of $TRACKS: $TRACKNAME..."
- run_command normalizetrack-$1 $NORMALIZER $NORMALIZEROPTS "$IN"
+ run_command "" echo "Normalizing track $1 of $TRACKS: $TRACKNAME..."
+ run_command "normalizetrack-$1" $NORMALIZER $NORMALIZEROPTS "$IN"
else
if [ "$(checkstatus encode-output)" = "loud" ]; then
echo "HEH! The file we were about to normalize disappeared:"
echo ">> $IN"
fi
- run_command normalizetrack-$1 false "File $IN was not found"
+ run_command "normalizetrack-$1" false "File $IN was not found"
fi
}
# TRACKNUM, TRACKNAME, TRACKARTIST, DALBUM, OUTPUTFORMAT, CDGENRE, CDYEAR
do_move ()
{
- for TMPOUTPUT in $(echo $OUTPUTTYPE | tr , \ )
+ for TMPOUTPUT in $(echo "$OUTPUTTYPE" | tr , \ )
do
# For now, set OUTPUT as TMPOUTPUT, and then change it once we have
# defined the OUTPUTFILE:
mka)
OUTPUT=$MKAOUTPUTCONTAINER
;;
+ aiff)
+ OUTPUT=$AIFFOUTPUTCONTAINER
+ ;;
flac)
OUTPUT=$FLACOUTPUTCONTAINER
;;
else
# mkdir -p shouldn't return an error if the directory already exists
mkdir -p "$OUTPUTFILEDIR"
- run_command movetrack-$1 mv "$ABCDETEMPDIR/track$1.$OUTPUT" "$OUTPUTDIR/$OUTPUTFILE.$OUTPUT"
- if checkstatus movetrack-output-$OUTPUT; then :; else
- run_command movetrack-output-$OUTPUT true
+ run_command "movetrack-$1" mv "${ABCDETEMPDIR}/track$1.$OUTPUT" "$OUTPUTDIR/$OUTPUTFILE.$OUTPUT"
+ if checkstatus "movetrack-output-$OUTPUT"; then :; else
+ run_command "movetrack-output-$OUTPUT" true
fi
fi
;;
*)
# mkdir -p shouldn't return an error if the directory already exists
mkdir -p "$OUTPUTFILEDIR"
- run_command movetrack-$1 mv "$ABCDETEMPDIR/track$1.$OUTPUT" "$OUTPUTDIR/$OUTPUTFILE.$OUTPUT"
- if checkstatus movetrack-output-$OUTPUT; then :; else
- run_command movetrack-output-$OUTPUT true
+ run_command "movetrack-$1" mv "${ABCDETEMPDIR}/track$1.$OUTPUT" "$OUTPUTDIR/$OUTPUTFILE.$OUTPUT"
+ if checkstatus "movetrack-output-$OUTPUT"; then :; else
+ run_command "movetrack-output-$OUTPUT" true
fi
;;
esac
# Lets move the cue file
if CUEFILE=$(checkstatus cuefile) >/dev/null ; then
- if [ -r "$ABCDETEMPDIR/$CUEFILE" ]; then
- if checkstatus movecue-$OUTPUT; then :; else
+ if [ -r "${ABCDETEMPDIR}/$CUEFILE" ]; then
+ if checkstatus "movecue-$OUTPUT"; then :; else
# Silence the Copying output since it overlaps with encoding processes...
- #run_command '' vecho "Copying cue file to its destination directory..."
+ #run_command "" vecho "Copying cue file to its destination directory..."
if checkstatus onetrack >/dev/null ; then
case $OUTPUT in
wav)
# We dont have the dir, since it was not created before.
:
else
- run_command movecue-$OUTPUT cp "$ABCDETEMPDIR/$CUEFILE" "$OUTPUTDIR/$OUTPUTFILE.cue"
+ run_command "movecue-$OUTPUT" cp "${ABCDETEMPDIR}/$CUEFILE" "$OUTPUTDIR/$OUTPUTFILE.cue"
fi
;;
# NOTE: Creating a cue file with the 3-char-extension files is to comply with
# http://brianvictor.tripod.com/mp3cue.htm#details
[a-z0-9][a-z0-9][a-z0-9])
- run_command movecue-$OUTPUT cp "$ABCDETEMPDIR/$CUEFILE" "$OUTPUTDIR/$OUTPUTFILE.cue"
+ run_command "movecue-$OUTPUT" cp "${ABCDETEMPDIR}/$CUEFILE" "$OUTPUTDIR/$OUTPUTFILE.cue"
;;
*)
- run_command movecue-$OUTPUT cp "$ABCDETEMPDIR/$CUEFILE" "$OUTPUTDIR/$OUTPUTFILE.$OUTPUT.cue"
+ run_command "movecue-$OUTPUT" cp "${ABCDETEMPDIR}/$CUEFILE" "$OUTPUTDIR/$OUTPUTFILE.$OUTPUT.cue"
;;
esac
else
- run_command movecue-$OUTPUT cp "$ABCDETEMPDIR/$CUEFILE" "$OUTPUTFILEDIR/$CUEFILE"
+ run_command "movecue-$OUTPUT" cp "${ABCDETEMPDIR}/$CUEFILE" "$OUTPUTFILEDIR/$CUEFILE"
fi
- echo movecue-$OUTPUT >> "$ABCDETEMPDIR/status"
+ echo "movecue-$OUTPUT" >> "${ABCDETEMPDIR}/status"
fi
fi
fi
# VARIOUSARTISTS, OUTPUTDIR
do_playlist ()
{
- for TMPOUTPUT in $(echo $OUTPUTTYPE | tr , \ )
+ for TMPOUTPUT in $(echo "$OUTPUTTYPE" | tr , \ )
do
case $TMPOUTPUT in
vorbis|ogg)
mka)
OUTPUT=$MKAOUTPUTCONTAINER
;;
+ aiff)
+ OUTPUT=$AIFFOUTPUTCONTAINER
+ ;;
flac)
OUTPUT=$FLACOUTPUTCONTAINER
;;
ERASEPLAYLIST=e
fi
# Once we erase the playlist, we use append to create the new one.
- [ "$ERASEPLAYLIST" = "e" -o "$ERASEPLAYLIST" = "E" ] && rm -f "$OUTPUTDIR/$PLAYLISTFILE" && ERASEPLAYLIST=a
+ [ "$ERASEPLAYLIST" = "e" ] || [ "$ERASEPLAYLIST" = "E" ] && rm -f "$OUTPUTDIR/$PLAYLISTFILE" && ERASEPLAYLIST=a
else
# The playlist does not exist, so we can safelly use append to create the new list
ERASEPLAYLIST=a
fi
- if [ "$ERASEPLAYLIST" = "a" -o "$ERASEPLAYLIST" = "A" ]; then
+ if [ "$ERASEPLAYLIST" = "a" ] || [ "$ERASEPLAYLIST" = "A" ]; then
touch "$OUTPUTDIR/$PLAYLISTFILE"
for UTRACKNUM in $TRACKQUEUE
do
# Shares some code with do_move since the filenames have to match
- CDDBTRACKNUM=$(expr $UTRACKNUM - 1)
+ CDDBTRACKNUM=$(expr $UTRACKNUM - 1) # Unpad
getcddbinfo TRACKNAME
splitvarious
TRACKFILE="$(mungetrackname "$TRACKNAME")"
fi
if [ "$VARIOUSARTISTS" = "y" ]; then
if [ "$VAPLAYLISTDATAPREFIX" ] ; then
- echo ${VAPLAYLISTDATAPREFIX}$OUTPUTFILE.$OUTPUT >> "$OUTPUTDIR/$PLAYLISTFILE"
+ echo "${VAPLAYLISTDATAPREFIX}$OUTPUTFILE.$OUTPUT" >> "$OUTPUTDIR/$PLAYLISTFILE"
else
relpath "$PLAYLISTFILE", "$OUTPUTFILE.$OUTPUT" >> "$OUTPUTDIR/$PLAYLISTFILE"
fi
else
if [ "$PLAYLISTDATAPREFIX" ]; then
- echo ${PLAYLISTDATAPREFIX}$OUTPUTFILE.$OUTPUT >> "$OUTPUTDIR/$PLAYLISTFILE"
+ echo "${PLAYLISTDATAPREFIX}$OUTPUTFILE.$OUTPUT" >> "$OUTPUTDIR/$PLAYLISTFILE"
else
relpath "$PLAYLISTFILE", "$OUTPUTFILE.$OUTPUT" >> "$OUTPUTDIR/$PLAYLISTFILE"
fi
## this will convert the playlist to have CRLF line-endings, if specified
## (some hardware players insist on CRLF endings)
if [ "$DOSPLAYLIST" = "y" ]; then
- awk '{sub("\r$",""); printf "%s\r\n", $0}' "$OUTPUTDIR/$PLAYLISTFILE" > "$ABCDETEMPDIR/PLAYLISTFILE.tmp"
-# mv -f "$ABCDETEMPDIR/PLAYLISTFILE.tmp" "$OUTPUTDIR/$PLAYLISTFILE"
- cat "$ABCDETEMPDIR/PLAYLISTFILE.tmp" | sed 's/\//\\/' > "$OUTPUTDIR/$PLAYLISTFILE"
+ awk '{sub("\r$",""); printf "%s\r\n", $0}' "$OUTPUTDIR/$PLAYLISTFILE" > "${ABCDETEMPDIR}/PLAYLISTFILE.tmp"
+# mv -f "${ABCDETEMPDIR}/PLAYLISTFILE.tmp" "$OUTPUTDIR/$PLAYLISTFILE"
+ cat "${ABCDETEMPDIR}/PLAYLISTFILE.tmp" | sed 's/\//\\/' > "$OUTPUTDIR/$PLAYLISTFILE"
fi
- echo "playlistcomplete" >> "$ABCDETEMPDIR/status"
+ echo "playlistcomplete" >> "${ABCDETEMPDIR}/status"
done
}
cddb_sum () {
val=$1
ret=0
- while [ $val -gt 0 ] ; do
- ret=$(( $ret + ( $val % 10) ))
- val=$(( $val / 10 ))
+ while [ "$val" -gt 0 ] ; do
+ ret=$(( "$ret" + ( "$val" % 10) ))
+ val=$(( "$val" / 10 ))
done
- echo $ret
+ echo "$ret"
}
msf2lba () {
OIFS="$IFS"
IFS=":"
- set -- $1
+ set -- "$1"
IFS="$OIFS"
local first second third
- first=$(expr ${1} + 0 )
- second=$(expr ${2} + 0 )
- third=$(expr ${3} + 0 )
+ first=$(( $1 + 0 ))
+ second=$(( $2 + 0 ))
+ third=$(( $3 + 0 ))
- echo $(( ((($first * 60) + $second) * 75) + $third ))
+ echo $(( ((("$first" * 60) + "$second") * 75) + "$third" ))
}
OFFSET=150
N=0
while read line ; do
- set -- $line
+ set -- "$line"
case "$1" in
TRACK) i=$(( i + 1 ))
;;
INDEX) if [ "$2" -eq 1 ] ; then
- LBA=$(msf2lba $3)
- START=$(( $LBA + $PREGAP + $OFFSET ))
+ LBA=$(msf2lba "$3")
+ START=$(( "$LBA" + "$PREGAP" + "$OFFSET" ))
eval TRACK$i=$START
- X=$(cddb_sum $(( $START / 75 )) )
- N=$(( $N + $X ))
+ X=$(cddb_sum $(( "$START" / 75 )) )
+ N=$(( "$N" + "$X" ))
fi
;;
- PREGAP) PREGAP=$(msf2lba $2)
+ PREGAP) PREGAP=$(msf2lba "$2")
;;
REM) case "$2" in
FLAC__lead-out)
- LEADOUT=$(( $4 / 588 ))
+ LEADOUT=$(( "$4" / 588 ))
;;
FLAC__lead-in)
- LEADIN=$(( $3 / 588 ))
+ LEADIN=$(( "$3" / 588 ))
;;
esac
;;
done
TRACKS=$i
- LEADOUT=$(( $LEADOUT + $LEADIN ))
+ LEADOUT=$(( "$LEADOUT" + "$LEADIN" ))
- LENGTH=$(( $LEADOUT/75 - $TRACK1/75 ))
- DISCID=$(( ( $N % 255 ) * 2**24 | $LENGTH * 2**8 | $TRACKS ))
- printf "%08x %i" $DISCID $TRACKS
+ LENGTH=$(( "$LEADOUT"/75 - "$TRACK1"/75 ))
+ CDDBDISCID=$(( ( "$N" % 255 ) * 2**24 | "$LENGTH" * 2**8 | "$TRACKS" ))
+ printf "%08x %i" "${CDDBDISCID}" "$TRACKS"
j=1
- while [ $j -le $TRACKS ] ; do
+ while [ $j -le "$TRACKS" ] ; do
eval echo -n "\" \$TRACK$j\""
- j=$((j+1))
+ j=$(( $j + 1))
done
echo " $(( $LEADOUT / 75 ))"
}
# Remaining track index values offset by <pregap value>
#
# Variables used:
-# TRACKINFO
+# CDDBTRACKINFO
abcde.mkcue () {
echomsf () {
local i OFFSET LBA
local CUEWAVFILE
- if [ "$1" = --wholedisc ] ; then
+ if [ "$1" = --wholedisk ] ; then
MODE=INDEX
else
MODE=PREGAP
CUEWAVFILE="dummy.wav"
fi
- set -- $TRACKINFO
+ set -- "$CDDBTRACKINFO"
- DISCID=$1
- TRACKS=$2
+ DISCID="$1"
+ TRACKS="$2"
shift 2
- echo REM DISCID $DISCID
+ echo "REM DISCID $DISCID"
echo FILE \""$CUEWAVFILE"\" WAVE
- if [ $1 -ne 150 ] && [ $MODE = "PREGAP" ] ; then
- OFFSET=$1
+ if [ "$1" -ne 150 ] && [ "$MODE" = "PREGAP" ] ; then
+ OFFSET="$1"
else
- OFFSET=150
+ OFFSET="150"
fi
i=1
while [ $i -le "$TRACKS" ] ; do
LBA=$(( $1 - $OFFSET ))
printf " TRACK %02i AUDIO\n" $i
- if [ $i -eq 1 -a $1 -ne 150 ] ; then
- if [ $MODE = PREGAP ] ; then
- echomsf " PREGAP " $(($OFFSET-150))
+ if [ "$i" -eq 1 ] && [ "$1" -ne 150 ] ; then
+ if [ "$MODE" = PREGAP ] ; then
+ echomsf " PREGAP " $(($"OFFSET" - 150))
else
echo " INDEX 00 00:00:00"
fi
fi
- echomsf " INDEX 01 " $LBA
- i=$(($i+1))
+ echomsf " INDEX 01 " "$LBA"
+ i=$(( $i + 1))
shift
done
}
# do_discid
-# This essentially the start of things
+# This is essentially the start of things
do_discid ()
{
- # Query the CD to get the track info, unless the user specified -C
- # or we are using some actions which do not need the CDDB data at all
- #if [ ! X"$EXPACTIONS" = "X" ]; then
- # :
- #elif [ -z "$DISCID" ]; then
- if [ -z "$DISCID" ]; then
+ if [ -z "${CDDBDISCID}" ]; then
vecho -n "Getting CD track info... "
# In OSX, unmount the disc before a query
if [ "$OSFLAVOUR" = "OSX" ]; then
- diskutil unmount ${CDROM#/dev/}
+ diskutil unmount "${CDROM#/dev/}"
fi
case "$CDROMREADERSYNTAX" in
flac)
TRACKS=${#OFFSETTIMES[@]}
unset OFFSETS
#echo "processing offsetimes ${OFFSETTIMES[@]}"
- for OFFSETTIME in ${OFFSETTIMES[@]}; do
+ for OFFSETTIME in "${OFFSETTIMES[@]}"; do
OFFSETS="$OFFSETS $(( 10#${OFFSETTIME:0:2} * 4500 + 10#${OFFSETTIME:3:2} * 75 + 10#${OFFSETTIME:6:2} ))"
#OFFSETS[${#OFFSETS[*]}]=$(( 10#${OFFSETTIME:0:2} * 4500 + 10#${OFFSETTIME:3:2} * 75 + 10#${OFFSETTIME:6:2} ))
done
;;
*)
#vecho "Using external python cue2discid implementation..."
- TRACKINFO=$($METAFLAC $METAFLACOPTS --export-cuesheet-to=- "$CDROM" | $CUE2DISCID)
+ CDDBTRACKINFO=$($METAFLAC $METAFLACOPTS --export-cuesheet-to=- "$CDROM" | $CUE2DISCID)
;;
esac
else
fi
;;
cdparanoia|debug)
- CDPARANOIAOUTPUT="$( $CDROMREADER -$CDPARANOIACDROMBUS "$CDROM" -Q --verbose 2>&1 )"
+ CDPARANOIAOUTPUT="$( $CDROMREADER -"$CDPARANOIACDROMBUS" "$CDROM" -Q --verbose 2>&1 )"
RET=$?
if [ ! "$RET" = "0" ];then
- log warning "something went wrong while querying the CD... Maybe a DATA CD?"
+ log warning "something went wrong while querying the CD... Maybe a DATA CD or the CD is not loaded?"
fi
TRACKS="$(echo "$CDPARANOIAOUTPUT" | grep -E '^[[:space:]]+[[:digit:]]' | tail -n 1 | get_first | tr -d "." | tr '\n' ' ')"
makeids
;;
*)
+ # Calculate the cddb discid in all
+ # cases now. We'll use the cddb discid
+ # for reference in most cases for
+ # consistency. Also calculate the
+ # musicbrainz discid if we need it.
+ CDDBTRACKINFO=$($CDDISCID "$CDROM")
+ if [ "$CDDISCID_NEEDS_PAUSE"x = "y"x ]; then
+ sleep 6
+ fi
+ CDDBDISCID=$(echo "$CDDBTRACKINFO" | cut -d' ' -f1)
case "$CDDBMETHOD" in
- cddb) TRACKINFO=$($CDDISCID "$CDROM") ;;
- musicbrainz) TRACKINFO=$($MUSICBRAINZ --command id --device "$CDROM") ;;
+ *musicbrainz*)
+ MBTRACKINFO=$($MUSICBRAINZ --command id --device "$CDROM")
+ error=$?
+ if [ $error != 0 ]; then
+ log error "$MUSICBRAINZ failed to run; ABORT"
+ exit $error
+ fi
+ MBDISCID=$(echo "$MBTRACKINFO" | cut -d' ' -f1)
+ ;;
esac
- ;;
esac
# Make sure there's a CD in there by checking cd-discid's return code
if [ ! "$?" = "0" ]; then
fi
# In OSX, remount the disc again
if [ "$OSFLAVOUR" = "OSX" ]; then
- diskutil mount ${CDROM#/dev/}
+ diskutil mount "${CDROM#/dev/}"
fi
WEHAVEACD=y
- DISCID=$(echo $TRACKINFO | cut -f1 -d' ')
+ CDDBDISCID=$(echo "$CDDBTRACKINFO" | cut -f1 -d' ')
else
- TRACKINFO=$(cat "$WAVOUTPUTDIR/abcde.$DISCID/discid")
+ CDDBTRACKINFO=$(cat "$WAVOUTPUTDIR/abcde.${CDDBDISCID}/cddbdiscid")
fi
# Get a full enumeration of tracks, sort it, and put it in the TRACKQUEUE.
TRACKNUMPADDING=2
fi
- ABCDETEMPDIR="$WAVOUTPUTDIR/abcde.$(echo $TRACKINFO | cut -f1 -d' ')"
+ ABCDETEMPDIR="$WAVOUTPUTDIR/abcde.$(echo "$CDDBTRACKINFO" | cut -f1 -d' ')"
if [ -z "$TRACKQUEUE" ]; then
if [ ! "$STRIPDATATRACKS" = "n" ]; then
case "$CDROMREADERSYNTAX" in
cdparanoia|libcdio|debug)
if [ "$WEHAVEACD" = "y" ]; then
vecho "Querying the CD for audio tracks..."
- CDPARANOIAOUTPUT="$( $CDROMREADER -$CDPARANOIACDROMBUS "$CDROM" -Q --verbose 2>&1 )"
+ CDPARANOIAOUTPUT="$( $CDROMREADER -"$CDPARANOIACDROMBUS" "$CDROM" -Q --verbose 2>&1 )"
RET=$?
if [ ! "$RET" = "0" ];then
log warning "something went wrong while querying the CD... Maybe a DATA CD?"
CDPARANOIAAUDIOTRACKS="$TRACKS"
else
# Previous versions of abcde would store the tracks on a file, instead of the status record.
- if [ -f "$ABCDETEMPDIR/cdparanoia-audio-tracks" ]; then
- echo cdparanoia-audio-tracks=$( cat "$ABCDETEMPDIR/cdparanoia-audio-tracks" ) >> "$ABCDETEMPDIR/status"
- rm -f "$ABCDETEMPDIR/cdparanoia-audio-tracks"
+ if [ -f "${ABCDETEMPDIR}/cdparanoia-audio-tracks" ]; then
+ echo "cdparanoia-audio-tracks=$( cat "${ABCDETEMPDIR}/cdparanoia-audio-tracks" )" >> "${ABCDETEMPDIR}/status"
+ rm -f "${ABCDETEMPDIR}/cdparanoia-audio-tracks"
fi
- if [ -f "$ABCDETEMPDIR/status" ] && TRACKS=$(checkstatus cdparanoia-audio-tracks); then :; else
- TRACKS=$(echo $TRACKINFO | cut -f2 -d' ')
+ if [ -f "${ABCDETEMPDIR}/status" ] && TRACKS=$(checkstatus cdparanoia-audio-tracks); then :; else
+ TRACKS=$(echo "$CDDBTRACKINFO" | cut -f2 -d' ')
fi
fi
;;
- *) TRACKS=$(echo $TRACKINFO | cut -f2 -d' ') ;;
+ *) TRACKS=$(echo "$CDDBTRACKINFO" | cut -f2 -d' ') ;;
esac
else
- TRACKS=$(echo $TRACKINFO | cut -f2 -d' ')
+ TRACKS=$(echo "$CDDBTRACKINFO" | cut -f2 -d' ')
fi
if echo "$TRACKS" | grep "[[:digit:]]" > /dev/null 2>&1 ;then :;else
log info "The disc does not contain any tracks. Giving up..."
fi
echo -n "Grabbing entire CD - tracks: "
if [ ! "$PADTRACKS" = "y" ] ; then
- TRACKNUMPADDING=$(echo -n $TRACKS | wc -c | tr -d ' ')
+ TRACKNUMPADDING=$(echo -n "$TRACKS" | wc -c | tr -d ' ')
fi
+
TRACKS=$(printf "%0.${TRACKNUMPADDING}d" $TRACKS)
X=0
while [ "$X" -ne "$TRACKS" ]
do
- X=$(printf "%0.${TRACKNUMPADDING}d" $(expr $X + 1))
- TRACKQUEUE=$(echo $TRACKQUEUE $X)
+ PT=$(printf "%0.${TRACKNUMPADDING}d" $(($X + 1)))
+ TRACKQUEUE="$TRACKQUEUE $PT"
+ X=$(($X + 1))
done
- echo $TRACKQUEUE
+ echo "$TRACKQUEUE"
else
- TRACKS=$(echo $TRACKINFO | cut -f2 -d' ')
+ TRACKS=$(echo "$CDDBTRACKINFO" | cut -f2 -d' ')
# User-supplied track queue.
# Weed out non-numbers, whitespace, then sort and weed out duplicates
- TRACKQUEUE=$(echo $TRACKQUEUE | sed 's-[^0-9 ]--g' | tr ' ' '\n' | grep -v ^$ | sort -n | uniq | tr '\n' ' ' | sed 's- $--g')
+ TRACKQUEUE=$(echo "$TRACKQUEUE" | sed 's-[^0-9 ]--g' | tr ' ' '\n' | grep -v ^$ | sort -n | uniq | tr '\n' ' ' | sed 's- $--g')
# Once cleaned, obtain the highest value in the trackqueue for number padding
for LASTTRACK in $TRACKQUEUE; do :; done
if [ ! "$PADTRACKS" = "y" ] ; then
- TRACKNUMPADDING=$(echo -n $LASTTRACK | wc -c | tr -d ' ')
+ TRACKNUMPADDING=$(echo -n "$LASTTRACK" | wc -c | tr -d ' ')
fi
# Now we normalize the trackqueue
for TRACK in $TRACKQUEUE ; do
- TRACKNUM=$(printf %0.${TRACKNUMPADDING}d $(expr ${TRACK} + 0 ))
- PADTRACKQUEUE=$(echo $PADTRACKQUEUE $TRACKNUM)
+ TRACKNUM=$(printf "%0.${TRACKNUMPADDING}d" $(($TRACK + 0)))
+ PADTRACKQUEUE="$PADTRACKQUEUE $TRACKNUM"
done
- TRACKQUEUE=$PADTRACKQUEUE
+ TRACKQUEUE="$PADTRACKQUEUE"
echo Grabbing tracks: "$TRACKQUEUE"
fi
# We have the discid, create a temp directory after it to store all the temp
# info
- if [ -e "$ABCDETEMPDIR" ]; then
- echo -n "abcde: attempting to resume from $ABCDETEMPDIR"
+ if [ -e "${ABCDETEMPDIR}" ]; then
+ echo -n "abcde: attempting to resume from ${ABCDETEMPDIR}"
# It already exists, see if it's a directory
- if [ ! -d "$ABCDETEMPDIR" ]; then
+ if [ ! -d "${ABCDETEMPDIR}" ]; then
# This is a file/socket/fifo/device/etc, not a directory
# Complain and exit
echo >&2
- echo "abcde: file $ABCDETEMPDIR already exists and does not belong to abcde." >&2
+ echo "abcde: file ${ABCDETEMPDIR} already exists and does not belong to abcde." >&2
echo "Please investigate, remove it, and rerun abcde." >&2
exit 1
fi
echo -n .
# It's a directory, let's see if it's writable by us
- if [ ! -r "$ABCDETEMPDIR" ] || [ ! -w "$ABCDETEMPDIR" ] || [ ! -x "$ABCDETEMPDIR" ]; then
+ if [ ! -r "${ABCDETEMPDIR}" ] || [ ! -w "${ABCDETEMPDIR}" ] || [ ! -x "${ABCDETEMPDIR}" ]; then
# Nope, complain and exit
echo >&2
- echo "abcde: directory $ABCDETEMPDIR already exists and is not writeable." >&2
+ echo "abcde: directory ${ABCDETEMPDIR} already exists and is not writeable." >&2
echo "Please investigate, remove it, and rerun abcde." >&2
exit 1
fi
echo .
# See if it's populated
- if [ ! -f "$ABCDETEMPDIR/discid" ]; then
+ if [ ! -f "${ABCDETEMPDIR}/cddbdiscid" ]; then
# Wipe and start fresh
- echo "abcde: $ABCDETEMPDIR/discid not found. Abcde must remove and recreate" >&2
+ echo "abcde: ${ABCDETEMPDIR}/cddbdiscid not found. Abcde must remove and recreate" >&2
echo -n "this directory to continue. Continue [y/N]? " >&2
if [ "$INTERACTIVE" = "y" ]; then
read ANSWER
if [ "$ANSWER" != "y" ]; then
exit 1
fi
- rm -rf "$ABCDETEMPDIR" || exit 1
- mkdir -p "$ABCDETEMPDIR"
+ rm -rf "${ABCDETEMPDIR}" || exit 1
+ mkdir -p "${ABCDETEMPDIR}"
if [ "$?" -gt "0" ]; then
# Directory already exists or could not be created
- echo "abcde: Temp directory $ABCDETEMPDIR could not be created." >&2
+ echo "abcde: Temp directory ${ABCDETEMPDIR} could not be created." >&2
exit 1
fi
else
# Everything is fine. Check for ^encodetracklocation-
# and encode-output entries in the status file and
# remove them. These are not relevant across sessions.
- if [ -f "$ABCDETEMPDIR/status" ]; then
- mv "$ABCDETEMPDIR/status" "$ABCDETEMPDIR/status.old"
- grep -v ^encodetracklocation- < "$ABCDETEMPDIR/status.old" \
- | grep -v ^encode-output > "$ABCDETEMPDIR/status"
+ if [ -f "${ABCDETEMPDIR}/status" ]; then
+ mv "${ABCDETEMPDIR}/status" "${ABCDETEMPDIR}/status.old"
+ grep -v ^encodetracklocation- < "${ABCDETEMPDIR}/status.old" \
+ | grep -v ^encode-output > "${ABCDETEMPDIR}/status"
fi
# Remove old error messages
- if [ -f "$ABCDETEMPDIR/errors" ]; then
- rm -f "$ABCDETEMPDIR/errors"
+ if [ -f "${ABCDETEMPDIR}/errors" ]; then
+ rm -f "${ABCDETEMPDIR}/errors"
fi
fi
else
# We are starting from scratch
- mkdir -p "$ABCDETEMPDIR"
+ mkdir -p "${ABCDETEMPDIR}"
if [ "$?" -gt "0" ]; then
# Directory already exists or could not be created
- echo "abcde: Temp directory $ABCDETEMPDIR could not be created." >&2
+ echo "abcde: Temp directory ${ABCDETEMPDIR} could not be created." >&2
exit 1
fi
- cat /dev/null > "$ABCDETEMPDIR/status"
+ cat /dev/null > "${ABCDETEMPDIR}/status"
# Store the abcde version in the status file.
- echo "abcde-version=$VERSION" >> "$ABCDETEMPDIR/status"
+ echo "abcde-version=$VERSION" >> "${ABCDETEMPDIR}/status"
fi
- if [ X"$DOCUE" = "Xy" -a X"$WEHAVEACD" = "Xy" ]; then
+ if [ X"$DOCUE" = "Xy" ] && [ X"$WEHAVEACD" = "Xy" ]; then
if checkstatus cuefile > /dev/null 2>&1 ; then :; else
- CUEFILE=cue-$(echo "$TRACKINFO" | cut -f1 -d' ').txt
+ CUEFILE=cue-$(echo "$CDDBTRACKINFO" | cut -f1 -d' ').txt
vecho "Creating cue file..."
- case $CDROMREADERSYNTAX in
+ case "$CDROMREADERSYNTAX" in
flac)
- if $METAFLAC --export-cuesheet-to=- "$CDROM" > "$ABCDETEMPDIR/$CUEFILE"; then
- echo cuefile=$CUEFILE >> "$ABCDETEMPDIR/status"
+ if $METAFLAC --export-cuesheet-to=- "$CDROM" > "${ABCDETEMPDIR}/$CUEFILE"; then
+ echo "cuefile=$CUEFILE" >> "${ABCDETEMPDIR}/status"
else
log warning "the input flac file does not contain a cuesheet."
fi
;;
*)
- if $CUEREADER $CUEREADEROPTS > "$ABCDETEMPDIR/$CUEFILE"; then
- echo cuefile=$CUEFILE >> "$ABCDETEMPDIR/status"
+ if $CUEREADER $CUEREADEROPTS > "${ABCDETEMPDIR}/$CUEFILE"; then
+ echo "cuefile=$CUEFILE" >> "${ABCDETEMPDIR}/status"
else
log warning "reading the CUE sheet is still considered experimental"
log warning "and there was a problem with the CD reading. abcde will continue,"
# If we got the CDPARANOIA status and it is not recorded, save it now
if [ -n "$CDPARANOIAAUDIOTRACKS" ]; then
if checkstatus cdparanoia-audio-tracks > /dev/null 2>&1; then :; else
- echo cdparanoia-audio-tracks=$CDPARANOIAAUDIOTRACKS >> "$ABCDETEMPDIR/status"
+ echo "cdparanoia-audio-tracks=$CDPARANOIAAUDIOTRACKS" >> "${ABCDETEMPDIR}/status"
fi
fi
- # Create the discid file
- echo "$TRACKINFO" > "$ABCDETEMPDIR/discid"
- if checkstatus cddbmethod > /dev/null 2>&1 ; then :; else
- echo "cddbmethod=$CDDBMETHOD" >> "$ABCDETEMPDIR/status"
- fi
+ # Create the discid files
+ echo "$CDDBTRACKINFO" > "${ABCDETEMPDIR}/cddbdiscid"
+ case "$CDDBMETHOD" in
+ *musicbrainz*)
+ echo "$MBTRACKINFO" > "${ABCDETEMPDIR}/mbdiscid"
+ ;;
+ esac
}
# do_cleancue
# Create a proper CUE file based on the CUE file we created before.
do_cleancue()
{
- if CUEFILE_IN="$ABCDETEMPDIR"/$(checkstatus cuefile); then
+ if CUEFILE_IN="${ABCDETEMPDIR}"/$(checkstatus cuefile); then
CUEFILE_OUT=$CUEFILE_IN.out
### FIXME ### checkstatus cddb
if [ -e "$CDDBDATA" ]; then
# echo "$line" >> "$CUEFILE_OUT"
# if echo "$line" | grep "^[[:space:]]*TRACK" > /dev/null 2>&1 ; then
eval track="\$TRACK$n"
- n=$(expr $n + 1)
+ n=$(( $n + 1 ))
echo " TITLE \"$track\"" >> "$CUEFILE_OUT"
# When making a single-track rip, put the
# actual file name into the file declaration
done
IFS="$OIFS"
mv "$CUEFILE_OUT" "$CUEFILE_IN"
- echo "cleancuefile" >> "$ABCDETEMPDIR/status"
+ echo "cleancuefile" >> "${ABCDETEMPDIR}/status"
fi
fi
}
if [ ! "$ONETRACK" = "y" ]; then
for TRACK in $(f_seq_row 1 $TRACKS)
do
- echo $TRACK: "$(grep -a ^TTITLE$(expr $TRACK - 1)= "${CDDBPARSEFILE}" | cut -f2- -d= | tr -d \\r\\n)"
+ echo "$TRACK": "$(grep -a ^TTITLE$(($TRACK - 1))= "${CDDBPARSEFILE}" | cut -f2- -d= | tr -d \\r\\n)"
done
fi
}
-# do_localcddb
+# do_localcddb_read
# Check for a local CDDB file, and report success
-do_localcddb ()
+do_localcddb_read ()
{
if checkstatus cddb-readcomplete && checkstatus cddb-choice >/dev/null; then :; else
CDDBLOCALSTATUS="notfound"
- CDDBDISCID=$(echo $TRACKINFO | cut -d' ' -f1)
+ CDDBDISCID=$(echo "$CDDBTRACKINFO" | cut -d' ' -f1)
USELOCALRESP="y"
if [ "$CDDBLOCALRECURSIVE" = "y" ]; then
- CDDBLOCALRESULTS="$(find ${CDDBLOCALDIR} -name "${CDDBDISCID}" -type f 2> /dev/null)"
+ CDDBLOCALRESULTS="$(find "${CDDBLOCALDIR}" -name "${CDDBDISCID}" -type f 2> /dev/null)"
if [ ! "${CDDBLOCALRESULTS}" = "" ]; then
if (( $(echo "${CDDBLOCALRESULTS}" | wc -l) == 1 )); then
CDDBLOCALFILE="${CDDBLOCALRESULTS}"
# If the user has selected to check a local CDDB repo, we proceed with it
case $CDDBLOCALMATCH in
multiple)
- echo "Processing multiple matching CDDB entries..." > "$ABCDETEMPDIR/cddblocalchoices"
+ echo "Processing multiple matching CDDB entries..." > "${ABCDETEMPDIR}/cddblocalchoices"
X=0
echo "$CDDBLOCALRESULTS" | while read RESULT ; do
- X=$(expr $X + 1)
+ X=$(( $X + 1 ))
# List out disc title/author and contents
- CDDBLOCALREAD="$ABCDETEMPDIR/cddblocalread.$X"
+ CDDBLOCALREAD="${ABCDETEMPDIR}/cddblocalread.$X"
cat "$RESULT" > "${CDDBLOCALREAD}"
{
echo -n "#$X: "
echo ""
##FIXME## QUICK HACK !!!!
if [ ! "$INTERACTIVE" = "y" ]; then break ; fi
- } >> "$ABCDETEMPDIR/cddblocalchoices"
+ } >> "${ABCDETEMPDIR}/cddblocalchoices"
done
- if [ $(cat "$ABCDETEMPDIR/cddblocalchoices" | wc -l) -ge 24 ] && [ "$INTERACTIVE" = "y" ]; then
- page "$ABCDETEMPDIR/cddblocalchoices"
- else
- # It's all going to fit in one page, cat it
- cat "$ABCDETEMPDIR/cddblocalchoices" >&2
- fi
+ page "${ABCDETEMPDIR}/cddblocalchoices"
CDDBLOCALCHOICES=$( echo "$CDDBLOCALRESULTS" | wc -l )
# Setting the choice to an impossible integer to avoid errors in the numeric comparisons
CDDBLOCALCHOICENUM=-1
if [ "$INTERACTIVE" = "y" ]; then
- while [ $CDDBLOCALCHOICENUM -lt 0 ] || [ $CDDBLOCALCHOICENUM -gt $CDDBLOCALCHOICES ]; do
- echo -n "Locally cached CDDB entries found. Which one would you like to use (0 for none)? [0-$CDDBLOCALCHOICES]: " >&2
+ while [ "$CDDBLOCALCHOICENUM" -lt 0 ] || [ "$CDDBLOCALCHOICENUM" -gt "$CDDBLOCALCHOICES" ]; do
+ echo "Locally cached CDDB entries found." >&2
+ echo -n "Which one would you like to use (0 for none)? [0-$CDDBLOCALCHOICES]: " >&2
read CDDBLOCALCHOICE
[ x"$CDDBLOCALCHOICE" = "x" ] && CDDBLOCALCHOICE="1"
# FIXME # Introduce diff's
elif echo $CDDBLOCALCHOICE | grep -E "[[:space:]]*[[:digit:]]+[[:space:]]*" > /dev/null 2>&1 ; then
# Make sure we get a valid choice
CDDBLOCALCHOICENUM=$(echo $CDDBLOCALCHOICE | xargs printf %d 2>/dev/null)
- if [ $CDDBLOCALCHOICENUM -lt 0 ] || [ $CDDBLOCALCHOICENUM -gt $CDDBLOCALCHOICES ]; then
+ if [ "$CDDBLOCALCHOICENUM" -lt 0 ] || [ "$CDDBLOCALCHOICENUM" -gt "$CDDBLOCALCHOICES" ]; then
echo "Invalid selection. Please choose a number between 0 and $CDDBLOCALCHOICES." >&2
fi
fi
done
else
- ### FIXME ###
- #echo "Selected ..."
- CDDBLOCALRESP=y
CDDBLOCALCHOICENUM=1
fi
if [ ! "$CDDBLOCALCHOICENUM" = "0" ]; then
#echo "Using local copy of CDDB data"
- echo "# DO NOT ERASE THIS LINE! Added by abcde to imitate cddb output" > "$ABCDETEMPDIR/cddbread.1"
- cat "$ABCDETEMPDIR/cddblocalread.$CDDBLOCALCHOICENUM" >> "$ABCDETEMPDIR/cddbread.1"
- echo 999 > "$ABCDETEMPDIR/cddbquery" # Assuming 999 isn't used by CDDB
- echo cddb-readcomplete >> "$ABCDETEMPDIR/status"
- do_cddbparse "$ABCDETEMPDIR/cddbread.1" > "$ABCDETEMPDIR/cddbchoices"
- echo cddb-choice=1 >> "$ABCDETEMPDIR/status"
+ echo "# DO NOT ERASE THIS LINE! Added by abcde to imitate cddb output" > "${ABCDETEMPDIR}/cddbread.1"
+ cat "${ABCDETEMPDIR}/cddblocalread.$CDDBLOCALCHOICENUM" >> "${ABCDETEMPDIR}/cddbread.1"
+ echo "local" > "${ABCDETEMPDIR}/datasource.1"
+ echo 999 > "${ABCDETEMPDIR}/cddbquery" # Assuming 999 isn't used by CDDB
+ echo cddb-readcomplete >> "${ABCDETEMPDIR}/status"
+ do_cddbparse "${ABCDETEMPDIR}/cddbread.1" > "${ABCDETEMPDIR}/cddbchoices"
+ echo cddb-choice=1 >> "${ABCDETEMPDIR}/status"
CDDBLOCALSTATUS="found"
else
#echo "Not using local copy of CDDB data"
fi
if [ "$USELOCALRESP" = "y" ]; then
#echo "Using local copy of CDDB data"
- echo "# DO NOT ERASE THIS LINE! Added by abcde to imitate cddb output" > "$ABCDETEMPDIR/cddbread.1"
- cat "${CDDBLOCALFILE}" >> "$ABCDETEMPDIR/cddbread.1"
- echo 999 > "$ABCDETEMPDIR/cddbquery" # Assuming 999 isn't used by CDDB
- echo cddb-readcomplete >> "$ABCDETEMPDIR/status"
- do_cddbparse "${CDDBLOCALFILE}" > "$ABCDETEMPDIR/cddbchoices"
- echo cddb-choice=1 >> "$ABCDETEMPDIR/status"
+ echo "# DO NOT ERASE THIS LINE! Added by abcde to imitate cddb output" > "${ABCDETEMPDIR}/cddbread.1"
+ cat "${CDDBLOCALFILE}" >> "${ABCDETEMPDIR}/cddbread.1"
+ echo "local" > "${ABCDETEMPDIR}/datasource.1"
+ echo 999 > "${ABCDETEMPDIR}/cddbquery" # Assuming 999 isn't used by CDDB
+ echo cddb-readcomplete >> "${ABCDETEMPDIR}/status"
+ do_cddbparse "${CDDBLOCALFILE}" > "${ABCDETEMPDIR}/cddbchoices"
+ echo cddb-choice=1 >> "${ABCDETEMPDIR}/status"
CDDBLOCALSTATUS="single"
else
#echo "Not using local copy of CDDB data"
fi
}
-# do_cdtext
+# do_cdtext_read
# Try to read CD-Text from the drive using icedax / cdda2wav
-do_cdtext ()
+do_cdtext_read ()
{
if new_checkexec icedax; then
CDTEXT_READER=icedax
return 0
fi
+ vecho "Obtaining CD-Text results..."
+ local SOURCE_WORKDIR="${ABCDETEMPDIR}/data-cdtext"
+ mkdir -p "${SOURCE_WORKDIR}"
+
if [ "$OSFLAVOUR" = "OSX" ] ; then
# Hei, we have to unmount the device before running anything like cdda2wav/icedax in OSX
- diskutil unmount ${CDROM#/dev/}
+ diskutil unmount "${CDROM#/dev/}"
# Also, in OSX the cdrom device for cdda2wav/icedax changes...
CDDA2WAVCDROM="IODVDServices"
- elif [ "$OSFLAVOUR" = "FBSD" ] ; then
+ elif [ "$OSFLAVOUR" = "FBSD" ] || [ "$OSFLAVOUR" = "IRIX" ]; then
CDDA2WAVCDROM="$CDROMID"
else
if [ "$CDROMID" = "" ]; then
# Do we have CD-Text on the disc (and can the drive read it?)
(
- cd "$ABCDETEMPDIR" && rm -f audio.* audio_*
- ${CDTEXT_READER} -J -v titles -D ${CDDA2WAVCDROM} > "$ABCDETEMPDIR/cd-text" 2>&1
+ cd "${SOURCE_WORKDIR}" && rm -f audio.* audio_*
+ ${CDTEXT_READER} -J -v titles -D "${CDDA2WAVCDROM}" > "${SOURCE_WORKDIR}/cd-text" 2>&1
)
- grep -a -q '^CD-Text: detected' "$ABCDETEMPDIR/cd-text"
+ grep -a -q '^CD-Text: detected' "${SOURCE_WORKDIR}/cd-text"
ERRORCODE=$?
if [ $ERRORCODE -ne 0 ]; then
# No CD-Text found, bail
return 0
fi
- rm -f "$ABCDETEMPDIR/cddbchoices"
- CDDBCHOICES=1
+ NUM_CDDB_MATCHES=$(($NUM_CDDB_MATCHES + 1))
# Make an empty template
- $CDDBTOOL template $(cat "$ABCDETEMPDIR/discid") > "$ABCDETEMPDIR/cddbread.1"
- echo -n "Retrieved 1 CD-Text match..." >> "$ABCDETEMPDIR/cddbchoices"
- echo "done." >> "$ABCDETEMPDIR/cddbchoices"
- echo cddb-read-1-complete >> "$ABCDETEMPDIR/status"
- echo cddb-choice=1 >> "$ABCDETEMPDIR/status"
- #ATITLE=$(grep -ae '^Album title:' "${ABCDETEMPDIR}/cd-text" | cut -c14- | sed "s~'\(.*\)'.*\[from \(.*\)]$~\2 / \1~")
- ATITLE=$(grep -ae '^DTITLE=' "${ABCDETEMPDIR}/audio.cddb" | cut -c8-)
- echo "200 none ${ATITLE}" >> "$ABCDETEMPDIR/cddbquery"
- # List out disc title/author and contents
- echo "---- ${ATITLE} ----" >> "$ABCDETEMPDIR/cddbchoices"
- sed -n 's~^Track \(..:\) .\(.*\).$~\1 \2~gp;' "$ABCDETEMPDIR/cd-text" >>"$ABCDETEMPDIR/cddbchoices"
- rm -f "$ABCDETEMPDIR/cddbread.1"
+ $CDDBTOOL template "$(cat "${ABCDETEMPDIR}/cddbdiscid")" > "${SOURCE_WORKDIR}/cddbread.${NUM_CDDB_MATCHES}"
+ echo "cddb-read-${NUM_CDDB_MATCHES}-complete" >> "${ABCDETEMPDIR}/status"
+ rm -f "${SOURCE_WORKDIR}/cddbread.${NUM_CDDB_MATCHES}"
+
# XXX FIXME - this is a hack and should be replaced by proper
# character set tracking for the CDDB data we have.
- if test "$CDDBPROTO" -ge 6 ; then
+ if [ "$CDDBPROTO" -ge 6 ]; then
# convert to Unicode
- iconv -f iso-8859-1 -t utf-8 <"$ABCDETEMPDIR/audio.cddb" >"$ABCDETEMPDIR/cddbread.1"
+ iconv -f iso-8859-1 -t utf-8 <"${SOURCE_WORKDIR}/audio.cddb" >"${SOURCE_WORKDIR}/cddbread.${NUM_CDDB_MATCHES}"
else
# copy verbatim, assuming CD-TEXT is in ISO-8859-1 format
# apparently icedax/cdda2wav have no support for 16-bit
# characters yet, either
- cp -p "$ABCDETEMPDIR/audio.cddb" "$ABCDETEMPDIR/cddbread.1"
+ cp -p "${SOURCE_WORKDIR}/audio.cddb" "${SOURCE_WORKDIR}/cddbread.${NUM_CDDB_MATCHES}"
fi
- ( cd "$ABCDETEMPDIR" && rm -f audio_* audio.* )
- echo >> "$ABCDETEMPDIR/cddbchoices"
- echo "cdtext-readcomplete" >> "$ABCDETEMPDIR/status"
+
+ CDDBDISCID=$(echo "$CDDBTRACKINFO" | cut -d' ' -f1)
+ ATITLE=$(grep -a -e '^DTITLE=' "${SOURCE_WORKDIR}/cddbread.${NUM_CDDB_MATCHES}" | cut -c8- | tr -d \\r\\n)
+ echo "CD-Text" > "${SOURCE_WORKDIR}/datasource.${NUM_CDDB_MATCHES}"
+ echo "none ${CDDBDISCID} ${ATITLE}" >> "${SOURCE_WORKDIR}/cddbquery.${NUM_CDDB_MATCHES}"
+
+ ( cd "${SOURCE_WORKDIR}" && rm -f audio_* audio.* )
+ for file in ${SOURCE_WORKDIR}/cddbread.* ${SOURCE_WORKDIR}/cddbquery.* ${SOURCE_WORKDIR}/datasource.*; do
+ if [ -f "$file" ]; then
+ cp "$file" "${ABCDETEMPDIR}"
+ fi
+ done
+ echo "cdtext-readcomplete" >> "${ABCDETEMPDIR}/status"
}
-# do_musicbrainz
+# do_musicbrainz_read
# Work with the musicbrainz WS API, then transform the results here so
# they look (very) like the results from CDDB. Maybe not the best way
# to go, but it Works For Me (TM)
-
-do_musicbrainz ()
+#
+# List out all the matches individually into $SOURCE_WORKDIR/cddbread.X
+#
+do_musicbrainz_read ()
{
if checkstatus musicbrainz-readcomplete; then :; else
vecho "Obtaining Musicbrainz results..."
# If MB is to be used, interpret the query results and read all
# the available entries.
- rm -f "$ABCDETEMPDIR/cddbchoices"
- CDDBCHOICES=1 # Overridden by multiple matches
- MBDISCID=$(echo $TRACKINFO | cut -d' ' -f1)
- ${MUSICBRAINZ} --command data --discid "$MBDISCID" --workdir "$ABCDETEMPDIR"
+ CDDBDISCID=$(echo "$CDDBTRACKINFO" | cut -d' ' -f1)
+ MBDISCID=$(echo "$MBTRACKINFO" | cut -d' ' -f1)
+ local SOURCE_WORKDIR="${ABCDETEMPDIR}/data-musicbrainz"
+ mkdir -p "${SOURCE_WORKDIR}"
+ ${MUSICBRAINZ} --command data --discid "${MBDISCID}" --workdir "${SOURCE_WORKDIR}" --start ${NUM_CDDB_MATCHES}
+ error=$?
+ if [ $error != 0 ]; then
+ log error "$MUSICBRAINZ failed to run; ABORT"
+ exit $error
+ fi
+ # Check for no matches.
# The helper script will write disc matches out to
# cddbread.*. Count how many we have
- if [ ! -f "${ABCDETEMPDIR}/cddbread.1" ] ; then
- if [ $CDDBLASTMETHOD = "y" ]
- then
- # We're the end of the line.
- #
- # No matches. Use the normal cddb template for the user to
- # fill in
- vecho "Unable to find a match with ${CDDBMETHCHOICE}, generating CDDB template."
- echo "No Musicbrainz match." >> "$ABCDETEMPDIR/cddbchoices"
- $CDDBTOOL template $(cat "$ABCDETEMPDIR/discid") > "$ABCDETEMPDIR/cddbread.0"
- # List out disc title/author and contents of template
- echo ---- Unknown Artist / Unknown Album ---- >> "$ABCDETEMPDIR/cddbchoices"
- UNKNOWNDISK=y
- for TRACK in $(f_seq_row 1 $TRACKS)
- do
- echo $TRACK: "$(grep -a ^TTITLE$(expr $TRACK - 1)= "$ABCDETEMPDIR/cddbread.0" | cut -f2- -d= | tr -d \\r\\n)" >> "$ABCDETEMPDIR/cddbchoices"
- done
- echo >> "$ABCDETEMPDIR/cddbchoices"
- echo cddb-read-0-complete >> "$ABCDETEMPDIR/status"
- echo cddb-choice=0 >> "$ABCDETEMPDIR/status"
- echo 503 > "$ABCDETEMPDIR/cddbquery"
- else
- # Neat, we'll let the next guy take care of this CDDB
- # file junk.
- vecho "Unable to find a match with ${CDDBMETHCHOICE}, moving on to the next option."
- fi
- else
- # We have some matches
- NUM_RESPONSES=$(echo "${ABCDETEMPDIR}"/cddbread.* | wc -w)
- if [ "$NUM_RESPONSES" -eq 1 ] ; then
- # One exact match
- echo -n "Retrieved 1 Musicbrainz match..." >> "$ABCDETEMPDIR/cddbchoices"
- echo "done." >> "$ABCDETEMPDIR/cddbchoices"
- echo cddb-read-1-complete >> "$ABCDETEMPDIR/status"
- echo cddb-choice=1 >> "$ABCDETEMPDIR/status"
- ATITLE=$(grep -a -e '^DTITLE=' "${ABCDETEMPDIR}/cddbread.1" | cut -c8- )
- echo "200 none ${ATITLE}" >> "$ABCDETEMPDIR/cddbquery"
- # List out disc title/author and contents
- echo ---- ${ATITLE} ---- >> "$ABCDETEMPDIR/cddbchoices"
- for TRACK in $(f_seq_row 1 $TRACKS)
- do
- echo $TRACK: "$(grep -a ^TTITLE$(expr $TRACK - 1)= "$ABCDETEMPDIR/cddbread.1" | cut -f2- -d= | tr -d \\r\\n)" >> "$ABCDETEMPDIR/cddbchoices"
- done
- echo >> "$ABCDETEMPDIR/cddbchoices"
- else
- echo "210 Found exact matches, list follows (until terminating .)" > "$ABCDETEMPDIR/cddbquery"
- echo "Multiple Musicbrainz matches:" >> "$ABCDETEMPDIR/cddbchoices"
- for file in "$ABCDETEMPDIR"/cddbread.*
- do
- X=$(echo $file | sed 's/^.*cddbread\.//g')
- echo cddb-read-$X-complete >> "$ABCDETEMPDIR/status"
- ATITLE=$(grep -a -e '^DTITLE=' "${ABCDETEMPDIR}"/cddbread.$X | cut -c8- )
- echo "none ${ATITLE}" >> "$ABCDETEMPDIR/cddbquery"
- # List out disc title/author and contents
- echo "#$X: ---- ${ATITLE} ----" >> "$ABCDETEMPDIR/cddbchoices"
- for TRACK in $(f_seq_row 1 $TRACKS)
- do
- echo $TRACK: "$(grep -a ^TTITLE$(expr $TRACK - 1)= "$ABCDETEMPDIR/cddbread.$X" | cut -f2- -d= | tr -d \\r\\n)" >> "$ABCDETEMPDIR/cddbchoices"
- done
- echo >> "$ABCDETEMPDIR/cddbchoices"
- done
- echo "." >> "$ABCDETEMPDIR/cddbquery"
- fi
+ NUM_RESPONSES=$(echo "${SOURCE_WORKDIR}"/cddbread.* | wc -w)
+ if [ "$NUM_RESPONSES" -gt 0 ] ; then
+ # One or more exact matches
+ i=1
+ while [ $i -le "$NUM_RESPONSES" ]; do
+ NUM_CDDB_MATCHES=$(($NUM_CDDB_MATCHES + 1))
+ i=$(($i + 1))
+ echo cddb-read-${NUM_CDDB_MATCHES}-complete >> "${ABCDETEMPDIR}/status"
+ ATITLE=$(grep -a -e '^DTITLE=' "${SOURCE_WORKDIR}/cddbread.${NUM_CDDB_MATCHES}" | cut -c8- | tr -d \\r\\n)
+ echo "none ${CDDBDISCID} ${ATITLE}" >> "${SOURCE_WORKDIR}/cddbquery.${NUM_CDDB_MATCHES}"
+ echo "Musicbrainz" > "${SOURCE_WORKDIR}/datasource.${NUM_CDDB_MATCHES}"
+ cp -f "${SOURCE_WORKDIR}/"*."${NUM_CDDB_MATCHES}" "${ABCDETEMPDIR}"
+ done
fi
- echo "musicbrainz-readcomplete" >> "$ABCDETEMPDIR/status"
+ echo "musicbrainz-readcomplete" >> "${ABCDETEMPDIR}/status"
fi
}
-# do_cddbstat
-do_cddbstat ()
+# do_cddb_read
+do_cddb_read ()
{
+ local SOURCE_WORKDIR="${ABCDETEMPDIR}/data-cddb"
+ mkdir -p "${SOURCE_WORKDIR}"
+
+ ###########
+ # cddbstat
+ ###########
+
# Perform CDDB protocol version check if it hasn't already been done
if checkstatus cddb-statcomplete; then :; else
if [ "$CDDBAVAIL" = "n" ]; then
ERRORCODE=no_query
- echo 503 > "$ABCDETEMPDIR/cddbstat"
+ echo 503 > "${SOURCE_WORKDIR}/cddbstat"
else
rc=1
- CDDBUSER=$(echo $HELLOINFO | cut -f1 -d'@')
- CDDBHOST=$(echo $HELLOINFO | cut -f2- -d'@')
- while test $rc -eq 1 -a $CDDBPROTO -ge 3; do
+ CDDBUSER=$(echo "$HELLOINFO" | cut -f1 -d'@')
+ CDDBHOST=$(echo "$HELLOINFO" | cut -f2- -d'@')
+ while [ $rc -eq 1 ] && [ "$CDDBPROTO" -ge 3 ]; do
vecho "Checking CDDB server status..."
- $CDDBTOOL stat $CDDBURL $CDDBUSER $CDDBHOST $CDDBPROTO > "$ABCDETEMPDIR/cddbstat"
- RESPONSECODE=$(head -n 1 "$ABCDETEMPDIR/cddbstat" | cut -f1 -d' ')
+ $CDDBTOOL stat "$CDDBURL" "$CDDBUSER" "$CDDBHOST" "$CDDBPROTO" > "${SOURCE_WORKDIR}/cddbstat"
+ RESPONSECODE=$(head -n 1 "${SOURCE_WORKDIR}/cddbstat" | cut -f1 -d' ')
case "$RESPONSECODE" in
210) # 210 OK, status information follows (until terminating `.')
rc=0
;;
501) # 501 Illegal CDDB protocol level: <n>.
- CDDBPROTO=`expr $CDDBPROTO - 1`
+ CDDBPROTO=$(($CDDBPROTO - 1))
;;
*) # Try a cddb query, since freedb2.org doesn't support the stat or ver commands
# FreeDB TESTCD disc-id is used for query
- $CDDBTOOL query $CDDBURL $CDDBPROTO $CDDBUSER $CDDBHOST 03015501 1 296 344 > "$ABCDETEMPDIR/cddbstat"
- RESPONSECODE=$(head -n 1 "$ABCDETEMPDIR/cddbstat" | cut -f1 -d' ')
+ $CDDBTOOL query "$CDDBURL" "$CDDBPROTO" "$CDDBUSER" "$CDDBHOST" 03015501 1 296 344 > "${SOURCE_WORKDIR}/cddbstat"
+ RESPONSECODE=$(head -n 1 "${SOURCE_WORKDIR}/cddbstat" | cut -f1 -d' ')
case "$RESPONSECODE" in
2??) # Server responded, everything seems OK
rc=0
;;
esac
done
- if test $rc -eq 1; then
+ if [ $rc -eq 1 ]; then
CDDBAVAIL="n"
fi
fi
- echo cddb-statcomplete >> "$ABCDETEMPDIR/status"
+ echo cddb-statcomplete >> "${ABCDETEMPDIR}/status"
fi
-}
+ ###########
+ # cddbquery
+ ###########
-# do_cddbquery
-do_cddbquery ()
-{
- CDDBDISCID=$(echo $TRACKINFO | cut -d' ' -f1)
+ CDDBDISCID=$(echo "$CDDBTRACKINFO" | cut -d' ' -f1)
CDDBLOCALFILE="${CDDBLOCALDIR}/${CDDBDISCID}"
# Perform CDDB query if it hasn't already been done
if checkstatus cddb-querycomplete; then :; else
if [ "$CDDBAVAIL" = "n" ]; then
ERRORCODE=no_query
- echo 503 > "$ABCDETEMPDIR/cddbquery"
+ echo 503 > "${SOURCE_WORKDIR}/cddbquery"
# The default CDDBLOCALSTATUS is "notfound"
# This part will be triggered if the user CDDB repo does not
# contain the entry, or if we are not trying to use the repo.
else
vecho "Querying the CDDB server..."
- CDDBUSER=$(echo $HELLOINFO | cut -f1 -d'@')
- CDDBHOST=$(echo $HELLOINFO | cut -f2- -d'@')
- $CDDBTOOL query $CDDBURL $CDDBPROTO $CDDBUSER $CDDBHOST $TRACKINFO > "$ABCDETEMPDIR/cddbquery"
+ CDDBUSER=$(echo "$HELLOINFO" | cut -f1 -d'@')
+ CDDBHOST=$(echo "$HELLOINFO" | cut -f2- -d'@')
+ $CDDBTOOL query "$CDDBURL" "$CDDBPROTO" "$CDDBUSER" "$CDDBHOST" "$CDDBTRACKINFO" > "${SOURCE_WORKDIR}/cddbquery"
ERRORCODE=$?
case $ERRORCODE in
0) # success
;;
12|13|14)
- # no match found in database,
- # wget/fetch error, or user requested not to use CDDB
- # Make up an error code (503) that abcde
- # will recognize in do_cddbread
+ # no match found in database, wget/fetch error,
+ # or user requested not to use CDDB. Make up an
+ # error code (503) that abcde will recognize later
# and compensate by making a template
- echo 503 > "$ABCDETEMPDIR/cddbquery"
+ echo 503 > "${SOURCE_WORKDIR}/cddbquery"
;;
*) # strange and unknown error
- echo ERRORCODE=$ERRORCODE
+ echo "ERRORCODE=$ERRORCODE"
echo "abcde: $CDDBTOOL returned unknown error code"
;;
esac
fi
- echo cddb-querycomplete >> "$ABCDETEMPDIR/status"
+ echo cddb-querycomplete >> "${ABCDETEMPDIR}/status"
fi
-}
-# do_cddbread
-do_cddbread ()
-{
+ ###########
+ # cddbread
+ ###########
+
# If it's not to be used, generate a template.
# Then, display it (or them) and let the user choose/edit it
if checkstatus cddb-readcomplete; then :; else
+ RESPONSECODE=$(head -n 1 "${SOURCE_WORKDIR}/cddbquery" | cut -f1 -d' ')
vecho "Obtaining CDDB results..."
- # If CDDB is to be used, interpret the query results and read all
- # the available entries.
- rm -f "$ABCDETEMPDIR/cddbchoices"
- CDDBCHOICES=1 # Overridden by multiple matches
- RESPONSECODE=$(head -n 1 "$ABCDETEMPDIR/cddbquery" | cut -f1 -d' ')
case "$RESPONSECODE" in
200)
# One exact match, retrieve it
# 200 [section] [discid] [artist] / [title]
- if checkstatus cddb-read-1-complete; then :; else
- echo -n "Retrieving 1 CDDB match..." >> "$ABCDETEMPDIR/cddbchoices"
- $CDDBTOOL read $CDDBURL $CDDBPROTO $CDDBUSER $CDDBHOST $(cut -f2,3 -d' ' "$ABCDETEMPDIR/cddbquery") > "$ABCDETEMPDIR/cddbread.1"
- echo "done." >> "$ABCDETEMPDIR/cddbchoices"
- echo cddb-read-1-complete >> "$ABCDETEMPDIR/status"
- echo cddb-choice=1 >> "$ABCDETEMPDIR/status"
- fi
- # List out disc title/author and contents
- echo ---- "$(cut '-d ' -f4- "$ABCDETEMPDIR/cddbquery")" ---- >> "$ABCDETEMPDIR/cddbchoices"
- for TRACK in $(f_seq_row 1 $TRACKS)
- do
- echo $TRACK: "$(grep -a ^TTITLE$(expr $TRACK - 1)= "$ABCDETEMPDIR/cddbread.1" | cut -f2- -d= | tr -d \\r\\n)" >> "$ABCDETEMPDIR/cddbchoices"
- done
- echo >> "$ABCDETEMPDIR/cddbchoices"
+ NUM_CDDB_MATCHES=$(($NUM_CDDB_MATCHES + 1))
+ $CDDBTOOL read "$CDDBURL" "$CDDBPROTO" "$CDDBUSER" "$CDDBHOST" \
+ $(cut -f2,3 -d' ' "${SOURCE_WORKDIR}/cddbquery") \
+ > "${SOURCE_WORKDIR}/cddbread.${NUM_CDDB_MATCHES}"
+ cat "${SOURCE_WORKDIR}/cddbquery" | cut -f2- -d' ' > "${SOURCE_WORKDIR}/cddbquery.${NUM_CDDB_MATCHES}"
+ echo "cddb" > "${SOURCE_WORKDIR}/datasource.${NUM_CDDB_MATCHES}"
+ echo "cddb-read-${NUM_CDDB_MATCHES}-complete" >> "${ABCDETEMPDIR}/status"
;;
202|403|409|500|503)
# TODO: Explain these error codes a little more accurately:
# http://ftp.freedb.org/pub/freedb/misc/freedb_CDDB_protcoldoc.zip
# No match response:
- if [ $CDDBLASTMETHOD = "y" ]
- then
- # We're the caboose, so we need to generate the CDDB
- # template.
- vecho "Unable to find a match with ${CDDBMETHCHOICE}, generating CDDB template."
- case "$RESPONSECODE" in
- 202) echo "No CDDB match." >> "$ABCDETEMPDIR/cddbchoices" ;;
- 403|409) echo "CDDB entry is corrupt, or the handshake failed." >> "$ABCDETEMPDIR/cddbchoices" ;;
- 500|503) echo "CDDB unavailable." >> "$ABCDETEMPDIR/cddbchoices" ;;
- esac
- $CDDBTOOL template $(cat "$ABCDETEMPDIR/discid") > "$ABCDETEMPDIR/cddbread.0"
- # List out disc title/author and contents of template
- echo ---- Unknown Artist / Unknown Album ---- >> "$ABCDETEMPDIR/cddbchoices"
- UNKNOWNDISK=y
- for TRACK in $(f_seq_row 1 $TRACKS)
- do
- echo $TRACK: "$(grep -a ^TTITLE$(expr $TRACK - 1)= "$ABCDETEMPDIR/cddbread.0" | cut -f2- -d= | tr -d \\r\\n)" >> "$ABCDETEMPDIR/cddbchoices"
- done
- echo >> "$ABCDETEMPDIR/cddbchoices"
- echo cddb-read-0-complete >> "$ABCDETEMPDIR/status"
- echo cddb-choice=0 >> "$ABCDETEMPDIR/status"
- else
- # Template's the next chump's job.
- vecho "Unable to find a match with ${CDDBMETHCHOICE}, moving on to the next option."
- fi
;;
210|211)
# Multiple exact, (possibly multiple) inexact matches
- IN=
- if [ "$RESPONSECODE" = "211" ]; then IN=in; fi
- if [ "$(wc -l < "$ABCDETEMPDIR/cddbquery" | tr -d ' ')" -eq 3 ]; then
- echo "One ${IN}exact match:" >> "$ABCDETEMPDIR/cddbchoices"
- tail -n +2 "$ABCDETEMPDIR/cddbquery" | head -n 1 >> "$ABCDETEMPDIR/cddbchoices"
- echo cddb-choice=1 >> "$ABCDETEMPDIR/status"
- else
- echo "Multiple ${IN}exact matches:" >> "$ABCDETEMPDIR/cddbchoices"
- fi
vecho -n "Retrieving multiple matches... "
- grep -v ^[.]$ "$ABCDETEMPDIR/cddbquery" | ( X=0
- read DISCINFO # eat top line
- while read DISCINFO
- do
- X=$(expr $X + 1)
- if checkstatus cddb-read-$X-complete; then :; else
- $CDDBTOOL read $CDDBURL $CDDBPROTO $CDDBUSER $CDDBHOST $(echo $DISCINFO | cut -f1,2 -d' ') > "$ABCDETEMPDIR/cddbread.$X"
- echo cddb-read-$X-complete >> "$ABCDETEMPDIR/status"
- fi
- # List out disc title/author and contents
- echo \#$X: ---- "$DISCINFO" ---- >> "$ABCDETEMPDIR/cddbchoices"
- for TRACK in $(f_seq_row 1 $TRACKS)
+ grep -v '^[.]$' "${SOURCE_WORKDIR}/cddbquery" | (
+ # IN A SUB-SHELL - VARIABLES MODIFIED
+ # HERE DO NOT PERSIST IN THE PARENT
+ read DISCINFO # eat top line
+ while read DISCINFO
do
- echo $TRACK: "$(grep -a ^TTITLE$(expr $TRACK - 1)= "$ABCDETEMPDIR/cddbread.$X" | cut -f2- -d= | tr -d \\r\\n)" >> "$ABCDETEMPDIR/cddbchoices"
- done
- echo >> "$ABCDETEMPDIR/cddbchoices"
- done )
+ NUM_CDDB_MATCHES=$(($NUM_CDDB_MATCHES + 1))
+ if checkstatus "cddb-read-${NUM_CDDB_MATCHES}-complete"; then :; else
+ $CDDBTOOL read "$CDDBURL" "$CDDBPROTO" "$CDDBUSER" "$CDDBHOST" \
+ $(echo "$DISCINFO" | cut -f1,2 -d' ') \
+ > "${SOURCE_WORKDIR}/cddbread.${NUM_CDDB_MATCHES}"
+ echo "$DISCINFO" > "${SOURCE_WORKDIR}/cddbquery.${NUM_CDDB_MATCHES}"
+ echo "cddb" > "${SOURCE_WORKDIR}/datasource.${NUM_CDDB_MATCHES}"
+ echo "cddb-read-${NUM_CDDB_MATCHES}-complete" >> "${ABCDETEMPDIR}/status"
+ fi
+ done )
+ # Need to re-count the entries here to be able
+ # to incrememnt $NUM_CDDB_MATCHES in the
+ # parent
+ NUM_CDDB_MATCHES=$(($NUM_CDDB_MATCHES + $(echo "${SOURCE_WORKDIR}/datasource.*" | wc -w)))
vecho "done."
- CDDBCHOICES=$(expr $(cat "$ABCDETEMPDIR/cddbquery" | wc -l) - 2)
;;
999)
# Using local copy.
- for TRACK in $(f_seq_row 1 $TRACKS)
- do
- echo $TRACK: "$(grep -a ^TTITLE$(expr $TRACK - 1)= "$ABCDETEMPDIR/cddbread.1" | cut -f2- -d= | tr -d \\r\\n)" >> "$ABCDETEMPDIR/cddbchoices"
- done
- echo >> "$ABCDETEMPDIR/cddbchoices"
- echo cddb-read-1-complete >> "$ABCDETEMPDIR/status"
- echo cddb-choice=1 >> "$ABCDETEMPDIR/status"
+ NUM_CDDB_MATCHES=$(($NUM_CDDB_MATCHES + 1))
+ echo "cddb-read-${NUM_CDDB_MATCHES}-complete" >> "${ABCDETEMPDIR}/status"
;;
esac
- echo "cddb-readcomplete" >> "$ABCDETEMPDIR/status"
+ echo "cddb-readcomplete" >> "${ABCDETEMPDIR}/status"
+ for file in ${SOURCE_WORKDIR}/cddbread.* ${SOURCE_WORKDIR}/cddbquery.* ${SOURCE_WORKDIR}/datasource.*; do
+ if [ -f "$file" ]; then
+ cp "$file" "${ABCDETEMPDIR}"
+ fi
+ done
fi
}
do_cddbedit ()
{
if checkstatus cddb-edit >/dev/null; then
- CDDBDATA="$ABCDETEMPDIR/cddbread.$(checkstatus cddb-choice)"
+ CDDBDATA="${ABCDETEMPDIR}/cddbread.$(checkstatus cddb-choice)"
VARIOUSARTISTS="$(checkstatus variousartists)"
VARIOUSARTISTSTYLE="$(checkstatus variousartiststyle)"
return 0
# We should show the CDDB results both when we are not using the local CDDB repo
# or when we are using it but we could not find a proper match
if [ "$CDDBUSELOCAL" = "y" ] && [ "$CDDBLOCALSTATUS" = "notfound" ] || [ ! "$CDDBUSELOCAL" = "y" ]; then
- # Display the $ABCDETEMPDIR/cddbchoices file created above
- # Pick a pager so that if the tracks overflow the screen the user can still view everything
- if [ -r "$ABCDETEMPDIR/cddbchoices" ]; then
- CDDBCHOICES=$(expr $(cat "$ABCDETEMPDIR/cddbquery" | wc -l) - 2)
+ # Display the ${ABCDETEMPDIR}/cddbchoices file created above
+ if [ -r "${ABCDETEMPDIR}/cddbchoices" ]; then
CHOICE=$(checkstatus cddb-choice)
if [ -n "$CHOICE" ] ; then
- case $CDDBCHOICES in
- -1) if head -1 "$ABCDETEMPDIR/cddbquery" | grep -a "^$" > /dev/null 2>&1 ; then
- log error "CDDB query failed!"
- exit 1
- else
- cat "$ABCDETEMPDIR/cddbchoices"
- fi
- ;;
- 1) cat "$ABCDETEMPDIR/cddbchoices" ;;
+ case $NUM_CDDB_MATCHES in
+ 1) cat "${ABCDETEMPDIR}/cddbchoices" ;;
*)
- echo "Selected: #$CHOICE"
- do_cddbparse "$ABCDETEMPDIR/cddbread.$CHOICE"
+ ATITLE=$(grep -a ^DTITLE= "${ABCDETEMPDIR}/cddbread.$CHOICE" | cut -f2- -d= | tr -d \\r\\n)
+ SOURCE=$(cat "${ABCDETEMPDIR}/datasource.$CHOICE")
+ echo "Selected: #$CDCHOICENUM ($SOURCE) ($ATITLE)"
+ do_cddbparse "${ABCDETEMPDIR}/cddbread.$CHOICE"
;;
esac
else
- # The user has a choice to make, display the info in a pager if necessary
- if [ $(cat "$ABCDETEMPDIR/cddbchoices" | wc -l) -ge 24 ]; then
- page "$ABCDETEMPDIR/cddbchoices"
- else
- # It's all going to fit in one page, cat it
- cat "$ABCDETEMPDIR/cddbchoices" >&2
- fi
-
+ page "${ABCDETEMPDIR}/cddbchoices"
CDDBCHOICENUM=""
# Setting the choice to an impossible integer to avoid errors in the numeric comparisons
CDCHOICENUM=-1
# I'll take CDDB read #3 for $400, Alex
- while [ $CDCHOICENUM -lt 0 ] || [ $CDCHOICENUM -gt $CDDBCHOICES ]; do
- echo -n "Which entry would you like abcde to use (0 for none)? [0-$CDDBCHOICES]: " >&2
+ while [ $CDCHOICENUM -lt 0 ] || [ $CDCHOICENUM -gt $NUM_CDDB_MATCHES ]; do
+ echo -n "Which entry would you like abcde to use (0 for none)? [0-$NUM_CDDB_MATCHES]: " >&2
read CDDBCHOICE
[ X"$CDDBCHOICE" = "X" ] && CDDBCHOICE=1
if echo $CDDBCHOICE | grep -E "[[:space:]]*[[:digit:]]+,[[:digit:]]+[[:space:]]*" > /dev/null 2>&1 ; then
if [ ! X"$DIFF" = "X" ]; then
PARSECHOICE1=$(echo $CDDBCHOICE | cut -d"," -f1 | xargs printf %d 2>/dev/null)
PARSECHOICE2=$(echo $CDDBCHOICE | cut -d"," -f2 | xargs printf %d 2>/dev/null)
- if [ $PARSECHOICE1 -lt 1 ] || [ $PARSECHOICE1 -gt $CDDBCHOICES ] || \
- [ $PARSECHOICE2 -lt 1 ] || [ $PARSECHOICE2 -gt $CDDBCHOICES ] || \
- [ $PARSECHOICE1 -eq $PARSECHOICE2 ]; then
- echo "Invalid diff range. Please select two comma-separated numbers between 1 and $CDDBCHOICES" >&2
+ if [ "$PARSECHOICE1" -lt 1 ] || [ "$PARSECHOICE1" -gt "$NUM_CDDB_MATCHES" ] || \
+ [ "$PARSECHOICE2" -lt 1 ] || [ "$PARSECHOICE2" -gt "$NUM_CDDB_MATCHES" ] || \
+ [ "$PARSECHOICE1" -eq "$PARSECHOICE2" ]; then
+ echo "Invalid diff range." >&2
+ echo "Please select two comma-separated numbers between 1 and $NUM_CDDB_MATCHES" >&2
else
# We parse the 2 choices to diff, store them in temporary files and diff them.
for PARSECHOICE in $(echo $CDDBCHOICE | tr , \ ); do
- do_cddbparse "$ABCDETEMPDIR/cddbread.$PARSECHOICE" > "$ABCDETEMPDIR/cddbread.parsechoice.$PARSECHOICE"
+ do_cddbparse "${ABCDETEMPDIR}/cddbread.$PARSECHOICE" \
+ > "${ABCDETEMPDIR}/cddbread.parsechoice.$PARSECHOICE"
done
- echo "Showing diff between choices $PARSECHOICE1 and $PARSECHOICE2..." > "$ABCDETEMPDIR/cddbread.diff"
- $DIFF $DIFFOPTS "$ABCDETEMPDIR/cddbread.parsechoice.$PARSECHOICE1" "$ABCDETEMPDIR/cddbread.parsechoice.$PARSECHOICE2" >> "$ABCDETEMPDIR/cddbread.diff"
- if [ $(cat "$ABCDETEMPDIR/cddbread.diff" | wc -l) -ge 24 ]; then
- page "$ABCDETEMPDIR/cddbread.diff"
- else
- cat "$ABCDETEMPDIR/cddbread.diff" >&2
- fi
+ echo "Showing diff between choices $PARSECHOICE1 and $PARSECHOICE2..." \
+ > "${ABCDETEMPDIR}/cddbread.diff"
+ $DIFF $DIFFOPTS "${ABCDETEMPDIR}/cddbread.parsechoice.$PARSECHOICE1" \
+ "${ABCDETEMPDIR}/cddbread.parsechoice.$PARSECHOICE2" \
+ >> "${ABCDETEMPDIR}/cddbread.diff"
+ page "${ABCDETEMPDIR}/cddbread.diff"
fi
else
- echo "The diff program was not found in your path. Please choose a number between 0 and $CDDBCHOICES." >&2
+ echo "The diff program was not found in your path." >&2
+ echo "Please choose a number between 0 and $NUM_CDDB_MATCHES." >&2
fi
elif echo $CDDBCHOICE | grep -E "[[:space:]]*[[:digit:]]+[[:space:]]*" > /dev/null 2>&1 ; then
# Make sure we get a valid choice
CDCHOICENUM=$(echo $CDDBCHOICE | xargs printf %d 2>/dev/null)
- if [ $CDCHOICENUM -lt 0 ] || [ $CDCHOICENUM -gt $CDDBCHOICES ]; then
- echo "Invalid selection. Please choose a number between 0 and $CDDBCHOICES." >&2
+ if [ "$CDCHOICENUM" -lt 0 ] || [ "$CDCHOICENUM" -gt "$NUM_CDDB_MATCHES" ]; then
+ echo "Invalid selection. Please choose a number between 0 and $NUM_CDDB_MATCHES." >&2
fi
fi
done
if [ "$CDCHOICENUM" = "0" ]; then
vecho "Creating empty CDDB template..."
UNKNOWNDISK=y
- $CDDBTOOL template $(cat "$ABCDETEMPDIR/discid") > "$ABCDETEMPDIR/cddbread.0"
+ $CDDBTOOL template $(cat "${ABCDETEMPDIR}/cddbdiscid") > "${ABCDETEMPDIR}/cddbread.0"
+ echo "template" > "${ABCDETEMPDIR}/datasource.0"
else
- echo "Selected: #$CDCHOICENUM ($(grep -a ^DTITLE= "$ABCDETEMPDIR/cddbread.$CDCHOICENUM" | cut -f2- -d= | tr -d \\r\\n))" >&2
- do_cddbparse "$ABCDETEMPDIR/cddbread.$CDCHOICENUM"
+ ATITLE=$(grep -a ^DTITLE= "${ABCDETEMPDIR}/cddbread.$CDCHOICENUM" | cut -f2- -d= | tr -d \\r\\n)
+ SOURCE=$(cat "${ABCDETEMPDIR}/datasource.$CDCHOICENUM")
+ echo "Selected: #$CDCHOICENUM ($SOURCE) ($ATITLE)" >&2
fi
- echo "cddb-choice=$CDCHOICENUM" >> "$ABCDETEMPDIR/status"
+ do_cddbparse "${ABCDETEMPDIR}/cddbread.$CDCHOICENUM"
+ echo "cddb-choice=$CDCHOICENUM" >> "${ABCDETEMPDIR}/status"
fi
fi
else
# We need some code to show the selected option when local repository is selected and we have found a match
vecho "Using cached CDDB match..." >&2
- # Display the $ABCDETEMPDIR/cddbchoices file created above
- # Pick a pager so that if the tracks overflow the screen the user can still view everything
- if [ -r "$ABCDETEMPDIR/cddbchoices" ]; then
- CDDBCHOICES=$(expr $(cat "$ABCDETEMPDIR/cddbquery" | wc -l) - 2)
+ # Display the ${ABCDETEMPDIR}/cddbchoices file created above
+ if [ -r "${ABCDETEMPDIR}/cddbchoices" ]; then
CHOICE=$(checkstatus cddb-choice)
if [ "$USELOCALRESP" = "y" ]; then :; else
if [ -n "$CHOICE" ] ; then
- case $CDDBCHOICES in
+ case $NUM_CDDB_MATCHES in
0)
UNKNOWNDISK=y
echo "Selected template."
;;
- 1) cat "$ABCDETEMPDIR/cddbchoices" ;;
+ 1) cat "${ABCDETEMPDIR}/cddbchoices" ;;
*)
echo "Selected: #$CHOICE"
- do_cddbparse "$ABCDETEMPDIR/cddbread.$CHOICE"
+ do_cddbparse "${ABCDETEMPDIR}/cddbread.$CHOICE"
;;
esac
fi
else
# We're noninteractive - pick the first choice.
# But in case we run a previous instance and selected a choice, use it.
- if [ -r "$ABCDETEMPDIR/cddbchoices" ]; then
+ if [ -r "${ABCDETEMPDIR}/cddbchoices" ]; then
# Show the choice if we are not using the locally stored one
# or when the local search failed to find a match.
PREVIOUSCHOICE=$(checkstatus cddb-choice)
if [ "$CDDBUSELOCAL" = "y" ] && [ "$CDDBLOCALSTATUS" = "notfound" ] || [ ! "$CDDBUSELOCAL" = "y" ]; then
#if [ "$PREVIOUSCHOICE" ]; then
- cat "$ABCDETEMPDIR/cddbchoices"
+ cat "${ABCDETEMPDIR}/cddbchoices"
#fi
fi
if [ ! -z "$PREVIOUSCHOICE" ] ; then
CDCHOICENUM=$PREVIOUSCHOICE
else
CDCHOICENUM=1
- echo "cddb-choice=$CDCHOICENUM" >> "$ABCDETEMPDIR/status"
+ echo "cddb-choice=$CDCHOICENUM" >> "${ABCDETEMPDIR}/status"
fi
- echo "Selected: #$CDCHOICENUM ($(grep -a ^DTITLE= "$ABCDETEMPDIR/cddbread.$CDCHOICENUM" | cut -f2- -d= | tr -d \\r\\n))" >&2
+ echo "Selected: #$CDCHOICENUM ($(grep -a ^DTITLE= "${ABCDETEMPDIR}/cddbread.$CDCHOICENUM" | cut -f2- -d= | tr -d \\r\\n))" >&2
fi
fi
echo "abcde: internal error: cddb-choice not recorded." >&2
exit 1
fi
- CDDBDATA="$ABCDETEMPDIR/cddbread.$(checkstatus cddb-choice)"
+ CDDBDATA="${ABCDETEMPDIR}/cddbread.$(checkstatus cddb-choice)"
+ CDDBSOURCE=$(cat "${ABCDETEMPDIR}/datasource.$(checkstatus cddb-choice)")
echo -n "Edit selected CDDB data " >&2
if [ "$INTERACTIVE" = "y" ]; then
if [ "$UNKNOWNDISK" = "y" ]; then
if [ -x "/usr/bin/sensible-editor" ]; then
/usr/bin/sensible-editor "$CDDBDATA"
elif [ -n "$EDITOR" ]; then
- if [ -x $(which "${EDITOR%%\ *}") ]; then
+ if [ -x "$(which "${EDITOR%%\ *}")" ]; then
# That failed, try to load the preferred editor, starting
# with their EDITOR variable
- eval $(echo "$EDITOR") \"$CDDBDATA\"
+ $EDITOR "$CDDBDATA"
fi
# If that fails, check for a vi
elif which vi >/dev/null 2>&1; then
DEFAULTSTYLE=1
# Need NUMTRACKS before cddb-tool will return it:
NUMTRACKS=$(grep -a -E '^TTITLE[0-9]+=' "$CDDBDATA" | wc -l)
- if [ "$(grep -ac "^TTITLE.*\/" "$CDDBDATA")" -gt "$(expr $NUMTRACKS / 2 )" ]; then
+ if [ "$(grep -ac "^TTITLE.*\/" "$CDDBDATA")" -gt "$(( $NUMTRACKS / 2 ))" ]; then
# More than 1/2 tracks contain a "/", so guess forward
DEFAULTSTYLE=1
- elif [ "$(grep -ac "^TTITLE.*\-" "$CDDBDATA")" -gt "$(expr $NUMTRACKS / 2 )" ]; then
+ elif [ "$(grep -ac "^TTITLE.*\-" "$CDDBDATA")" -gt "$(( $NUMTRACKS / 2 ))" ]; then
# More than 1/2 contain a "-", so guess forward-dash
DEFAULTSTYLE=2
- elif [ "$(grep -ac "^TTITLE.*(.*)" "$CDDBDATA")" -gt "$(expr $NUMTRACKS / 2 )" ]; then
+ elif [ "$(grep -ac "^TTITLE.*(.*)" "$CDDBDATA")" -gt "$(( $NUMTRACKS / 2 ))" ]; then
# More than 1/2 contain something in parens, so guess trailing-paren
DEFAULTSTYLE=6
fi
fi
VARIOUSARTISTSTYLE=$(echo 0$VARIOUSARTISTSTYLE | xargs printf %d)
# If they press Enter, then the default style (0) was chosen
- while [ $VARIOUSARTISTSTYLE -lt 0 ] || [ $VARIOUSARTISTSTYLE -gt 7 ]; do
+ while [ "$VARIOUSARTISTSTYLE" -lt 0 ] || [ "$VARIOUSARTISTSTYLE" -gt 7 ]; do
echo "Invalid selection. Please choose a number between 1 and 7."
echo -n "Selection [1-7]: "
read VARIOUSARTISTSTYLE
- VARIOUSARTISTSTYLE=$(echo 0$VARIOUSARTISTSTYLE | xargs printf %d)
+ VARIOUSARTISTSTYLE=$(echo "0$VARIOUSARTISTSTYLE" | xargs printf "%d")
done
if [ "$VARIOUSARTISTSTYLE" = "0" ]; then
- VARIOUSARTISTSTYLE=$DEFAULTSTYLE
+ VARIOUSARTISTSTYLE="$DEFAULTSTYLE"
fi
vecho "Selected: $VARIOUSARTISTSTYLE"
case "$VARIOUSARTISTSTYLE" in
esac
fi
- echo "variousartists=$VARIOUSARTISTS" >> "$ABCDETEMPDIR/status"
- echo "variousartiststyle=$VARIOUSARTISTSTYLE" >> "$ABCDETEMPDIR/status"
+ echo "variousartists=$VARIOUSARTISTS" >> "${ABCDETEMPDIR}/status"
+ echo "variousartiststyle=$VARIOUSARTISTSTYLE" >> "${ABCDETEMPDIR}/status"
- if [ "$EDITCDDB" = "y" ] && [ "$CDDBMETHOD" = "cddb" ] && [ "$UNINTENTIONALLY_ANGER_THE_FREEDB_PEOPLE" = "y" ]; then
+ if [ "$EDITCDDB" = "y" ] && [ "$CDDBSOURCE" = "cddb" ] && [ "$UNINTENTIONALLY_ANGER_THE_FREEDB_PEOPLE" = "y" ]; then
if [ "$CDDBDATAMD5SUM" != "" ] && [ "$CDDBDATAMD5SUM" != "$($MD5SUM "$CDDBDATA" | cut -d " " -f 1)" ]; then
# This works but does not have the necessary error checking
# yet. If you are familiar with the CDDB spec
done
if [ "$YESNO" = "y" ] || [ "$YESNO" = "Y" ]; then
echo -n "Sending..."
- $CDDBTOOL send "$CDDBDATA" $CDDBSUBMIT
+ $CDDBTOOL send "$CDDBDATA" "$CDDBSUBMIT"
echo "done."
fi
fi
# Cache edited CDDB entry in the user's cddb dir
if [ "$CDDBCOPYLOCAL" = "y" ]; then
# Make sure the cache directory exists
- mkdir -p $CDDBLOCALDIR
- cat "$CDDBDATA" | tail -n $(expr $(cat "$CDDBDATA" | wc -l ) - 1 ) > ${CDDBLOCALDIR}/$(echo "$TRACKINFO" | cut -d' ' -f1)
+ mkdir -p "$CDDBLOCALDIR"
+ NUM_LINES=$(( $(wc -l < "$CDDBDATA") - 1 ))
+ OUTPUT_FILE="$(echo "$CDDBTRACKINFO" | cut -d' ' -f1)"
+ tail -n "$NUM_LINES" < "$CDDBDATA" > "${CDDBLOCALDIR}/${OUTPUT_FILE}"
fi
- echo "cddb-edit" >> "$ABCDETEMPDIR/status"
+ echo "cddb-edit" >> "${ABCDETEMPDIR}/status"
}
# do_getalbumart
YEAR=${CDYEAR:-$CDYEAR}
# have we got a musicbrainz mbid or amazon asin?
case "$CDDBMETHOD" in
- musicbrainz)
+ *musicbrainz*)
# try musicbrainz mbid
- if [ -s "$ABCDETEMPDIR/mbid.$(checkstatus cddb-choice)" ]; then
- MBID=$(cat "$ABCDETEMPDIR/mbid.$(checkstatus cddb-choice)")
+ if [ -s "${ABCDETEMPDIR}/mbid.$(checkstatus cddb-choice)" ]; then
+ MBID=$(cat "${ABCDETEMPDIR}/mbid.$(checkstatus cddb-choice)")
vecho "trying to get cover from coverartarchive.orq with musicbrainz mbid $MBID" >&2
ALBUMARTURL="http://coverartarchive.org/release/$MBID/front"
vecho "cover URL: $ALBUMARTURL" >&2
- $HTTPGET "$ALBUMARTURL" > "$ABCDETEMPDIR/$ALBUMARTFILE"
+ $HTTPGET "$ALBUMARTURL" > "${ABCDETEMPDIR}/$ALBUMARTFILE"
if [ $? -ne 0 ]; then
vecho "could not download cover from musicbrainz" >&2
# try amazon asin
- if [ -s "$ABCDETEMPDIR/asin.$(checkstatus cddb-choice)" ]; then
- ASIN=$(cat "$ABCDETEMPDIR/asin.$(checkstatus cddb-choice)")
+ if [ -s "${ABCDETEMPDIR}/asin.$(checkstatus cddb-choice)" ]; then
+ ASIN=$(cat "${ABCDETEMPDIR}/asin.$(checkstatus cddb-choice)")
vecho "trying to get cover from amazon.com with asin $ASIN" >&2
ALBUMARTURL="http://ec1.images-amazon.com/images/P/$ASIN.01.LZZZZZZZZ.jpg"
vecho "cover URL: $ALBUMARTURL" >&2
- $HTTPGET "$ALBUMARTURL" > "$ABCDETEMPDIR/$ALBUMARTFILE"
+ $HTTPGET "$ALBUMARTURL" > "${ABCDETEMPDIR}/$ALBUMARTFILE"
if [ $? -ne 0 ]; then
vecho "could not download cover from amazon" >&2
else
# Check that size is reasonable; sometimes when there is no cover image
# on amazon.com a 1x1 pixel gif image will be downloaded instead:
- FILESIZE=$(wc -c < "$ABCDETEMPDIR/$ALBUMARTFILE")
+ FILESIZE=$(wc -c < "${ABCDETEMPDIR}/$ALBUMARTFILE")
if [ "$FILESIZE" -lt 1024 ]; then
- rm "$ABCDETEMPDIR/$ALBUMARTFILE"
+ rm "${ABCDETEMPDIR}/$ALBUMARTFILE"
vecho "could not download cover from amazon" >&2
fi
fi
;;
esac
# use glyrc
- if [ ! -s "$ABCDETEMPDIR/$ALBUMARTFILE" ]; then
+ if [ ! -s "${ABCDETEMPDIR}/$ALBUMARTFILE" ]; then
vecho "trying to get cover with glyrc for $ARTISTFILE / $ALBUMFILE" >&2
- $GLYRC cover --artist "$ARTISTFILE" --album "$ALBUMFILE" --write "$ABCDETEMPDIR/$ALBUMARTFILE" $GLYRCOPTS
+ $GLYRC cover --artist "$ARTISTFILE" --album "$ALBUMFILE" --write "${ABCDETEMPDIR}/$ALBUMARTFILE" $GLYRCOPTS
if [ $? -ne 0 ]; then
vecho "could not download cover with glyrc" >&2
else
fi
fi
if [ "$INTERACTIVE" = "y" ]; then
- if [ -s "$ABCDETEMPDIR/$ALBUMARTFILE" ]; then
+ if [ -s "${ABCDETEMPDIR}/$ALBUMARTFILE" ]; then
# display properties of coverart when identify is available
- if new_checkexec $IDENTIFY; then
- $IDENTIFY $IDENTIFYOPTS "$ABCDETEMPDIR/$ALBUMARTFILE" >&2
+ if new_checkexec "$IDENTIFY"; then
+ $IDENTIFY $IDENTIFYOPTS "${ABCDETEMPDIR}/$ALBUMARTFILE" >&2
fi
# display coverart when DISPLAY is set and display command is available
- if new_checkexec $DISPLAYCMD && [ "$DISPLAY" != "" ]; then
- $DISPLAYCMD $DISPLAYCMDOPTS "$ABCDETEMPDIR/$ALBUMARTFILE" >&2 &
+ if new_checkexec "$DISPLAYCMD" && [ "$DISPLAY" != "" ]; then
+ $DISPLAYCMD $DISPLAYCMDOPTS "${ABCDETEMPDIR}/$ALBUMARTFILE" >&2 &
fi
else
# nothing downloaded yet
read ALBUMARTURL
if [ ! -z "$ALBUMARTURL" ]; then
if [[ ${ALBUMARTURL} =~ (https?|ftp|file)://.* ]]; then
- $HTTPGET "$ALBUMARTURL" > "$ABCDETEMPDIR/$ALBUMARTFILE"
- if [ ! -s "$ABCDETEMPDIR/$ALBUMARTFILE" ]; then
+ $HTTPGET "$ALBUMARTURL" > "${ABCDETEMPDIR}/$ALBUMARTFILE"
+ if [ ! -s "${ABCDETEMPDIR}/$ALBUMARTFILE" ]; then
vecho "unable to download $ALBUMARTURL" >&2
fi
else # it's a local path
- cp "$ALBUMARTURL" "$ABCDETEMPDIR/$ALBUMARTFILE"
- if [ ! -s "$ABCDETEMPDIR/$ALBUMARTFILE" ]; then
- vecho "unable to copy $ALBUMARTURL to $ABCDETEMPDIR/$ALBUMARTFILE" >&2
+ cp "$ALBUMARTURL" "${ABCDETEMPDIR}/$ALBUMARTFILE"
+ if [ ! -s "${ABCDETEMPDIR}/$ALBUMARTFILE" ]; then
+ vecho "unable to copy $ALBUMARTURL to ${ABCDETEMPDIR}/$ALBUMARTFILE" >&2
fi
fi
fi
fi
fi
# convert to ALBUMARTTYPE if ImageMagick is available, if not assume correct type
- if [ -s "$ABCDETEMPDIR/$ALBUMARTFILE" ] && new_checkexec $IDENTIFY; then
- ALBUMARTURLTYPE=$($IDENTIFY "$ABCDETEMPDIR/$ALBUMARTFILE" | cut -d' ' -f2)
- if [ "$ALBUMARTURLTYPE" != "$ALBUMARTTYPE" -o "$ALBUMARTALWAYSCONVERT" = "y" ]; then
- if new_checkexec $CONVERT; then
- mv "$ABCDETEMPDIR/$ALBUMARTFILE" "$ABCDETEMPDIR/$ALBUMARTFILE.tmp"
- $CONVERT "$ABCDETEMPDIR/$ALBUMARTFILE.tmp" $CONVERTOPTS "$ABCDETEMPDIR/$ALBUMARTFILE"
- rm -f "$ABCDETEMPDIR/$ALBUMARTFILE.tmp"
+ if [ -s "${ABCDETEMPDIR}/$ALBUMARTFILE" ] && new_checkexec "$IDENTIFY"; then
+ ALBUMARTURLTYPE=$($IDENTIFY "${ABCDETEMPDIR}/$ALBUMARTFILE" | cut -d' ' -f2)
+ if [ "$ALBUMARTURLTYPE" != "$ALBUMARTTYPE" ] || [ "$ALBUMARTALWAYSCONVERT" = "y" ]; then
+ if new_checkexec "$CONVERT"; then
+ mv "${ABCDETEMPDIR}/$ALBUMARTFILE" "${ABCDETEMPDIR}/$ALBUMARTFILE.tmp"
+ $CONVERT "${ABCDETEMPDIR}/$ALBUMARTFILE.tmp" $CONVERTOPTS "${ABCDETEMPDIR}/$ALBUMARTFILE"
+ rm -f "${ABCDETEMPDIR}/$ALBUMARTFILE.tmp"
else
- rm -f "$ABCDETEMPDIR/$ALBUMARTFILE"
- vecho "sorry, cannot convert $ALBUMARTURLTYPE to $ALBUMARTTYPE without ImageMagick convert" >&2
+ rm -f "${ABCDETEMPDIR}/$ALBUMARTFILE"
+ vecho "sorry, cannot convert $ALBUMARTURLTYPE to $ALBUMARTTYPE" >&2
+ vecho "without ImageMagick convert" >&2
fi
fi
fi
# copy to target directories
- if [ -s "$ABCDETEMPDIR/$ALBUMARTFILE" ]; then
- for OUTPUT in $(echo $OUTPUTTYPE | tr , \ )
+ if [ -s "${ABCDETEMPDIR}/$ALBUMARTFILE" ]; then
+ for OUTPUT in $(echo "$OUTPUTTYPE" | tr , \ )
do
# put cover in the same place as the album
if [ "$ONETRACK" = "y" ] ; then
FINALALBUMARTDIR="$(dirname "$OUTPUTDIR/$ALBUMARTDIR")"
vecho "copying cover to target directory $FINALALBUMARTDIR" >&2
mkdir -p "$FINALALBUMARTDIR"
- cp "$ABCDETEMPDIR/$ALBUMARTFILE" "$FINALALBUMARTDIR"
+ cp "${ABCDETEMPDIR}/$ALBUMARTFILE" "$FINALALBUMARTDIR"
done
- rm -f "$ABCDETEMPDIR/$ALBUMARTFILE"
- echo "get-album-art=$ALBUMARTURL" >> "$ABCDETEMPDIR/status"
+ rm -f "${ABCDETEMPDIR}/$ALBUMARTFILE"
+ echo "get-album-art=$ALBUMARTURL" >> "${ABCDETEMPDIR}/status"
else
log warning "could not get cover"
- echo "get-album-art=none" >> "$ABCDETEMPDIR/status"
+ echo "get-album-art=none" >> "${ABCDETEMPDIR}/status"
fi
}
+# Optionally embed the albumart downloaded by the getalbumart fuction.
+# FIXME: It would be nice to have this also selectable from within the
+# FIXME: getalbumart function itself. Andrew
+do_embedalbumart()
+{
+ # Set variables:
+ ALBUMFILE="$(mungealbumname "$DALBUM")"
+ ARTISTFILE="$(mungeartistname "$DARTIST")"
+ GENRE="$(mungegenre "$GENRE")"
+ YEAR=${CDYEAR:-$CDYEAR}
+
+ # Allow for multiple output formats:
+ for OUTPUT in $(echo "$OUTPUTTYPE" | tr , \ )
+ do
+ # Find the output directory for multi track encodes:
+ if [ "$ONETRACK" != "y" ] ; then
+ if [ "$VARIOUSARTISTS" = "y" ] ; then
+ FINDPATH="$(eval echo "$VAOUTPUTFORMAT")"
+ else
+ FINDPATH="$(eval echo "$OUTPUTFORMAT")"
+ fi
+ fi
+ # Find the output directory for single track encodes:
+ if [ "$ONETRACK" = "y" ] ; then
+ if [ "$VARIOUSARTISTS" = "y" ] ; then
+ FINDPATH="$(eval echo "$VAONETRACKOUTPUTFORMAT")"
+ else
+ FINDPATH="$(eval echo "$ONETRACKOUTPUTFORMAT")"
+ fi
+ fi
+
+ FINALDIR="$(dirname "$OUTPUTDIR/$FINDPATH")"
+ cd "$FINALDIR"
+
+# Instructions for each format, feel free to add more. It would be nice to
+# make the backup directory selectable and perhaps also have an option for
+# the bold to simply have the image deleted. Work for another day... Andrew.
+ if [ -e "$ALBUMARTFILE" ] ; then
+ case "$OUTPUT" in
+ mp3)
+ for i in *.mp3
+ do
+ "$EYED3" --add-image "$ALBUMARTFILE":FRONT_COVER "$i"
+ done
+ mkdir "$FINALDIR"/albumart_backup
+ mv "$ALBUMARTFILE" "$FINALDIR"/albumart_backup
+ vecho "Successfully embedded the album art into your $OUTPUT tracks" >&2
+ ;;
+ flac)
+ for i in *.flac
+ do
+ "$METAFLAC" --import-picture-from="$ALBUMARTFILE" "$i"
+ done
+ mkdir "$FINALDIR"/albumart_backup
+ mv "$ALBUMARTFILE" "$FINALDIR"/albumart_backup
+ vecho "Successfully embedded the album art into your $OUTPUT tracks" >&2
+ ;;
+ m4a)
+ for i in *.m4a
+ do
+ "$ATOMICPARSLEY" "$i" --artwork "$ALBUMARTFILE" --overWrite
+ done
+ mkdir "$FINALDIR"/albumart_backup
+ mv "$ALBUMARTFILE" "$FINALDIR"/albumart_backup
+ vecho "Successfully embedded the album art into your $OUTPUT tracks" >&2
+ ;;
+ wv)
+ for i in *.wv
+ do
+ "$WVTAG" --write-binary-tag "Cover Art (Front)=@$ALBUMARTFILE" "$i"
+ done
+ mkdir "$FINALDIR"/albumart_backup
+ mv "$ALBUMARTFILE" "$FINALDIR"/albumart_backup
+ vecho "Successfully embedded the album art into your $OUTPUT tracks" >&2
+ ;;
+ ogg)
+ # ----------------
+ # This technique is drawn from 2 sources (the first link being the primary source):
+ # 1. https://github.com/biapy/howto.biapy.com/blob/master/various/mussync-tools
+ # 2. https://github.com/acabal/scripts/blob/master/ogg-cover-art
+ # In abcde a few steps are used in this sequence:
+ #
+ # 1. Create a 'legal' header for the cover art image
+ # 2. Makes a copy of the existing tags
+ # 3. base64 the cover art image
+ # 4. Copy the original tags + the base64 image back to the original ogg file
+ #
+ # Might need some fine tuning but it is a start for abcde 2.8.2 Andrew.
+ # FIXME: I am not sure if there is a maximum size for images converted in this
+ # way, but this could be perhaps handled by CONVERTOPTS called from do_getalbumart.
+ # ----------------
+ # First some variables we can reuse:
+ # Use MIMETYPECOVER to allow use of either png or the more common jpeg:
+ MIMETYPECOVER=$(file -b --mime-type "$ALBUMARTFILE")
+ EXPORTTAGS="${ABCDETEMPDIR}/export_ogg_tags"
+ BUILDHEADER="${ABCDETEMPDIR}/build_header"
+ # Now build the header, gory details are here:
+ # https://xiph.org/flac/format.html#metadata_block_picture
+ # Picture Type:
+ printf "0: %.8x" 3 | xxd -r -g0 > "$BUILDHEADER"
+ # Mime type length
+ printf "0: %.8x" $(echo -n "$MIMETYPECOVER" | wc -c) | xxd -r -g0 >> "$BUILDHEADER"
+ # Mime type:
+ echo -n "$MIMETYPECOVER" >> "$BUILDHEADER"
+ # Description length. FIXME: I have used 'Cover Image' but I am not sure
+ # if this is better left as an empty field. Andrew
+ printf "0: %.8x" $(echo -n "Cover Image" | wc -c) | xxd -r -g0 >> "$BUILDHEADER"
+ # Description:
+ echo -n "Cover Image" >> "$BUILDHEADER"
+ # Picture width:
+ printf "0: %.8x" 0 | xxd -r -g0 >> "$BUILDHEADER"
+ # Picture height:
+ printf "0: %.8x" 0 | xxd -r -g0 >> "$BUILDHEADER"
+ # Picture color depth:
+ printf "0: %.8x" 0 | xxd -r -g0 >> "$BUILDHEADER"
+ # Picture color count:
+ printf "0: %.8x" 0 | xxd -r -g0 >> "$BUILDHEADER"
+ # Image file size:
+ printf "0: %.8x" $(wc -c "$ALBUMARTFILE" | cut --delimiter=' ' --fields=1) | xxd -r -g0 >> "$BUILDHEADER"
+ # cat the image file:
+ cat "$ALBUMARTFILE" >> "$BUILDHEADER"
+ # Now process each ogg file by first exporting the original tags then
+ # appending the cover image and finally copying the whole thing back
+ # to the original image:
+ for i in *.ogg
+ do
+ # Make a backup of the existing tags:
+ "$VORBISCOMMENT" --list --raw "$i" > "EXPORTTAGS"
+ # base64 the file and then mix it all together with the exported tags:
+ echo "metadata_block_picture=$(base64 --wrap=0 < "$BUILDHEADER")" >> "EXPORTTAGS"
+ # Update the original ogg file with exported tags and the appended base64'd image:
+ "$VORBISCOMMENT" --write --raw --commentfile "EXPORTTAGS" "$i"
+ # Delete the EXPORTTAGS file ready to be recreated for the next file in the loop,
+ # note that the header file BUILDHEADER will be reused for each file in the loop:
+ rm "EXPORTTAGS"
+ done
+ mkdir "$FINALDIR"/albumart_backup
+ mv "$ALBUMARTFILE" "$FINALDIR"/albumart_backup
+ vecho "Successfully embedded the album art into your $OUTPUT tracks" >&2
+ ;;
+ *) vecho "Sorry, abcde does not embed album art for the $OUTPUT container..." >&2
+ esac
+ else
+ vecho "Suitable cover image not found, no embedding done..." >&2
+ fi
+done
+}
+
# do_cdread [tracknumber]
# do_cdread onetrack [firsttrack] [lasttrack]
#
# the user said
# We need the first and last track for cdda2wav/icedax
FIRSTTRACK=$2
- LASTTRACK=$(expr $3 + 0)
+ LASTTRACK=$(($3 + 0))
UTRACKNUM=$FIRSTTRACK
case "$CDROMREADERSYNTAX" in
flac) READTRACKNUMS="-" ;;
else
UTRACKNUM=$1
fi
- CDDBTRACKNUM=$(expr $UTRACKNUM - 1)
+ CDDBTRACKNUM=$(expr $UTRACKNUM - 1) # Unpad
if [ "$USEPIPES" = "y" ]; then
TEMPARG="PIPERIPPER_$CDROMREADERSYNTAX"
FILEARG="$( eval echo "\$$TEMPARG" )"
PIPE_MESSAGE="and encoding "
else
- WAVDATA="$ABCDETEMPDIR/track$UTRACKNUM.wav"
+ WAVDATA="${ABCDETEMPDIR}/track$UTRACKNUM.wav"
case "$CDROMREADERSYNTAX" in
## FIXME ## Find the cases for flac, to avoid exceptions
flac)
### FIXME ### Shall we just use -o $FILEARG ??
flac)
# Avoid problems with math expressions by unpadding the given UTRACKNUM
- STRIPTRACKNUM=$(expr $UTRACKNUM + 0)
- nice $READNICE $FLAC -d -f --cue=${READTRACKNUMS:-$STRIPTRACKNUM.1-$(($STRIPTRACKNUM + 1)).0} "$FILEARG" "$CDROM" ;;
+ STRIPTRACKNUM=$(expr $UTRACKNUM + 0 )
+ nice $READNICE $FLAC -d -f --cue="${READTRACKNUMS:-$STRIPTRACKNUM.1-$(($STRIPTRACKNUM + 1)).0}" "$FILEARG" "$CDROM" ;;
cdparanoia|libcdio)
if [ "$USEPIPES" = "y" ]; then
- nice $READNICE $CDROMREADER -$CDPARANOIACDROMBUS "$CDROM" ${READTRACKNUMS:-$UTRACKNUM} "$FILEARG"
+ nice $READNICE $CDROMREADER -"$CDPARANOIACDROMBUS" "$CDROM" "${READTRACKNUMS:-$UTRACKNUM}" "$FILEARG"
else
- nice $READNICE $CDROMREADER -$CDPARANOIACDROMBUS "$CDROM" ${READTRACKNUMS:-$UTRACKNUM} "$FILEARG" >&2
+ nice $READNICE $CDROMREADER -"$CDPARANOIACDROMBUS" "$CDROM" "${READTRACKNUMS:-$UTRACKNUM}" "$FILEARG" >&2
fi
;;
cdda2wav|icedax)
if [ "$OSFLAVOUR" = "OSX" ] ; then
# Hei, we have to unmount the device before running anything like cdda2wav/icedax in OSX
- diskutil unmount ${CDROM#/dev/}
+ diskutil unmount "${CDROM#/dev/}"
# Also, in OSX the cdrom device for cdda2wav/icedax changes...
CDDA2WAVCDROM="IODVDServices"
- elif [ "$OSFLAVOUR" = "FBSD" ] ; then
+ elif [ "$OSFLAVOUR" = "FBSD" ] || [ "$OSFLAVOUR" = "IRIX" ]; then
CDDA2WAVCDROM="$CDROMID"
else
if [ "$CDROMID" = "" ]; then
fi
fi
if [ "$USEPIPES" = "y" ]; then
- nice $READNICE $CDROMREADER -D $CDDA2WAVCDROM -t ${READTRACKNUMS:-$UTRACKNUM} "$FILEARG"
+ nice $READNICE $CDROMREADER -D "$CDDA2WAVCDROM" -t "${READTRACKNUMS:-$UTRACKNUM}" "$FILEARG"
else
- nice $READNICE $CDROMREADER -D $CDDA2WAVCDROM -t ${READTRACKNUMS:-$UTRACKNUM} "$FILEARG" >&2
+ nice $READNICE $CDROMREADER -D "$CDDA2WAVCDROM" -t "${READTRACKNUMS:-$UTRACKNUM}" "$FILEARG" >&2
fi
;;
dagrab)
# I cannot get USEPIPES to work with dagrab so just this:
- nice $READNICE $CDROMREADER -d "$CDROM" -f "$FILEARG" -v $UTRACKNUM >&2
+ nice $READNICE $CDROMREADER -d "$CDROM" -f "$FILEARG" -v "$UTRACKNUM" >&2
;;
pird)
if [ "$USEPIPES" = "y" ]; then
- nice $READNICE $CDROMREADER -j ${READTRACKNUMS:-$UTRACKNUM} "$CDROM" "$FILEARG"
+ nice $READNICE $CDROMREADER -j "${READTRACKNUMS:-$UTRACKNUM}" "$CDROM" "$FILEARG"
else
# Write ripped audio data to stdout and redirect to $FILEARG.
# Progress is written to stderr by default and thus >&2 is not required.
- nice $READNICE $CDROMREADER -j ${READTRACKNUMS:-$UTRACKNUM} "$CDROM" "$PIPERIPPER_pird" > "$FILEARG"
+ nice $READNICE $CDROMREADER -j "${READTRACKNUMS:-$UTRACKNUM}" "$CDROM" "$PIPERIPPER_pird" > "$FILEARG"
fi
;;
cddafs)
# Find the track's mounted path
- REALTRACKNUM=$(expr $UTRACKNUM + 0)
+ REALTRACKNUM=$(expr $UTRACKNUM + 0) # Unpad
FILEPATH=$(mount | grep "$CDROM on" | sed 's/^[^ ]* on \(.*\) (.*/\1/')
FILEPATH=$(find "$FILEPATH" | grep "/$REALTRACKNUM ");
# If the file exists, copy it
fi ;;
debug)
if [ "$USEPIPES" = "y" ]; then
- nice $READNICE $CDROMREADER -$CDPARANOIACDROMBUS "$CDROM" -w $UTRACKNUM-[:1] "$FILEARG"
+ nice $READNICE $CDROMREADER -"$CDPARANOIACDROMBUS" "$CDROM" -w "$UTRACKNUM-[:1]" "$FILEARG"
else
- nice $READNICE $CDROMREADER -$CDPARANOIACDROMBUS "$CDROM" -w $UTRACKNUM-[:1] "$FILEARG" >&2
+ nice $READNICE $CDROMREADER -"$CDPARANOIACDROMBUS" "$CDROM" -w "$UTRACKNUM-[:1]" "$FILEARG" >&2
fi
;;
esac
RETURN=$?
# If we get some error or we get some missing wav
# (as long as we dont use pipes)
- if [ "$RETURN" != "0" -o \( ! -s "$WAVDATA" -a X"$USEPIPES" != "Xy" \) ]; then
+ if [ "$RETURN" != "0" ] || ( [ ! -s "$WAVDATA" ] && [ X"$USEPIPES" != "Xy" ] ); then
# Thank goodness errors is only machine-parseable up to the
# first colon, otherwise this woulda sucked
- if [ "$RETURN" = "0" -a ! -s "$WAVDATA" ]; then
+ if [ "$RETURN" = "0" ] || [ ! -s "$WAVDATA" ]; then
RETURN=73 # fake a return code as cdparanoia return 0 also on aborted reads
fi
if [ "$USEPIPES" = "y" ]; then
- echo "readencodetrack-$UTRACKNUM: $CDROMREADER returned code $RETURN" >> "$ABCDETEMPDIR/errors"
+ echo "readencodetrack-$UTRACKNUM: $CDROMREADER returned code $RETURN" >> "${ABCDETEMPDIR}/errors"
else
- echo "readtrack-$UTRACKNUM: $CDROMREADER returned code $RETURN" >> "$ABCDETEMPDIR/errors"
+ echo "readtrack-$UTRACKNUM: $CDROMREADER returned code $RETURN" >> "${ABCDETEMPDIR}/errors"
fi
return $RETURN
else
if [ "$USEPIPES" = "y" ]; then
- echo readencodetrack-$UTRACKNUM >> "$ABCDETEMPDIR/status"
+ echo "readencodetrack-$UTRACKNUM" >> "${ABCDETEMPDIR}/status"
else
- echo readtrack-$UTRACKNUM >> "$ABCDETEMPDIR/status"
+ echo "readtrack-$UTRACKNUM" >> "${ABCDETEMPDIR}/status"
fi
if [ "$1" = "onetrack" ]; then
- echo onetrack >> "$ABCDETEMPDIR/status"
+ echo onetrack >> "${ABCDETEMPDIR}/status"
fi
fi
}
# vecho outputs a message if EXTRAVERBOSE is 1 or more
vecho ()
{
-if [ x"$EXTRAVERBOSE" != "x" ] && [ $EXTRAVERBOSE -gt 0 ] ; then
+if [ x"$EXTRAVERBOSE" != "x" ] && [ "$EXTRAVERBOSE" -gt 0 ] ; then
case $1 in
warning) shift ; log warning "$@" ;;
*) >&4 echo "$@" ;;
# vvecho outputs a message if EXTRAVERBOSE is 2 or more
vvecho ()
{
-if [ x"$EXTRAVERBOSE" != "x" ] && [ $EXTRAVERBOSE -gt 1 ] ; then
+if [ x"$EXTRAVERBOSE" != "x" ] && [ "$EXTRAVERBOSE" -gt 1 ] ; then
case $1 in
warning) shift ; log warning "$@" ;;
*) >&4 echo "$@" ;;
decho ()
{
if [ x"$DEBUG" != "x" ]; then
- if echo $1 | grep "^\[" > /dev/null 2>&1 ; then
+ if echo "$1" | grep "^\[" > /dev/null 2>&1 ; then
DEBUGECHO=$(echo "$@" | tr -d '[]')
- echo >&4 "[DEBUG] $DEBUGECHO: `eval echo \\$${DEBUGECHO}`"
+ echo >&4 "[DEBUG] $DEBUGECHO: $(eval echo \\$${DEBUGECHO})"
else
echo >&4 "[DEBUG] $1"
fi
# Custom filename munging specific to track names:
mungetrackname ()
{
- mungefilename $@
+ mungefilename "$@"
}
# Custom filename munging specific to artist names:
mungeartistname ()
{
- mungefilename $@
+ mungefilename "$@"
}
# Custom filename munging specific to album names:
mungealbumname ()
{
- mungefilename $@
+ mungefilename "$@"
}
# Custom genre munging:
mungegenre ()
{
- echo $CDGENRE | tr "[:upper:]" "[:lower:]"
+ echo "$CDGENRE" | tr "[:upper:]" "[:lower:]"
}
# pre_read
# Builtin defaults
# CDDB
-# Currently two supported options ("musicbrainz" and "cddb" for freedb.org)
+# Currently three supported options ("musicbrainz", "cddb" for freedb.org and "cdtext")
CDDBMETHOD=musicbrainz
CDDBURL="http://freedb.freedb.org/~cddb/cddb.cgi"
CDDBSUBMIT=freedb-submit@freedb.org
CDDBLOCALRECURSIVE="y"
CDDBLOCALDIR="$HOME/.cddb"
CDDBUSELOCAL="n"
-# pre-declare a variable we'll use if the user provides a
-# comma-separated list of CDDBMETHODs
-declare -a CDDBMETHODS
-CDDBLASTMETHOD="n"
# List of fields we parse and show during the CDDB parsing...
SHOWCDDBFIELDS="year,genre"
OGGENCODERSYNTAX=default
OPUSENCODERSYNTAX=default
MKAENCODERSYNTAX=default
+AIFFENCODERSYNTAX=default
FLACENCODERSYNTAX=default
SPEEXENCODERSYNTAX=default
MPCENCODERSYNTAX=default
METAFLAC=metaflac
NEROAACTAG=neroAacTag
ATOMICPARSLEY=AtomicParsley
+WVTAG=wvtag
WINE=wine
CDPARANOIA=cdparanoia
-CD_PARANOIA=cd-paranoia
+CD_PARANOIA="cd-paranoia"
CDDA2WAV=icedax
DAGRAB=dagrab
CDDAFS=cp
PIRD=pird
-CDDISCID=cd-discid
+CDDISCID="cd-discid"
CDDBTOOL=cddb-tool
MUSICBRAINZ=abcde-musicbrainz-tool
EJECT=eject
MD5SUM=md5sum
DISTMP3=distmp3
-NORMALIZE=normalize-audio
+NORMALIZE="normalize-audio"
CDSPEED=eject
VORBISGAIN=vorbisgain
MP3GAIN=mp3gain
CONVERT=convert
DISPLAYCMD=display
-# Options for programs called from abcde
+# Options for programs called from abcde:
+#
+# aiff
+# These options needed by FFmpeg for tagging and selection of id3v2 version:
+# 1. '-write_id3v2 1' allows id3v2 tagging while '-write_id3v2 0' disables tagging
+# 2. '-id3v2_version 4' gives version id3v2.4 while '3' gives id3v2.3
+AIFFENCOPTS="-write_id3v2 1 -id3v2_version 4"
# mp3
LAMEOPTS=
GOGOOPTS=
# Linux/OpenBSD. ftp is user for NetBSD.
# Let's use these checkings to determine the OS flavour, which will be used
# later
-if [ X$(uname) = "XFreeBSD" ] ; then
+UNAME="$(uname)"
+if [ X"$UNAME" = "XFreeBSD" ] ; then
HTTPGET=fetch
MD5SUM=md5
NEEDCDROMID=y
OSFLAVOUR=FBSD
-elif [ X$(uname) = "XDarwin" ] ; then
+elif [ X"$UNAME" = "XDarwin" ] ; then
HTTPGET=curl
+ # By default md5sum is not installed, use md5 instead:
+ MD5SUM=md5
OSFLAVOUR=OSX
# We should have diskutil in OSX, but let's be sure...
NEEDDISKUTIL=y
CDROMREADERSYNTAX=cddafs
# We won't find the eject program in OSX, and doing checkexec will fail further below...
unset EJECT
-elif [ X$(uname) = "XOpenBSD" ] ; then
+elif [ X"$UNAME" = "XOpenBSD" ] ; then
HTTPGET=ftp
MD5SUM=md5
OSFLAVOUR=OBSD
-elif [ X$(uname) = "XNetBSD" ] ; then
+elif [ X"$UNAME" = "XNetBSD" ] ; then
HTTPGET=ftp
MD5SUM=md5
OSFLAVOUR=NBSD
-elif [ X$(uname) = "SunOS" ] ; then
+elif [ X"$UNAME" = X"SunOS" ] ; then
HTTPGET=""
MD5SUM=md5
OSFLAVOUR=SunOS
+elif [ X"$UNAME" = X"IRIX64" ] ; then
+ HTTPGET="wget"
+ OSFLAVOUR=IRIX
+ NEEDCDROMID=y
+ # Apparently necessary - see
+ # https://abcde.einval.com/bugzilla/show_bug.cgi?id=29
+ CDDISCID_NEEDS_PAUSE=y
else
HTTPGET=wget
fi
GREP_OPTIONS=""
GREP_COLOR=""
+# Length of the terminal *should* be in $LINES. If it's not, guess at
+# a reasonable number instead
+if [ -z "$LINES" ]; then
+ LINES=24
+fi
+
if [ -z "$OUTPUTDIR" ]; then
OUTPUTDIR=$(pwd)
fi
. /etc/abcde.conf
fi
# Load user preference defaults
-if [ -r $HOME/.abcde.conf ]; then
- . $HOME/.abcde.conf
+if [ -r "$HOME/.abcde.conf" ]; then
+ . "$HOME/.abcde.conf"
fi
# By this time, we need some HTTPGETOPTS already defined.
esac
# Parse command line options
-while getopts 1a:bc:C:d:DefgGhj:klLmMnNo:pPr:s:S:t:T:UvVxX:w:W:z opt ; do
+while getopts 1a:bBc:C:d:DefgGhj:klLmMnNo:pP:Q:r:s:S:t:T:UvVxX:w:W:z opt ; do
case "$opt" in
1) ONETRACK=y ;;
a) ACTIONS="$OPTARG" ;;
A) EXPACTIONS="$OPTARG" ;;
b) BATCHNORM=y ;;
- c) if [ -e "$OPTARG" ] ; then . "$OPTARG" ; else log error "config file \"$OPTARG\" cannot be found." ; exit 1 ; fi ;;
- C) DISCID="$( echo ${OPTARG#abcde.} | tr -d /)" ;;
+ B) GETALBUMART=y ; EMBEDALBUMART=y ;;
+ c) if [ -e "$OPTARG" ]; then
+ . "$OPTARG"
+ else
+ log error "config file \"$OPTARG\" cannot be found."
+ exit 1
+ fi
+ ;;
+ C) CDDBDISCID="$( echo "${OPTARG#abcde.}" | tr -d /)" ;;
d) CDROM="$OPTARG" ;;
D) set -x ;;
h) usage; exit ;;
o) OUTPUTTYPE="$OPTARG" ;;
p) PADTRACKS=y ;;
P) USEPIPES=y ;;
+ Q) CDDBMETHOD="$OPTARG" ;;
r) REMOTEHOSTS="$OPTARG" ;;
R) CDDBLOCALRECURSIVE=y ;;
s) SHOWCDDBFIELDS="$OPTARG" ;;
x) EJECTCD="y" ;;
X) CUE2DISCID="$OPTARG" ;;
w) COMMENT="$OPTARG" ;;
- W) if echo $OPTARG | grep "[[:digit:]]" > /dev/null 2>&1 ; then
- STARTTRACKNUMBER="${OPTARG}$(printf %02d ${STARTTRACKNUMBER:-01})"
+ W) if echo "$OPTARG" | grep "[[:digit:]]" > /dev/null 2>&1 ; then
+ STARTTRACKNUMBER="${OPTARG}$(printf "%02d" "${STARTTRACKNUMBER:-01}")"
STARTTRACKNUMBERTAG="y"
COMMENT="CD${OPTARG}"
DISCNUMBER="${OPTARG}"
EJECTCD=n
fi
-# If the user provided a DISCID, disable eject
-if [ -n "$DISCID" ] || [ "$CDROMREADERSYNTAX" = "flac" ]; then EJECTCD=n ; fi
+# If the user provided a CDDBDISCID, disable eject
+if [ -n "${CDDBDISCID}" ] || [ "$CDROMREADERSYNTAX" = "flac" ]; then EJECTCD=n ; fi
# Check the available cd rippers in the system, from the ones we know.
if [ "$CDROMREADERSYNTAX" = "" ]; then
for DEFAULT_CDROMREADER in $DEFAULT_CDROMREADERS; do
- if new_checkexec $DEFAULT_CDROMREADER; then
- CDROMREADERSYNTAX=$DEFAULT_CDROMREADER
+ if new_checkexec "$DEFAULT_CDROMREADER"; then
+ CDROMREADERSYNTAX="$DEFAULT_CDROMREADER"
break
fi
done
else
RSTART=${1%%-*}
REND=${1##*-}
- while [ ${RSTART:=1} -le ${REND:=0} ] ; do
+ while [ "${RSTART:=1}" -le "${REND:=0}" ] ; do
TRACKQUEUE="$TRACKQUEUE $RSTART"
RSTART=$(( $RSTART + 1 ))
done
## FIXME ## Lets keep compatibility with -M
[ "$DOCUE" != "y" ] && DOCUE=n
-for ACTION in $(echo $ACTIONS | tr , \ )
+for ACTION in $(echo "$ACTIONS" | tr , \ )
do
case $ACTION in
default) DOCDDB=y; DOREAD=y; DOENCODE=y; DOTAG=y; DOMOVE=y; DOCLEAN=y;;
playlist) DOCDDB=y; DOPLAYLIST=y;;
clean) DOCLEAN=y;;
getalbumart) GETALBUMART=y;;
+ embedalbumart) GETALBUMART=y; EMBEDALBUMART=y;;
esac
done
log warning "selected both normalize and replaygain actions"
fi
-for SHOWCDDBFIELD in $(echo $SHOWCDDBFIELDS | tr , \ ); do
+for SHOWCDDBFIELD in $(echo "$SHOWCDDBFIELDS" | tr , \ ); do
case $SHOWCDDBFIELD in
y*|Y*) SHOWCDDBYEAR="y";;
g*|G*) SHOWCDDBGENRE="y";;
# At this point a CDROM has to be defined, so we check it exists.
if [ X"$CDROM" != "X" ] ; then
- if ( [ "$CDROMREADERSYNTAX" = "cdda2wav" ] || [ "$CDROMREADERSYNTAX" = "icedax" ] ) && [ "$NEEDCDROMID" = "y" ] ; then
- if [ "$OSFLAVOUR" = "FBSD" ]; then
- if echo "$CDROMID" | grep "^[0-9],[0-9],[0-9]$" >/dev/null 2>&1 ; then :; else
+ if [ "$NEEDCDROMID" = "y" ] ; then
+ if [ "$CDROMREADERSYNTAX" = "cdda2wav" ] || [ "$CDROMREADERSYNTAX" = "icedax" ]; then
+ if [ "$OSFLAVOUR" = "IRIX" ]; then
+ if [ -z "$CDROMID" ]; then
+ CDROMID="$(echo "$CDROM" | sed -e 's;/dev/scsi/sc\([0-9]*\)d\([0-9]*\)l\([0-9]*\)$;\1,\2,\3;')"
+ fi
+ fi
+ if ! echo "$CDROMID" | grep "^[0-9],[0-9],[0-9]$" >/dev/null 2>&1 ; then
log error "CDROMID not in the right format for $CDROMREADERSYNTAX"
log error "Use \"cdrecord -scanbus\" to obtain an adequate ID and set CDROMID accordingly"
exit 1
fi
fi
- elif [ ! -e "$CDROM" -a X"$DOREAD" = "Xy" ]; then
+ elif [ ! -e "$CDROM" ] && [ X"$DOREAD" = "Xy" ]; then
log error "CDROM device cannot be found."
exit 1
fi
# - lowdisk algorithm
# - anything else?
if [ X"$USEPIPES" = "Xy" ]; then
- if [ $(echo "$OUTPUTTYPE" | tr , \ | wc -w ) -gt 1 ]; then
+ NUM_OUTPUT_TYPES="$(echo "$OUTPUTTYPE" | tr , \ | wc -w )"
+ if [ "$NUM_OUTPUT_TYPES" -gt 1 ]; then
log error "Unix pipes not compatible with multiple outputs"
exit 1
fi
# Check the encoding format from the ones available in the system, if nothing has been configured.
if [ X"$OUTPUTTYPE" = "X" ]; then
for DEFAULT_OUTPUT in $( echo "$DEFAULT_OUTPUT_BINARIES" | tr , \ ); do
- DEFAULT_OUTPUT_FORMAT="$(echo $DEFAULT_OUTPUT | cut -d ":" -f 1)"
- DEFAULT_OUTPUT_BINARY="$(echo $DEFAULT_OUTPUT | cut -d ":" -f 2)"
- if [ -x $(which $DEFAULT_OUTPUT_BINARY) ] ; then
+ DEFAULT_OUTPUT_FORMAT="$(echo "$DEFAULT_OUTPUT" | cut -d ":" -f 1)"
+ DEFAULT_OUTPUT_BINARY="$(echo "$DEFAULT_OUTPUT" | cut -d ":" -f 2)"
+ if [ -x "$(which "$DEFAULT_OUTPUT_BINARY")" ] ; then
OUTPUTTYPE=$DEFAULT_OUTPUT_FORMAT
vecho "No default output type defined. Autoselecting $OUTPUTTYPE..." >&2
break
vorbis:*|ogg:*) OGGENCODEROPTSCLI="$( echo $OUTPUT | cut -d: -f2- )" ;;
opus:*) OPUSENCODEROPTSCLI="$( echo $OUTPUT | cut -d: -f2- )" ;;
mka:*) MKAENCODEROPTSCLI="$( echo $OUTPUT | cut -d: -f2- )" ;;
+ aiff:*) AIFFENCODEROPTSCLI="$( echo $OUTPUT | cut -d: -f2- )" ;;
mp3:*) MP3ENCODEROPTSCLI="$( echo $OUTPUT | cut -d: -f2- )" ;;
flac:*) FLACENCODEROPTSCLI="$( echo $OUTPUT | cut -d: -f2- )" ;;
spx:*) SPEEXENCODEROPTSCLI="$( echo $OUTPUT | cut -d: -f2- )" ;;
# wavpack for wvs...
# Getting ready for multiple output changes
-for OUTPUT in $(echo $OUTPUTTYPE | tr , \ )
+for OUTPUT in $(echo "$OUTPUTTYPE" | tr , \ )
do
case $OUTPUT in
vorbis|ogg)
[ "$MKAENCODERSYNTAX" = "default" ] && MKAENCODERSYNTAX=ffmpeg
MKAOUTPUTCONTAINER=mka
;;
+ aiff)
+ [ "$AIFFENCODERSYNTAX" = "default" ] && AIFFENCODERSYNTAX=ffmpeg
+ AIFFOUTPUTCONTAINER=aiff
+ ;;
mp3)
[ "$MP3ENCODERSYNTAX" = "default" ] && MP3ENCODERSYNTAX=lame
[ "$DOTAG" = "y" ] && NEEDTAGGER=y
[ "$DOREPLAYGAIN" = "y" ] && NEEDMP3GAIN=y
+ [ "$EMBEDALBUMART" = "y" ] && NEEDEYED3=y
;;
flac)
[ "$FLACENCODERSYNTAX" = "default" ] && FLACENCODERSYNTAX=flac
[ "$DOTAG" = "y" ] && NEEDMETAFLAC=y
[ "$DOREPLAYGAIN" = "y" ] && NEEDMETAFLAC=y
[ "$ONETRACK" = "y" ] && [ "$DOCUE" = "y" ] && NEEDMETAFLAC=y
+ [ "$EMBEDALBUMART" = "y" ] && NEEDMETAFLAC=y
;;
spx)
[ "$SPEEXENCODERSYNTAX" = "default" ] && SPEEXENCODERSYNTAX=speexenc
[ "$DOTAG" = "y" ]
[ "$DOREPLAYGAIN" = "y" ] && NEEDWVGAIN=y
[ "$WVENCODERSYNTAX" = "ffmpeg" ] && DOREPLAYGAIN=n
+ [ "$EMBEDALBUMART" = "y" ] && NEEDWVTAG=y
;;
ape)
[ "$APENCODERSYNTAX" = "default" ] && APENCODERSYNTAX=mac
[ "$AACENCODERSYNTAX" = "qaac" ] && NEEDWINE=y
[ "$AACENCODERSYNTAX" = "fhgaacenc" ] && NEEDWINE=y && NEEDATOMICPARSLEY=y
[ "$AACENCODERSYNTAX" = "ffmpeg" ] && [ "$DOTAG" = "y" ]
+ [ "$EMBEDALBUMART" = "y" ] && NEEDATOMICPARSLEY=y
;;
wav)
if [ "$KEEPWAVS" = "y" ]; then
MKAENCODER="$FFMPEG"
;;
esac
+case "$AIFFENCODERSYNTAX" in
+ ffmpeg)
+ AIFFENCODEROPTS="${AIFFENCODEROPTSCLI:-$AIFFENCOPTS}"
+ AIFFENCODER="$FFMPEG"
+ ;;
+esac
case "$FLACENCODERSYNTAX" in
flac)
FLACENCODEROPTS="${FLACENCODEROPTSCLI:-$FLACOPTS}"
CUEREADEROPTS="${CDROM}"
CUEREADER="$MKCUE"
;;
+ abcde.mkcue)
+ CUEREADEROPTS="$MKCUEOPTS ${CDROM}"
+ CUEREADER="$MKCUE"
+ ;;
esac
# which information retrieval tool are we using?
musicbrainz) ;;
esac
-# 2016-08-30: adding comma-separated list (in this case, to be used in
-# sequence until successful) support ala OUTPUTYPE. -GR
-idx=0
-for CDDBCHOICE in $(echo "$CDDBMETHOD" | tr -d ' ' | tr , ' ')
-do
- # The OUTPUTTYPE code uses bash-specific syntax (var=${var:+var}),
- # but then doesn't just use an array to store the output, which seems
- # weird. So I'm going to use an array for this...? -GR
- CDDBMETHODS[$idx]=$CDDBCHOICE
- vvecho "CDDB method $idx: $CDDBCHOICE"
- idx=$((idx + 1))
-done
-
-# Just so CDDBMETHOD is a legible value for functions, in case I
-# miss something, set it to the first choice: -GR
-CDDBMETHOD=${CDDBMETHODS[0]}
-
# Check if both OGGEOUTPUTCONTAINER and FLACOUTPUTCONTAINER are the same, and differentiante them
if [ X"$OGGOUTPUTCONTAINER" = "Xogg" ] && [ X"$FLACOUTPUTCONTAINER" = "Xogg" ]; then
log error "FLAC on an Ogg container is not yet supported"
exit 1
OGGOUTPUTCONTAINER=ogg.ogg
FLACOUTPUTCONTAINER=flac.ogg
- vecho warning "modified file endings due to conflicting transport layers in Ogg/Vorbis and Ogg/FLAC"
+ vecho warning "modified file endings due to conflicting transport"
+ vecho warning "layers in Ogg/Vorbis and Ogg/FLAC"
fi
# Clean up nice options (either use '-n NICELEVEL or -NICELEVEL')
NEEDEJECT=y
fi
if [ ! "$CDDBAVAIL" = "n" ] && [ "$DOCDDB" = "y" ]; then
- if [ "$CDDBMETHOD" = "cddb" ]; then
- NEEDHTTPGET=y
- elif [ "$CDDBMETHOD" = "musicbrainz" ]; then
- :
- fi
+ # Need an http tool to be able to do CDDB
+ case $CDDBMETHOD in
+ *cddb*)
+ NEEDHTTPGET=y;;
+ esac
fi
if [ "$DOCUE" = "y" ]; then
NEEDCUEREADER=y
PIPEENCODERSVARCHECK="PIPE_$OPUSENCODERSYNTAX" ;;
mka)
PIPEENCODERSVARCHECK="PIPE_$MKAENCODERSYNTAX" ;;
+ aiff)
+ PIPEENCODERSVARCHECK="PIPE_$AIFFENCODERSYNTAX" ;;
flac)
PIPEENCODERSVARCHECK="PIPE_$FLACENCODERSYNTAX" ;;
spx)
# Make sure a buncha things exist
for X in $CDROMREADER $CDDISCID ${NEEDTAGGER+$TAGGER} $MP3ENCODER \
$OGGENCODER $OPUSENCODER $MKAENCODER $FLACENCODER $SPEEXENCODER $MPCENCODER \
- $AACENCODER $WVENCODER $CDDBTOOL $APENCODER $MP2ENCODER $TTAENCODER \
+ $AACENCODER $WVENCODER $CDDBTOOL $APENCODER $MP2ENCODER $TTAENCODER $AIFFENCODER \
${NEEDHTTPGET+$HTTPGET} ${NEEDDISTMP3+$DISTMP3} \
${NEEDCOMMENTER+$VORBISCOMMENT} ${NEEDMETAFLAC+$METAFLAC} \
${NEEDNORMALIZER+$NORMALIZER} ${NEEDEJECT+$EJECT} \
${NEEDWVGAIN+WVGAIN} ${NEEDAPETAG+$APETAG} \
${NEEDCUE2DISCID+$CUE2DISCID} ${NEEDNEROAACTAG+$NEROAACTAG} \
${NEEDGLYRC+$GLYRC} ${NEEDWINE+$WINE} ${NEEDATOMICPARSLEY+$ATOMICPARSLEY} \
- ${NEEDMID3V2+$MID3V2}
+ ${NEEDMID3V2+$MID3V2} ${NEEDEYED3+$EYED3} ${NEEDWVTAG+$WVTAG}
do
checkexec "$X"
done
# And last but not least, check if we can diff between files. We do not abort,
# since diffing is not critical...
-if [ -x $(which $DIFF) ]; then :; else
+if [ -x "$(which "$DIFF")" ]; then :; else
vecho warning "Disabling diff since we cannot find it in the \$PATH..."
DIFF=""
fi
## Now that we have metaflac, check if we need cue2discid
#case $CDROMREADERSYNTAX in
# flac)
-# TRACKINFO=$($METAFLAC --show-tag=CDDB $CDROM | cut -d"=" -f2 | grep -E "[a-f0-9]{8}")
-# if [ "$TRACKINFO" = "" ]; then
+# CDDBTRACKINFO=$($METAFLAC --show-tag=CDDB $CDROM | cut -d"=" -f2 | grep -E "[a-f0-9]{8}")
+# if [ "$CDDBTRACKINFO" = "" ]; then
# checkexec ${NEEDCUE2DISCID+$CUE2DISCID}
# fi
# ;;
# Hey, for grins, as of 2016-08-30 this is now line 4814! -GR
# Export needed things so they can be read in this subshell
-export CDDBTOOL ABCDETEMPDIR TRACKQUEUE LOWDISK EJECTCD EJECT EJECTOPTS
-export CDROM CDDBDATA REMOTEHOSTS MAXPROCS HTTPGET MD5SUM
+export CDDBTOOL # Path and options for the tool to query CDDB
+export ABCDETEMPDIR # Path to the tmpdir for this rip
+export TRACKQUEUE # 0-padded list of tracks to be processed
+export LOWDISK # Are we using the low-diskspace algorithm?
+export EJECTCD # Should we eject the CD when we're finished ripping?
+export EJECT # The commend to use to eject the CD, if we have one
+export EJECTOPTS # Options to that command
+export CDROM # Device path for the CD device
+export CDDBDATA # The filename we're using for CD lookup data
+export REMOTEHOSTS # List of remote hosts for parallel encoding, if given
+export MAXPROCS # The number of *local* encodes to do in parallel
+export HTTPGET # Program to use to grab files via http
+export MD5SUM # Program to calculate MD5 checksums
if [ "$DOREAD" = "y" ]; then
# User-definable function to set some things. Use it for
# start with a sane default:
CDDBLOCALSTATUS=notfound
if [ $CDDBUSELOCAL = "y" ]; then
- do_localcddb
+ do_localcddb_read
fi
if checkstatus cddb-choice > /dev/null; then
:
else
+ NUM_CDDB_MATCHES=0
if [ "$CDDBLOCALSTATUS" = "notfound" ] ; then
- for CDDBMETHCHOICE in ${CDDBMETHODS[@]}
+ idx=0
+ for CDDBMETHCHOICE in $(echo "$CDDBMETHOD" | tr -d ' ' | tr , ' ')
do
- vecho "Trying CDDB method ${CDDBMETHCHOICE}."
- if [ $CDDBLASTMETHOD = "n" ]
- then
- if [ ${#CDDBMETHODS[@]} -le 1 ]
- # (number of items)
- then
- CDDBLASTMETHOD="y"
- else
- CDDBMETHODS=("${CDDBMETHODS[@]:1}")
- # (performs shift on an array in bash)
- fi
- else
- vvecho "(Last chance before manual entry...)"
- fi
+ addstatus "Lookup method $idx: $CDDBMETHCHOICE"
+ idx=$(($idx + 1))
+ vecho "Found $NUM_CDDB_MATCHES matches so far"
+ vecho "Trying lookup method ${CDDBMETHCHOICE}"
+
+ # Run all the desired data acquisition methods, in the order
+ # specified by the user. Each will use its own temporary
+ # subdirectory, then copy the cddbread.* etc. files up into
+ # ${ABCDETEMPDIR}
case "$CDDBMETHCHOICE" in
cddb)
- do_cddbstat
- do_cddbquery
- do_cddbread
+ do_cddb_read
;;
musicbrainz)
- do_musicbrainz
+ do_musicbrainz_read
+ ;;
+ cdtext)
+ do_cdtext_read
+ ;;
+ *)
+ echo "Unknown lookup method $CDDBMETHCHOICE. Aborting." >&2
+ exit 1
;;
esac
- if [ -f "$ABCDETEMPDIR/cddbchoices" ]
- then
- # If this pass found something, we're done.
- break
- fi
+
done
- fi
- CHOICE=$(checkstatus cddb-choice)
- if [ "$CHOICE" = 0 ] ; then
- # We don't have any information at all; try to fall back
- # to CD-Text for basic information
- vecho "No CDDB information found, trying cdtext from the CD"
- do_cdtext
+
+ rm -f "${ABCDETEMPDIR}/cddbchoices"
+ CDDBDISCID=$(echo "$CDDBTRACKINFO" | cut -d' ' -f1)
+
+ if [ $NUM_CDDB_MATCHES = 0 ]; then
+ # If we got no matches, we need to
+ # generate a blank CDDB template.
+ vecho "Unable to find any matches, generating unknown template."
+ echo "No lookup matches." >> "${ABCDETEMPDIR}/cddbchoices"
+ $CDDBTOOL template $(cat "${ABCDETEMPDIR}/cddbdiscid") > "${ABCDETEMPDIR}/cddbread.0"
+ echo "template" > "${ABCDETEMPDIR}/datasource.0"
+ # List out disc title/author and contents of template
+ echo ---- Unknown Artist / Unknown Album ---- >> "${ABCDETEMPDIR}/cddbchoices"
+ UNKNOWNDISK=y
+ for TRACK in $(f_seq_row 1 $TRACKS)
+ do
+ echo "$TRACK:" "$(grep -a ^TTITLE$(($TRACK - 1))= "${ABCDETEMPDIR}/cddbread.0" | cut -f2- -d= | tr -d \\r\\n)" >> "${ABCDETEMPDIR}/cddbchoices"
+ done
+ echo >> "${ABCDETEMPDIR}/cddbchoices"
+ echo cddb-read-0-complete >> "${ABCDETEMPDIR}/status"
+ echo cddb-choice=0 >> "${ABCDETEMPDIR}/status"
+ echo 503 > "${ABCDETEMPDIR}/cddbquery"
+ else
+ # We have matches; create the cddbchoices and cddbquery
+ # files from all the inputs we have
+ if [ $NUM_CDDB_MATCHES = 1 ]; then
+ echo "Retrieved 1 match..." >> "${ABCDETEMPDIR}/cddbchoices"
+ echo -n "200 " > "${ABCDETEMPDIR}/cddbquery"
+ cat "${ABCDETEMPDIR}/cddbquery.1" >> "${ABCDETEMPDIR}/cddbquery"
+ else
+ echo "Retrieved $NUM_CDDB_MATCHES matches..." >> "${ABCDETEMPDIR}/cddbchoices"
+ echo "210 Found exact matches, list follows (until terminating .)" > "${ABCDETEMPDIR}/cddbquery"
+ for X in $(f_seq_row 1 $NUM_CDDB_MATCHES)
+ do
+ cat "${ABCDETEMPDIR}/cddbquery.$X" >> "${ABCDETEMPDIR}/cddbquery"
+ done
+ echo "." >> "${ABCDETEMPDIR}/cddbquery"
+ fi
+
+ for X in $(f_seq_row 1 $NUM_CDDB_MATCHES)
+ do
+ ATITLE=$(grep -a -e '^DTITLE=' "${ABCDETEMPDIR}/cddbread.$X" | cut -c8- | tr -d \\r\\n)
+ SOURCE=$(cat "${ABCDETEMPDIR}/datasource.$X")
+ echo "#$X ($SOURCE): ---- ${ATITLE} ----" >> "${ABCDETEMPDIR}/cddbchoices"
+ for TRACK in $(f_seq_row 1 $TRACKS)
+ do
+ echo "$TRACK:" "$(grep -a ^TTITLE$(($TRACK - 1))= "${ABCDETEMPDIR}/cddbread.$X" | cut -f2- -d= | tr -d \\r\\n)" >> "${ABCDETEMPDIR}/cddbchoices"
+ done
+ echo >> "${ABCDETEMPDIR}/cddbchoices"
+ done
+ fi
fi
fi
do_cddbedit
FIRSTTRACK=$( get_first $TRACKQUEUE )
LASTTRACK=$( get_last $TRACKQUEUE )
-if [ -f "$ABCDETEMPDIR/status" ] && [ X"$ERASEENCODEDSTATUS" = "Xy" ]; then
- mv "$ABCDETEMPDIR/status" "$ABCDETEMPDIR/status.old"
- grep -v ^encodetracklocation- < "$ABCDETEMPDIR/status.old" \
- | grep -v ^encode-output > "$ABCDETEMPDIR/status"
+if [ -f "${ABCDETEMPDIR}/status" ] && [ X"$ERASEENCODEDSTATUS" = "Xy" ]; then
+ mv "${ABCDETEMPDIR}/status" "${ABCDETEMPDIR}/status.old"
+ grep -v ^encodetracklocation- < "${ABCDETEMPDIR}/status.old" \
+ | grep -v ^encode-output > "${ABCDETEMPDIR}/status"
fi
if checkstatus onetrack ; then ONETRACK=y ; fi
# For the lowdisk option, only one program is running at once so the encoder
# can be unsilenced right away.
if [ "$LOWDISK" = "y" ] || [ "$ONETRACK" = "y" ]; then
- echo "encode-output=loud" >> "$ABCDETEMPDIR/status"
+ echo "encode-output=loud" >> "${ABCDETEMPDIR}/status"
fi
if [ "$ONETRACK" = "y" ]; then
TRACKS="$FIRSTTRACK"
if [ "$USEPIPES" = "y" ]; then
- if checkstatus readencodetrack-$FIRSTTRACK; then :; else
- do_cdread onetrack $FIRSTTRACK $LASTTRACK | do_encode $FIRSTTRACK %local0% > /dev/null 2>&1
+ if checkstatus "readencodetrack-$FIRSTTRACK"; then :; else
+ do_cdread onetrack "$FIRSTTRACK" "$LASTTRACK" | do_encode "$FIRSTTRACK" %local0% > /dev/null 2>&1
fi
else
- if checkstatus readtrack-$FIRSTTRACK; then :; else
- do_cdread onetrack $FIRSTTRACK $LASTTRACK
+ if checkstatus "readtrack-$FIRSTTRACK"; then :; else
+ do_cdread onetrack "$FIRSTTRACK" "$LASTTRACK"
fi
fi
else
do
if [ "$DOREAD" = "y" ]; then
if [ "$USEPIPES" = "y" ]; then
- if checkstatus readencodetrack-$UTRACKNUM; then :; else
+ if checkstatus "readencodetrack-$UTRACKNUM"; then :; else
# Read, pipe, shut up!
- do_cdread $UTRACKNUM | do_encode $UTRACKNUM %local0% > /dev/null 2>&1
+ do_cdread "$UTRACKNUM" | do_encode "$UTRACKNUM" %local0% > /dev/null 2>&1
fi
else
- if checkstatus readtrack-$UTRACKNUM; then :; else
- do_cdread $UTRACKNUM
+ if checkstatus "readtrack-$UTRACKNUM"; then :; else
+ do_cdread "$UTRACKNUM"
fi
if [ "$?" != "0" ]; then
# CD read failed - don't give the goahead to
# If we are not reading, set the encode output to loud already, so
# that we can see the output of the first track.
if [ "$MAXPROCS" = "1" ] && [ ! "$DOREAD" = "y" ]; then
- echo "encode-output=loud" >> "$ABCDETEMPDIR/status"
+ echo "encode-output=loud" >> "${ABCDETEMPDIR}/status"
fi
echo NEXTTRACK # Get the encoder machine churning again
if [ "$DOREAD" = "y" ]; then
if [ "$LOWDISK" = "y" ] && [ "$DOENCODE" = "y" ]; then
- until checkstatus encodetrack-$UTRACKNUM
+ until checkstatus "encodetrack-$UTRACKNUM"
do
- if checkerrors encodetrack-$UTRACKNUM; then
+ if checkerrors "encodetrack-$UTRACKNUM"; then
break
fi
sleep 2
# Now that we're done the encoding can be loud again -
# if we're not using SMP.
if [ "$MAXPROCS" = "1" ]; then
- echo "encode-output=loud" >> "$ABCDETEMPDIR/status"
+ echo "encode-output=loud" >> "${ABCDETEMPDIR}/status"
fi
# All tracks read, start encoding.
# CD tray. If not, we do not eject the CD, since it might be so that the
# user ejected it manually.
#CURRENTTRACKINFO=$($CDDISCID $CDROM)
- #if if [ "$?" != "1" ] && [ "$CURRENTTRACKINFO" = "$TRACKINFO" ] ; then
+ #if if [ "$?" != "1" ] && [ "$CURRENTTRACKINFO" = "$CDDBTRACKINFO" ] ; then
# More FreeBSD bits.
- if [ X"$(uname)" = X"FreeBSD" ] ; then
+ if [ X"$UNAME" = X"FreeBSD" ] ; then
# FreeBSD eject uses the EJECT environment variable to name the CDROM
# but in this script EJECT is in the envionment and names the program
eject=$EJECT
unset EJECT
# The FreeBSD eject needs "adc0" not "/dev/adc0c"
- cd="$(echo $CDROM | sed -e 's=.*/==;s=[a-h]$==;')"
+ cd="$(echo "$CDROM" | sed -e 's=.*/==;s=[a-h]$==;')"
$eject $EJECTOPTS $cd
- elif [ X"$(uname)" = X"Darwin" ] ; then
- diskutil eject ${CDROM#/dev/} 0
- elif [ -x $(which $EJECT) ]; then
+ elif [ X"$UNAME" = X"Darwin" ] ; then
+ diskutil eject "${CDROM#/dev/}" 0
+ elif [ -x "$(which "$EJECT")" ]; then
$EJECT $EJECTOPTS "$CDROM"
fi
#fi
# PREPROCEED=
# until [ $PREPROCEED ]
# do
-# if checkstatus readtrack-$PRETRACKNUM; then PREPROCEED=y; break; fi
+# if checkstatus "readtrack-$PRETRACKNUM"; then PREPROCEED=y; break; fi
# # all locations are working, wait and try again later
# if [ ! $PREPROCEED ]; then sleep 3; fi
# done
read GOAHEAD # For blocking - will contain either "NO" or "NEXTTRACK"
if [ "$GOAHEAD" != "NO" ]; then
for LASTTRACK in $TRACKQUEUE; do :; done
- if checkstatus readtrack-$LASTTRACK; then
+ if checkstatus "readtrack-$LASTTRACK"; then
if [ "$DONORMALIZE" = "y" ] && [ "$BATCHNORM" = "y" ]; then
- if checkstatus normalizetrack-$LASTTRACK; then :; else do_batch_normalize; fi
+ if checkstatus "normalizetrack-$LASTTRACK"; then :; else do_batch_normalize; fi
if checkerrors batch-normalize; then exit 1; fi
fi
if [ "$DOENCODE" = "y" ] && [ "$NOGAP" = "y" ]; then
if [ "$DONORMALIZE" = "y" ]; then
for UTRACKNUM in $TRACKQUEUE
do
- if checkstatus readtrack-$UTRACKNUM; then
- if checkstatus normalizetrack-$UTRACKNUM; then :; else do_normalize $UTRACKNUM; fi
+ if checkstatus "readtrack-$UTRACKNUM"; then
+ if checkstatus "normalizetrack-$UTRACKNUM"; then :; else do_normalize "$UTRACKNUM"; fi
fi
done
fi
- if checkstatus encodetrack-$LASTTRACK; then :; else do_nogap_encode; fi
+ if checkstatus "encodetrack-$LASTTRACK"; then :; else do_nogap_encode; fi
if checkerrors nogap-encode; then exit 1; fi
fi
fi
# Do the encoding, including parallelization of remote encoding
# Figure out where each track is going to be encoded
-ENCODELOCATIONS="$(echo $REMOTEHOSTS | tr , ' ')"
+ENCODELOCATIONS="$(echo "$REMOTEHOSTS" | tr , ' ')"
if [ "$MAXPROCS" != "0" ]; then
- for NUM in $(f_seq_row 1 "$MAXPROCS")
+ for NUM in $(f_seq_row 1 $MAXPROCS)
do
ENCODELOCATIONS="$ENCODELOCATIONS %local$NUM%"
done
read GOAHEAD # For blocking - will contain either "NO" or "NEXTTRACK"
if [ "$GOAHEAD" = "NO" ]; then break; fi
# find out where this track is to be encoded
- if [ "$DOENCODE" = "y" -a "$USEPIPES" != "y" ]; then
+ if [ "$DOENCODE" = "y" ] && [ "$USEPIPES" != "y" ]; then
# Make sure we have a place to encode this, if not, exit stage right
if [ -z "$ENCODELOCATIONS" ]; then
continue
do
for LOCATION in $ENCODELOCATIONS
do
- PREVIOUSTRACK="$(checkstatus encodetracklocation-$LOCATION)"
+ PREVIOUSTRACK="$(checkstatus "encodetracklocation-$LOCATION")"
# check first if a track has ever been assigned to this location
if [ -z "$PREVIOUSTRACK" ]; then PROCEED=y; break; fi
# If it errored out, rebuild $ENCODELOCATIONS without this location in it
- if checkerrors encodetrack-$PREVIOUSTRACK; then
+ if checkerrors "encodetrack-$PREVIOUSTRACK"; then
for TEMPLOCATION in $ENCODELOCATIONS
do
if [ "$TEMPLOCATION" != "$LOCATION" ]; then
# We're still here, this location must have been previously assigned,
# and last completed without error - check if it's done with the
# previous track yet
- if checkstatus encodetrack-$PREVIOUSTRACK; then PROCEED=y; break; fi
+ if checkstatus "encodetrack-$PREVIOUSTRACK"; then PROCEED=y; break; fi
done
# all locations are working, wait and try again later
- if [ ! $PROCEED ]; then sleep 3; fi
+ if [ ! "$PROCEED" ]; then sleep 3; fi
done
# Record the location we're about to encode the next track at
- echo "encodetracklocation-$LOCATION=$UTRACKNUM" >> "$ABCDETEMPDIR/status"
+ echo "encodetracklocation-$LOCATION=$UTRACKNUM" >> "${ABCDETEMPDIR}/status"
fi
# Don't proceed with the rest of the loop if we can't encode
if [ "$ABORT" ]; then continue; fi
## FIXME ## Add here
- ## run_command tagtrack-$OUTPUT-$1 $METAFLAC $METAFLACOPTS ${IMPORTCUESHEET:+--import-cuesheet-from="$ABCDETEMPDIR/$CUEFILE"} --import-tags-from=- "$ABCDETEMPDIR/track$1.$FLACOUTPUTCONTAINER"
+ ## run_command "tagtrack-$OUTPUT-$1" $METAFLAC $METAFLACOPTS ${IMPORTCUESHEET:+--import-cuesheet-from="${ABCDETEMPDIR}/$CUEFILE"} --import-tags-from=- "${ABCDETEMPDIR}/track$1.$FLACOUTPUTCONTAINER"
# Set TRACKNUM, TRACKNAME
if [ -e "$CDDBDATA" ]; then
if [ "$ONETRACK" = "y" ]; then
TRACKNUM="$FIRSTTRACK"
splitvarious
else
- TRACKNUM=$UTRACKNUM
- CDDBTRACKNUM=$(expr $UTRACKNUM - 1)
+ TRACKNUM="$UTRACKNUM"
+ CDDBTRACKNUM=$(expr $UTRACKNUM - 1) # Unpad
getcddbinfo TRACKNAME
splitvarious
fi
# thus all of this is backgrounded together
(
if [ "$DONORMALIZE" = "y" ]; then
- if checkstatus readtrack-$UTRACKNUM; then
- if checkstatus normalizetrack-$UTRACKNUM; then :; else do_normalize $UTRACKNUM; fi
+ if checkstatus "readtrack-$UTRACKNUM"; then
+ if checkstatus "normalizetrack-$UTRACKNUM"; then :; else do_normalize "$UTRACKNUM"; fi
fi
fi
- if [ "$DOENCODE" = "y" -a "$USEPIPES" != "y" ]; then
- if checkstatus readtrack-$UTRACKNUM; then
- #if checkstatus encodetrack-$UTRACKNUM; then :; else do_encode $UTRACKNUM $LOCATION; fi
+ if [ "$DOENCODE" = "y" ] && [ "$USEPIPES" != "y" ]; then
+ if checkstatus "readtrack-$UTRACKNUM"; then
if [ "$DONORMALIZE" = "y" ]; then
- if checkstatus normalizetrack-$UTRACKNUM; then
- if checkstatus encodetrack-$UTRACKNUM; then :; else do_encode $UTRACKNUM $LOCATION $OUTPUT; fi
+ if checkstatus "normalizetrack-$UTRACKNUM"; then
+ if checkstatus "encodetrack-$UTRACKNUM"; then :; else do_encode "$UTRACKNUM" "$LOCATION" "$OUTPUT"; fi
fi
else
- if checkstatus encodetrack-$UTRACKNUM; then :; else do_encode $UTRACKNUM $LOCATION $OUTPUT; fi
+ if checkstatus "encodetrack-$UTRACKNUM"; then :; else do_encode "$UTRACKNUM" "$LOCATION" "$OUTPUT"; fi
fi
fi
fi
if [ "$DOTAG" = "y" ]; then
- if checkstatus encodetrack-$UTRACKNUM; then
- if checkstatus tagtrack-$UTRACKNUM; then :; else do_tag $UTRACKNUM; fi
+ if checkstatus "encodetrack-$UTRACKNUM"; then
+ if checkstatus "tagtrack-$UTRACKNUM"; then :; else do_tag "$UTRACKNUM"; fi
fi
# Lets tag the cue file
if checkstatus cleancuefile >/dev/null; then :; else
fi
fi
if [ "$DOMOVE" = "y" ]; then
- if checkstatus tagtrack-$UTRACKNUM; then
- if checkstatus movetrack-$UTRACKNUM; then :; else do_move $UTRACKNUM; fi
+ if checkstatus "tagtrack-$UTRACKNUM"; then
+ if checkstatus "movetrack-$UTRACKNUM"; then :; else do_move "$UTRACKNUM"; fi
fi
fi
) &
PROCEED=y
for LOCATION in $ENCODELOCATIONS
do
- CHECKTRACK="$(checkstatus encodetracklocation-$LOCATION)"
+ CHECKTRACK="$(checkstatus "encodetracklocation-$LOCATION")"
# "How can he give us a status update, if he's DEAD?"
- if checkstatus encodetrack-$CHECKTRACK; then
+ if checkstatus "encodetrack-$CHECKTRACK"; then
continue
fi
# Nothing to see here please go quietly back to your homes
if [ -z "$CHECKTRACK" ]; then continue; fi
# You're still here? Maybe there is something...
- if checkstatus encodetrack-$CHECKTRACK; then :; else PROCEED= ; break; fi
+ if checkstatus "encodetrack-$CHECKTRACK"; then :; else PROCEED= ; break; fi
done
# hold up
if [ ! $PROCEED ]; then sleep 5; fi
do_replaygain
fi
+if [ "$EMBEDALBUMART" = "y" ]; then
+ do_embedalbumart
+fi
+
# Execute the user-defined post_encode function before cleaning up
post_encode
# Check to see if run_command logged any errors
-if [ -f "$ABCDETEMPDIR/errors" ]; then
+if [ -f "${ABCDETEMPDIR}/errors" ]; then
log error "The following commands failed to run:"
- cat "$ABCDETEMPDIR/errors"
+ cat "${ABCDETEMPDIR}/errors"
# Don't clean up
DOCLEAN=n
fi
fi
# Check if we have moved all the formats we had previously encoded, if we are not using the FORCE.
if [ "$DOCLEAN" = "y" ] && [ ! "$FORCE" = "y" ]; then
- ENCODED_FORMATS=$(grep -E "^encodetrack-(.{3,6})-(.{1,2})$" "$ABCDETEMPDIR/status" | cut -d"-" -f2 | sort -u | tr '\n' '|')
- MOVED_FORMATS=$(grep -E "^movetrack-output-(.{3,6})$" "$ABCDETEMPDIR/status" | cut -d"-" -f3 | sort -u | tr '\n' '|')
+ ENCODED_FORMATS=$(grep -E "^encodetrack-(.{3,6})-(.{1,2})$" "${ABCDETEMPDIR}/status" | cut -d"-" -f2 | sort -u | tr '\n' '|')
+ MOVED_FORMATS=$(grep -E "^movetrack-output-(.{3,6})$" "${ABCDETEMPDIR}/status" | cut -d"-" -f3 | sort -u | tr '\n' '|')
if [ "$ENCODED_FORMATS" != "$MOVED_FORMATS" ]; then
log warning "The encoded formats does not match with the moved ones"
- log warning "Formats encoded: $( echo $ENCODED_FORMATS | tr "|" " " )"
- log warning "Formats moved: $( echo $MOVED_FORMATS | tr "|" " " )"
- log warning "Use \"abcde -a clean -f -C $DISCID\" to force the removal of the remaining data."
+ log warning "Formats encoded: $( echo "$ENCODED_FORMATS" | tr "|" " " )"
+ log warning "Formats moved: $( echo "$MOVED_FORMATS" | tr "|" " " )"
+ log warning "Use \"abcde -a clean -f -C ${CDDBDISCID}\" to force the removal of the remaining data."
DOCLEAN=n
fi
fi
# Wipe all the evidence
# Gimme gimme gimme some more time!
sleep 5
- rm -rf "$ABCDETEMPDIR"
+ rm -rf "${ABCDETEMPDIR}"
echo "Finished."
else
- echo "Finished. Not cleaning $ABCDETEMPDIR."
+ echo "Finished. Not cleaning ${ABCDETEMPDIR}."
fi
)
exit 0