mpd-monitor

#!/usr/bin/env bash
## This script for bash 4.x on linux displays the way an audio file is
## streamed from storage, through mpd, to alsa (the DAC).
##
##  Copyright (C) 2017 Ronald van Engelen <ronalde+github@lacocina.nl>
##  This program is free software: you can redistribute it and/or modify
##  it under the terms of the GNU General Public License as published by
##  the Free Software Foundation, either version 3 of the License, or
##  (at your option) any later version.
##
##  This program is distributed in the hope that it will be useful,
##  but WITHOUT ANY WARRANTY; without even the implied warranty of
##  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
##  GNU General Public License for more details.
##
##  You should have received a copy of the GNU General Public License
##  along with this program.  If not, see <http://www.gnu.org/licenses/>.
##
## Source:    https://github.com/ronalde/mpd-configure
## See also:  https://lacocina.nl/detect-alsa-output-capabilities

LANG=C

app_name_mm="mpd-monitor"
app_version="0.1.0"
app_info_url="https://lacocina.nl/mpd-display-status"

def_mpd_host="localhost"
def_mpd_port="6600"
def_ssh_user="root"

## output formatting
bold="$(tput bold)"
dim="$(tput dim)"
std="$(tput sgr0)"
red=$(tput setaf 1)
green=$(tput setaf 2)
blue=$(tput setaf 4)
white=$(tput setaf 7)

arg_mpd_host=""
arg_mpd_port=""
arg_ssh_user=""
arg_mpd_music_dir=""
arg_mpd_password=""

#PS4='+ $(date "+%s.%N")\011 '
#exec 3>&2 2>/tmp/bashstart.$$.log
#set -x

function display_usageinfo() {

    msg_usage="\
Usage:
${app_name_mm} -d|--mpd-music-dir PATH [optional arguments]
-or-
${app_name_mm} PATH

PATH should be the path to the directory used as 'music_directory' by
mpd running on MPDHOST.

Optional arguments:
 -m|--mpd-host MPDHOST    The IP address or hostname on which mpd
                          runs.
			  Defaults to 'localhost'.
 -p|--mpd-port MPDPORT    The port on which mpd on MPDHOST
                          listens.
			  Defaults to '6600'.
 -x|--mpd-password PASSWD The password for mpd.
 -u|--ssh-user SSHUSER    The username for the ssh connection to
                          MPDHOST used to get realtime alsa
                          information on MPDHOST.
			  (Only used when MPDHOST is remote, ie not
			  'localhost' or '127.0.x.y'.)

Background information:
${app_info_url}
"
    printf 1>&2 "%s\n" "${msg_usage}"
}


function analyze_command_line() {
    ## parse command line arguments using the `manual loop` method
    ## described in http://mywiki.wooledge.org/BashFAQ/035.
    while :; do
        case "${1:-}" in
            -h|--mpd-host)
		if [[ "${2}x" == "x" ]]; then
		    die "argument \`$1' requires the dns host name or ip address for the host running mpd."
		else
		    arg_mpd_host="$2"
		    shift 2
                    continue
		fi
		;;
	    -x|--mpd-password)
		if [[ "${2}x" == "x" ]]; then
		    die "argument \`$1' requires a non-empty value."
		else
		    arg_mpd_password="${2}"
		    shift 2
                    continue
		fi
		;;
	    -u|--ssh-user)
		if [[ "${2}x" == "x" ]]; then
                    die "argument \`$1' requires a non-empty value."
		else
		    arg_ssh_user="${2}"
		    shift 2
                    continue
		fi
		;;
            -d|--mpd-music-dir)
		if [[ "${2}x" == "x" ]]; then
                    die "argument \`$1' requires the path to the directory where the music for mpd is stored."
		    break
		else
		    arg_mpd_music_dir="$2"
		    mpd_music_dir="${arg_mpd_music_dir}"
		    shift 2
                    continue
		fi
		;;
	    -\?|--help)
		display_usageinfo
		exit
		;;
            --)
		shift
		break
		;;
	    -?*)
		printf "Notice: unknown option \`%s' ignored\n\n." "$1" 1>&2
		display_usageinfo
		exit
		;;
            *)
		break
        esac
    done

    ## shift the options index to get the remainder of the command
    ## line arguments containing the font descriptions
    ## and return them as 0-separated strings.
    #printf 1>&2 "OPTIND: \`%s'\n" "${OPTIND}"
    shift $((OPTIND - 1))
    if [[ "${arg_mpd_music_dir}x" == "x" ]]; then
        arg_single="$@"
        arg_mpd_music_dir="${arg_single}"
        if [[ ! -d "${arg_mpd_music_dir}" ]]; then
	    printf 1>&2 "error: invalid mpd music directory \`%s' specified.\n\n" \
			"${arg_mpd_music_dir}"
            display_usageinfo
        else
            ## single argument, use in defaults
	    mpd_music_dir="${arg_mpd_music_dir}"
	    mpd_host="${def_mpd_host}"
	    mpd_port="${def_mpd_port}"
	    mpd_password=""
	    ssh_host=""
        fi
    else
	[[ ${DEBUG} ]] && \
	    declare -p arg_mpd_music_dir \
		    arg_mpd_host arg_mpd_port arg_mpd_password \
		    arg_ssh_user 1>&2
    fi

}

function die() {
    printf "error: %s\n" "$@" 1>&2
    exit 1
}

function bytes_to_si() {
    ## see: http://www.pixelbeat.org/docs/numfmt.html
    ## return the human notation for the number of bytes specified in $1.
    ## strip decimals from input
    bytes="${1}"
    si_size=""
    if [[ "${cmd_numfmt}x" != "x" ]]; then 
	#bytes="$(LC_ALL=nonexisting numfmt --from=si ${si_size})"
	si_size="$(LC_ALL=nonexisting ${cmd_numfmt} --to=iec-i --suffix=B --format="%.1f" "${bytes}"  2>/dev/null)"
    fi
    if [[ "${si_size}x" == "x" ]]; then
	echo TODO 1>&2
	return 1
    fi
    printf "%s" "${si_size}"
}


function run_func() {
    ## run an internal function whose name is specified in $1 with
    ## args on the local host or remote through ssh.
    func="$1"
    shift
    args="$@"
    [[ ${DEBUG} ]] && \
	declare -p 1>&2 func args
    if [[ "${alsa_ssh_userhost}x" == "x" ]]; then
	"${func} ${args}"
    else
	## use declare -f to first print the function in the remote
	## bash session, and then execute it.
	ssh ${alsa_ssh_userhost} -- \
	    "$(declare -f ${func}); ${func} ${args}"
    fi
}


function check_commands() {
    declare -a err
    msg="not found in PATH"
    cmd_mpc=$(type -p mpc) || err+=("mpc")
    cmd_soxi=$(type -p soxi) || err+=("soxi")
    cmd_exiftool=$(type -p exiftool) || err+=("exiftool")
    cmd_netcat=$(type -p nc) || err+=("netcat (nc)")
    cmd_bc=$(type -p bc) || err+=("bc")
    cmd_numfmt=$(type -p numfmt)
    if [[ ${#err[@]} -gt 0 ]]; then
	printf 1>&2 "required command \`%s' ${msg}\n" "${err[@]}"
	return 1
    fi
}

function get_csv_value() {
    data="$1"
    IFS=\; read type field value <<<"${data}"
    printf "%s" "${value//\"}"
}

function get_soxi_value() {
    fieldname="$1"
    printf 1>&2 "%s: fieldname='%s', value='%s'\n" \
		"${FUNCNAME[0]}" "${fieldname}" "${soxi_info["${fieldname}"]}"
    declare vals="${soxi_info["${fieldname}"]}"
    #declare -p vals 1>&2
    value="$(get_csv_value "${vals[0]}")"
    printf "%s" "${value}"
}

function filter_soxi_duration() {
    ## expects: hh:mm:ss.xxx where xxx are the subseconds (milliseconds?)
    duration_fields=($1)
    IFS=":" read hours minutes seconds subseconds <<<"${duration_fields[0]//./:}"
    minutes=$(${cmd_bc} <<< "${minutes} + ( ${hours} * 60 )")
    printf "%s:%s" "${minutes}" "${seconds}"
}


function ret_mpdconf_contents() {
    ## return the contents of the mpd configuration file specified in
    ## $1.
    mpdconf_path="$1"
    alsa_ssh_userhost="${alsa_ssh_userhost:-}"
    if [[ -f "${mpdconf_path}" ]]; then
	cat "${mpdconf_path}"
    else
	printf 1>&2 "error: mpd configuration file %s does not exist on host %s.\n" \
		    "${mpdconf_path}" "$(hostname)"
	return 1
    fi
}


function ret_mpdconf_commandline() {
    ## return the command line arguments for running mpd
    alsa_ssh_userhost="${alsa_ssh_userhost:-}"
    mpd_pid="$(pidof mpd | awk '{print $1}')"
    xargs -0 echo < /proc/${mpd_pid}/cmdline
}


function ret_mpdconf_default() {
    ## function 
    for conffile in $XDG_CONFIG_HOME/mpd/mpd.conf \
			~/.mpdconf \
			~/.mpd/mpd.conf \
			/etc/mpd.conf; do 
	if [[ "${conffile}x" != "x" ]]; then 
	    if [[ -f ${conffile} ]]; then
		[[ ${DEBUG} ]] && \
		    printf 1>&2 "using mpd configuration file %s\n" \
				"${conffile}"
       		echo ${conffile}
      		return 0
	    fi
	fi
    done
    printf 1>&2 "warning: no mpd configuration found.\n"
    return 1
}


function ret_mpdconf_path() {
    ## returns the name of the mpd.conf file in use by mpd (either
    ## local or remote)
    ## the command mpd itself (including a possible path) gets
    ## stripped before
    ## all possible mpd command line arguments
    mpd_args=(--no-config)    
    mpd_args+=(--no-daemon)
    mpd_args+=(-v)
    mpd_args+=(--verbose)
    mpd_args+=(--stderr)
    ## strip each command line argument from all possible arguments
    ## the remainder is the mpd conf file
    mpd_real_args=($(run_func ret_mpdconf_commandline))
    mpd_rest_args=(${mpd_real_args[@]:1})
    for arg in ${mpd_args[@]}; do
	mpd_rest_args=(${mpd_rest_args[@]//${arg}})
    done
    [[ ${DEBUG} ]] && \
	declare -p mpd_args mpd_real_args mpd_rest_args 1>&2
    mpd_conf_file="${mpd_rest_args[0]}"
    if [[ "${mpd_conf_file}x" == "x" ]]; then
	[[ ${DEBUG} ]] && \
	    printf 1>&2 "no conffile specified on mpd command line, \
test default locations\n"
	run_func ret_mpdconf_default || return 1
    else
	printf "%s" "${mpd_conf_file}"
    fi
}

function get_mpdconf_contents() {
    mpdconf_path="$1"
    run_func ret_mpdconf_contents "${mpdconf_path}"  || return 1
}


function get_mpd_alsa_outputs() {
    ## query the (local or remote) mpd configuration file for alsa audio outputs.
    ## returns newline separated list of alsa output devices
    ## TODO; handle multiple outputs
    #    while read -r line; do
    #    done< <(ssh ${alsa_ssh_userhost} -- "cat /ec/mpd.conf")
    mpdconf_path=$(ret_mpdconf_path)
    [[ ${DEBUG} ]] && printf 1>&2 "%s: mpdconf_path=\`%s'\n" "${FUNCNAME}" "${mpdconf_path}"
    #mpdconf_contents="$(get_mpdconf_contents "${mpdconf_path}")"
    #declare -p mpdconf_path mpdconf_contents 1>&2
    start_audio_output_re="^[[:space:]]*audio_output[[:space:]]*\{"
    end_audio_output_re="[[:space:]]*\}"
    ## only handle alsa audio outputs
    type_re="^[[:space:]]*type[[:space:]]*[\"'](.*)[\"']"
    device_re="^[[:space:]]*device[[:space:]]*[\"']hw:([0-9]+),([0-9]+)[\"']"    
    audio_outputs=0
    inside_audio_output=
    inside_alsa_output=
    declare -a devices
    while read -r line; do
	# declare -p line inside_audio_output inside_alsa_output 1>&2 
	if [[ "${inside_audio_output}x" == "x" ]]; then
	    if [[ "${line}" =~ ${start_audio_output_re} ]]; then
		## new audio_output started
		((audio_outputs++))
		inside_audio_output=true
		[[ ${DEBUG} ]] && \
		    printf 1>&2 "\n *** starting audio_output\n"
	    elif [[ "${line}" =~ ${end_audio_output_re} ]]; then
		## end of audio output
		inside_audio_output=
	    fi
	else
	    if [[ "${line}" =~ ${type_re} ]]; then
		type="${BASH_REMATCH[1]}"
		[[ ${DEBUG} ]] && \
		    printf 1>&2 "  ** audio_output type: %s\n" "${type}"		
		if [[ "${type}x" == "alsax" ]]; then
		    inside_alsa_output=true
		else
		    inside_alsa_output=
		fi
	    elif [[ "${line}" =~ ${device_re} ]] && \
		     [[ "${inside_alsa_output}x" != "x" ]]; then
		alsa_dev="${BASH_REMATCH[1]}"
		alsa_int="${BASH_REMATCH[2]}"
		[[ ${DEBUG} ]] && \
		    printf 1>&2 "  ** audio_output device: hw:%s,%s\n" \
				"${alsa_dev}" "${alsa_int}"
		devices+=("hw:${alsa_dev},${alsa_int}")
		inside_audio_output=
		inside_alsa_output=
	    fi
	fi
    done< <(get_mpdconf_contents "${mpdconf_path}")
    [[ ${DEBUG} ]] && \
	declare -p audio_outputs devices 1>&2
    ## TODO: handle multiple devices
    for device in ${devices[@]}; do
	printf "%s\n" "${device}"
    done
}

function fill_arrays() {
    ret_mpc_info || return 1
    #ret_mpc_now
    ret_mpd_now || return 1
    ret_exif_info "${mpc_vals[file]}"
    ret_soxi_info "${mpc_vals[file]}"
    ## TODO get right card and interface numbers
    alsa_outputs=("$(get_mpd_alsa_outputs)")
    [[ ${DEBUG} ]] && declare -p alsa_outputs 1>&2
    #for output in ${alsa_outputs[0]}; do
#	ret_alsa_info "${output}"
 #   done
    for output in ${alsa_outputs[@]}; do
    	ret_alsa_info "${output}"
    done
    #[[ "${exif_vals[*]}x" == "x" ]] || ret_exif_info "${mpc_vals[file]}"
    #[[ "${soxi_vals[*]}x" == "x" ]] || ret_soxi_info "${mpc_vals[file]}"
    #[[ "${alsa_vals[*]}x" == "x" ]] || ret_alsa_info "1" "0" "root@sonida"
}
    

function alsa_format_outputencoding() {
    ## extract alsa output encoding format and store in appropriate array.
    alsa_encoding="$1" # ${alsa_vals[format]}
    encoding_re="([SU])([0-9]+)_([0-3]*[LB]E)"
    if [[ "${alsa_encoding}" =~ ${encoding_re} ]]; then 
	signedness="${BASH_REMATCH[1]}"
	bitdepth="${BASH_REMATCH[2]}"
	alsa_encoding[bitdepth]="${bitdepth}"
	endianness="${BASH_REMATCH[3]}"
	case "${signedness}" in
	    U) alsa_encoding[signedness]="unsigned" ;;
	    S) alsa_encoding[signedness]="signed" ;;
	esac
	case "${endianness}" in
	    *LE) alsa_encoding[endianness]="little endian" ;;
	    *BE) alsa_encoding[endianness]="big endian" ;;
	esac
    else
	printf "ANOMALITY in %s: alsa_encoding '%s' does not match regex.\n" \
	       "${FUNCNAME[0]}" "${alsa_encoding}"
	return 1
    fi
}
	

function get_info() {

    ## check presence of needed commands
    check_commands || die "not all needed commands are installed."

    ## parse command line arguments
    analyze_command_line "$@"
    
    if [[ ! -d "${mpd_music_dir}" ]]; then
	die "error: can't access directory ${mpd_music_dir}."
    fi
    mpd_host="${arg_mpd_host:-${def_mpd_host}}"
    mpd_port="${arg_mpd_port:-${def_mpd_port}}"
    ssh_user="${arg_ssh_user:-${def_ssh_user}}"
    mpd_password="${arg_mpd_password:-}"
    ssh_host="${mpd_host:-}"
    localhost_re="127.0.[0-9]+.[0-9]+|localhost"
    if [[ "${mpd_host}" =~ ${localhost_re} ]]; then
	## mpd runs local, no need for ssh to get alsa properties
	alsa_ssh_userhost=""
    else
	alsa_ssh_host="${mpd_host}"
	## mpd runs remote, use ssh to get alsa properties	
	alsa_ssh_userhost="${ssh_user}@${ssh_host}"
    fi
    [[ ${DEBUG} ]] && \
	declare -p mpd_host ssh_host ssh_user mpd_music_dir 1>&2
    
    fill_arrays
    [[ ${DEBUG} ]] && \
	declare -p mpc_vals mpd_vals 1>&2
    
    main_playing_tracktitle="${mpc_vals[title]}"
    main_playing_trackartist="${mpc_vals[artist]}"
    main_playing_trackperformers="${exif_vals[Performer]}"
    main_rt_tracknumber_album="${mpc_vals[track]}"
    main_rt_tracknumber_playlist="${mpc_vals[position]}"
    main_rt_playlistlength="${mpd_vals[rt_raw_playlistlength]}"
    main_playing_trackalbumname="${mpc_vals[album]}"
    main_playing_trackalbumnumber="${mpc_vals[position]}"
    main_playing_trackalbumartist="${mpc_vals[albumartist]}"
    main_playing_trackduration="$(filter_soxi_duration "${soxi_vals[Duration]}")"
    [[ $? -ne 0 ]] && return 1
    file_path="${arg_mpd_music_dir}/${mpc_vals[file]}"
    if [[ ! -f "${file_path}" ]]; then
	return 1
	## TODO
    fi
    a_du_output=($(du --bytes --dereference "${file_path}"))
    main_file_sizebytes="${a_du_output[0]}"
    ## TODO: declare -p main_file_sizebytes 1>&2
    main_file_sizehbytes="$(bytes_to_si "${main_file_sizebytes}")"
    [[ $? -ne 0 ]] && return 1
    msg_filesize="$(printf "%-10s: %-13s (%s)" \
"File size" "${main_file_sizebytes} bytes" "${main_file_sizehbytes}")"
    
    main_file_bitrate_raw="${soxi_vals[BitRate]}"
    main_file_bitrate_value="${main_file_bitrate_raw:0:-1}"
    main_file_bitrate_unit="${main_file_bitrate_raw:$(( ${#main_file_bitrate_raw} - 1 )):1}"
    main_file_bitrate_kvalue=
    if [[ "${main_file_bitrate_unit}x" == "Mx" ]]; then
	int="${main_file_bitrate_value%%.*}"
	dec="${main_file_bitrate_value##*.}"
	## TODO
	[[ ${DEBUG} ]] && \
	    declare -p main_file_bitrate_value int dec 1>&2
	main_file_bitrate_kvalue=$(bc <<< "${main_file_bitrate_value} * 1000")
    else
	main_file_bitrate_kvalue="${main_file_bitrate_value}"
    fi
    main_file_bitrate_kvalue="${main_file_bitrate_kvalue%%.00}"
    main_file_bitrate="${main_file_bitrate_kvalue}"
    main_file_bitdepth="${soxi_vals[Precision]//-bit}"
    main_file_samplerate="${soxi_vals[SampleRate]}"
    #declare -p alsa_vals 1>&2
    main_output_samplerate_raw=(${alsa_vals[rate]})
    main_output_samplerate="${main_output_samplerate_raw[0]}"
    ## get and store alsa output encoding
    alsa_format_outputencoding "${alsa_vals[format]}"
    main_output_bitdepth="${alsa_encoding[bitdepth]}"
    main_output_sampleencoding="${alsa_encoding[bitdepth]} bit (${alsa_encoding[signedness]} ${alsa_encoding[endianness]})"
    main_output_samplechannelcount="${alsa_vals[channels]}"

    main_playing_trackplayingtime="${mpc_vals[rt_time_elapsed_minutes]}:${mpc_vals[rt_time_elapsed_seconds]}"
    main_playing_trackplayingpercentage="${mpc_vals[rt_percentage_played]}%"
    #declare -p main_playing_trackplayingpercentage 1>&2
    main_mpd_bitdepth="${mpd_vals[rt_audio_bitdepth]}"
    main_mpd_samplerate="${mpd_vals[rt_audio_samplerate]}"
    main_mpd_bitrate="${mpd_vals[rt_audio_bitrate]}"

    ## determine if playback is bit perfect
    color_bitdepth_file_mpd="${red}"
    color_bitdepth_mpd_output="${red}"
    if [[ ${main_mpd_bitdepth} -ge ${main_file_bitdepth} ]]; then
	color_bitdepth_file_mpd="${green}"
	if [[ ${main_output_bitdepth} -ge ${main_mpd_bitdepth} ]]; then
	    color_bitdepth_mpd_output="${green}"
	fi
    fi
    color_samplerate_file_mpd="${red}"
    color_samplerate_mpd_output="${red}"
    if [[ ${main_mpd_samplerate} -ge ${main_file_samplerate} ]]; then
	color_samplerate_file_mpd="${green}"
	if [[ ${main_output_samplerate} -ge ${main_mpd_samplerate} ]]; then
	    color_samplerate_mpd_output="${green}"
	fi
    fi

    ## prepare output 
    msg_header="$(printf "%-11s %-18s  ${white}%8s${std}    ${white}%8s${std}    ${white}%8s${std}" " " " " "${label_input}" "${label_throughput}" "${label_output}")"
    msg_bitrate="$(printf "%-11s %-18s: ${dim}${white}%8s${std}  > ${white}%8s${std}  > ${dim}${white}%8s${std}" \
" " "${label_bitrate}" "${main_file_bitrate}" "${main_mpd_bitrate}" "(n/a)")"
    msg_bitdepth="$(printf "%-11s %-18s: %8s  ${color_bitdepth_file_mpd}> %8s  ${color_bitdepth_mpd_output}> %8s${std}" \
" " "${label_bitdepth}" "${main_file_bitdepth}" "${main_mpd_bitdepth}" "${main_output_bitdepth}")"
    msg_samplerate="$(printf "%-11s %-18s: %8s  ${color_samplerate_file_mpd}> %8s${std}  ${color_samplerate_mpd_output}> %8s${std}" \
" " "${label_samplerate}" "${main_file_samplerate}" "${main_mpd_samplerate}" "${main_output_samplerate}")"

    msg_tracktitle="${bold}${white}${main_playing_tracktitle}${std}"
    msg_trackartist="${blue}${main_playing_trackartist}${std}"
    msg_tracknumber="$(printf "%-4s of %-3s" "#${bold}${blue}${main_rt_tracknumber_playlist}${std}" "${main_rt_playlistlength}")"
    msg_nowplaying="${msg_tracknumber}: ${msg_tracktitle}"
    msg_byline="$(printf "%-11sby %s" " " "${msg_trackartist}")"
    msg_albumline="$(printf "%-11strack %s from album %s" \
" " "${bold}${main_rt_tracknumber_album}${std}" "${bold}${blue}${main_playing_trackalbumname}${std}")"
    msg_playingtime="$(printf "%-13s   playing %s from %s (%s)" \
" " "${bold}${std}${main_playing_trackplayingtime}${std}" "${main_playing_trackduration}" "${main_playing_trackplayingpercentage}")"

    echo -en "\
${msg_playingtime}
${msg_nowplaying}
${msg_albumline}
${msg_byline}

${msg_header}
${msg_bitdepth}
${msg_samplerate}
${msg_bitrate}

${msg_filesize}
\r"
}

function ret_formatted_time() {
    ## returns formatted time (hh:mm:ss) from number of seconds ($1)
    ## https://stackoverflow.com/questions/12199631/convert-seconds-to-hours-minutes-seconds
    nr_seconds="${1}"
    hours=$(bc <<< "${nr_seconds}/3600")
    minutes=$(bc <<< "(${nr_seconds}%3600)/60")
    seconds=$(bc <<< "${nr_seconds}%60")
    printf "%02d:%02d:%02d" \
	   "${hours}" "${minutes}" "${seconds}"
}

function ret_mpd_now() {
    ## echo status command to mpd host on mpd port using netcat, to
    ## fill mpc_vals array with rt_ fields

    [[ ${DEBUG} ]] && \
	declare -p cmd_netcat mpd_host mpd_port 1>&2
    res=$(${cmd_netcat} --help 2>&1 >/dev/null)
    if [[ $? -ne 0 ]]; then
	netcat_args=(-N)	
    else
	netcat_args=(--close)	
    fi
    ## get realtime mpd status using netcat
    mpd_status="$(${cmd_netcat} ${netcat_args[@]} ${mpd_host} ${mpd_port} <<<  "status")"
    [[ ${DEBUG} ]] && \
	declare -p mpd_status 1>&2
    linecounter=1
    prefix="rt_raw"
    key_val_re="^([^\:]+):[[:space:]]+(.*)"
    ## store each line in an associative array, by splitting the mpc
    ## output lines (paramater:value)
    while read -r line; do
	if [[ "${line}" =~ ${key_val_re} ]]; then
	    field="${BASH_REMATCH[1]}"
	    value="${BASH_REMATCH[2]}"
	    mpd_vals["${prefix}_${field}"]="${value}"
	fi
    done<<<"${mpd_status}"
    ## store the double colon separated values
    ## (samplerate:bitdepth:channelcount, eg. 48000:24:2) of the
    ## audiofield in separate variables and an array
    IFS=: read audio_samplerate audio_bitdepth audio_channelcount <<< "${mpd_vals[${prefix}_audio]}"
    mpd_vals["rt_audio_samplerate"]="${audio_samplerate}"
    mpd_vals["rt_audio_bitdepth"]="${audio_bitdepth}"
    mpd_vals["rt_audio_channelcount"]="${audio_channelcount}"
    mpd_vals["rt_audio_bitrate"]="${mpd_vals[${prefix}_bitrate]}"

    ## store the (elapsed) playing time value (seconds:frames,
    ## eg. 20:123) in separate variables and an array
    IFS=: read time_elapsed_seconds time_duration_seconds <<< "${mpd_vals[${prefix}_time]}"
    mpd_vals["rt_time_elapsed_seconds"]="${time_elapsed_seconds}"
    mpd_vals["rt_time_duration_seconds"]="${time_duration_seconds}"
    mpd_vals["rt_time_elapsed_formatted"]="$(ret_formatted_time "${time_elapsed_seconds}")"
    mpd_vals["rt_time_duration_formatted"]="$(ret_formatted_time "${time_duration_seconds}")"
    #mpd_vals["rt_time_tracktotal"]="${mpd_vals[${prefix}_tracktotal]}"
    ## old
    #mpd_val rt_time_tracktotal: '223'
    #mpd_val rt_raw_time: '53:223'
    #mpd_val rt_raw_elapsed: '52.911'
    #mpd_val rt_raw_duration: '223.168'

    if [[ ${DEBUG} ]]; then 
	for k in "${!mpd_vals[@]}"; do
     	    if [[ "${k}" =~ ^rt ]]; then
     		printf 1>&2 "mpd_val %s: '%s'\n" "${k}" "${mpd_vals[${k}]}"
     	    fi
	done
    fi
}

function ret_mpc_info() {
    ## get information from mpd using mpc with the 'current' command
    ## and a format string.
    if [[ "${mpd_password}x" == "x" ]]; then
	mpc_args=(-h "${mpd_host}")
    else
	mpc_args=(-h "${mpd_password}@${mpd_host}")
    fi
    mpc_args+=(-p "${mpd_port}")
    mpc_args+=(current)
    mpc_args+=(-f "${mpc_format_string}")
    [[ ${DEBUG} ]] && \
	declare -p mpc_format_string 1>&2
    res="$(${cmd_mpc} "${mpc_args[@]}" &)"
    if [[ $? -ne 0 ]]; then
	die "${FUNCNAME[0]}: mpd on %s is not running."
    else
	if [[ "${res}x" == "x" ]]; then 
	    printf 1>&2 "mpd on %s is not currently playing anything.\n" \
			"${mpd_host}"
	    return 1
	fi
    fi
    field_val_re="^([^\:]+):(.*)"
    while read -r line; do
	if [[ "${line}" =~ ${field_val_re} ]]; then
	    field="${BASH_REMATCH[1]}"
	    val="${BASH_REMATCH[2]}"
	    mpc_vals["${field}"]="${val}"
	fi
    done<<<"${res}"
}

function ret_soxi_info() {
    rel_file_path="${1}"
    file_path="${arg_mpd_music_dir}/${rel_file_path}"
    if [[ -f "${file_path}" ]]; then 
	res="$(${cmd_soxi} "${file_path}")"
	field_val_re='([^\:]+):[[:space:]]*(.*)'
	while read -r line; do
	    if [[ "${line}" =~ ${field_val_re} ]]; then
		field="${BASH_REMATCH[1]}"
		field="${field// /}"
		val="${BASH_REMATCH[2]}"
		soxi_vals["${field}"]="${val}"
		if [[ "${field}x" == "Sample Encodingx" ]]; then
		    break
		fi
	    fi
	done<<<"${res}"
    fi
}

function ret_exif_info() {
    rel_file_path="${1}"
    file_path="${arg_mpd_music_dir}/${rel_file_path}"
    if [[ -f "${file_path}" ]]; then 
	res="$(${cmd_exiftool} -j "${file_path}")"
	field_val_re='"([^\:]+)":(.*)'
	while read -r line; do
	    if [[ "${line}" =~ ${field_val_re} ]]; then
		field="${BASH_REMATCH[1]}"
		val="${BASH_REMATCH[2]}"
		exif_vals["${field}"]="${val}"
	    fi
	done<<<"${res}"
    fi
}

function get_hwparams() {
    ## tries to get the contents of
    ## /proc/asound/card${alsa_card_no}/pcm${alsa_dev_no}p/sub0/hw_params
    ## using alsa_card $1 and alsa_dev $2.
    ## (called by run_func so could be remote).
    ## returns newline separated file contents or an error.
    alsa_card_no="$1"
    alsa_dev_no="$2"
    [[ ! -z ${DEBUG} ]] && \
	declare -p alsa_card_no alsa_dev_no 1>&2
    hwparams_file="/proc/asound/card${alsa_card_no}/pcm${alsa_dev_no}p/sub0/hw_params"
    if [[ -f "${hwparams_file}" ]]; then
	## return the contents of the file
	xargs -0 echo < "${hwparams_file}"
    else
	[[ ${DEBUG} ]] && \
	    printf 1>&2 "error accessing file: '%s' on host '%s'\n" \
			"${hwparams_file}" "$(hostname)"
	return 1
    fi
}

function ret_alsa_info() {
    ## TODO: fix handling of mpd output(s)
    ## expects "hw:x,y"
    alsa_hw="${1//hw:/}"
    alsa_dev_no="${alsa_hw##*,}"
    alsa_card_no="${alsa_hw%%,*}"
    alsa_ssh_userhost="${alsa_ssh_userhost:-}"
    unset mpd_outputs
    declare -a mpd_outputs
    [[ ${DEBUG} ]] && \
	declare -p alsa_hw alsa_card_no alsa_dev_no alsa_ssh_userhost
    declare -a mpc_args
    if [[ "${mpd_password}x" == "x" ]]; then
	mpc_args=(-h "${mpd_host}")
    else
	mpc_args=(-h "${mpd_password}@${mpd_host}")
    fi
    mpc_args+=(-p "${mpd_port}")
    mpc_args+=(output)
    [[ ${DEBUG} ]] && \
	declare -p mpd_host mpd_port mpc_args 1>&2
    mpc_output_re="Output[[:space:]]([0-9]+)[[:space:]]\(([^\(]+)\)"
    while read -r line; do
	if [[ "${line}" =~ ${mpc_output_re} ]]; then
	    mpd_outputs+=("${BASH_REMATCH[2]}")
	fi
    done< <(${cmd_mpc} "${mpc_args[@]}")
    [[ ${DEBUG} ]] && \
	declare -p mpd_outputs 1>&2
    key_val_re="^([^\:]+):[[:space:]]+(.*)"
    while read -r line; do
	if [[ "${line}" =~ ${key_val_re} ]]; then
	    field="${BASH_REMATCH[1]}"
	    val="${BASH_REMATCH[2]}"
	    alsa_vals["${field}"]="${val}"
	    [[ ${DEBUG} ]] && \
		declare -p line field val 1>&2
	else
	    [[ ${DEBUG} ]] && \
		declare -p line 1>&2
	    return 1
	fi
    done< <(run_func get_hwparams "${alsa_card_no} ${alsa_dev_no}")
}

function terminal_size() { # Calculate the size of the terminal
    terminal_cols="$(tput cols)"
    terminal_rows="$(tput lines)"
}


function main_loop() {
    ## unused
    mpc_args=(-h "${mpd_host}")
    counter=0
    while : ; do
	#"${cmd_mpc}" "${mpc_args[@]}" idle
	sleep 0.5
	get_info || return 1
	fill_arrays
	# \r"
	((counter++))
	echo -en "bla die bla $counter\ntwee bla die bla $counter\r"
	
	#tclsh /etc/shairport/smartie/smartie-cat.tcl -tty /dev/ttyUSB0
    done
    printf 1>&2 "main_loop done.\n"
}

unset mpc_vals
unset mpd_vals
unset alsa_vals
unset exif_vals
unset soxi_vals

declare -A alsa_vals
declare -A mpc_vals
declare -A mpd_vals
declare -A exif_vals
declare -A soxi_vals

## input | nfs://srv/media/music/.../track11.aiff
##       | AIFF (Little Endian) PCM in 24bit/192kHz  @ 4.503bit/s
label_input="Storage"
label_throughput="MPD"
label_output="DAC"
label_samplerate="Sample rate (Hz)"
label_bitdepth="Bit depth (bit)"
label_bitrate="Bit rate (kbit/s)"

main_file_bitdepth=
main_file_bitrate=
main_file_bitrate_kvalue=
main_file_bitrate_raw=
main_file_bitrate_unit=
main_file_bitrate_value=
main_file_samplerate=
main_file_sizebytes=
main_mpd_bitdepth=
main_mpd_bitrate=
main_mpd_samplerate=
main_output_bitdepth=
main_output_samplechannelcount=
main_output_sampleencoding=
main_output_samplerate=
main_output_samplerate_raw=
main_playing_trackalbumartist=
main_playing_trackalbumname=
main_playing_trackalbumnumber=
main_playing_trackartist=
main_playing_trackduration=
main_playing_trackperformers=
main_playing_trackplayingpercentage=
main_playing_trackplayingtime=
main_playing_tracktitle=
main_rt_tracknumber_album=
main_rt_tracknumber_playlist=
main_rt_playlistlength=

declare -A alsa_encoding
declare -a mpc_fields=(
    album
    albumartist
    artist
    comment
    composer
    date
    disc
    file        	      
    genre
    mdate
    mtime
    name
    performer
    position
    time
    title
    length
    track
)

mpc_format_string=
for mpc_field in ${mpc_fields[@]}; do 
	mpc_format_string+="${mpc_field}:[%${mpc_field}%]\n"
done

## if the script is not sourced by another script but run within its
## own shell call function `analyze_commandline_args'
[[ "${BASH_SOURCE[0]:-}" != "${0}" ]] || \
    get_info "$@"

#set +x
#exec 2>&3 3>&-