#!/bin/bash

version=0.2.9
protocol=
distrib=unknown
distribver=0.0
tmpdir=$TMPDIR
if test -z "$tmpdir"; then
	tmpdir="/tmp"
fi
tmpdir=$tmpdir/alsa-compile-script
baseurl="http://www.alsa-project.org/snapshot/?package="
package=alsa-driver
packagedefault=true
url=
urldefault=
gittree="git://git.alsa-project.org/"
httpdownloader=
clean=
compile=
install=
quiet=
yes=
kernelmodules=
kmodlist=
kmodremove=
kmodclean=
depmodbin=
modinfobin=
runargs=
patches=
kmodmesg=
withdebug=
shell=
branch=
kernel=

fuser_prg=fuser
insmod_prg=insmod
rmmod_prg=rmmod
lsmod_prg=lsmod
modprobe_prg=modprobe
test -x /sbin/fuser && fuser_prg=/sbin/fuser
test -x /sbin/insmod && insmod_prg=/sbin/insmod
test -x /sbin/rmmod && rmmod_prg=/sbin/rmmod
test -x /sbin/lsmod && lsmod_prg=/sbin/lsmod
test -x /sbin/modprobe && modprobe_prg=/sbin/modprobe

usage() {
	echo "Usage: $0 [OPTION]..."
	cat <<EOF

This is a script version $version doing ALSA code compilation and installation.
Report any problems to <alsa-devel@alsa-project.org> mailing list.

Operation modes:
  -h, --help		print this help, then exit
  -e, --examples	print text with examples, then exit
  -q, --quiet		quiet mode
  -y, --yes		do not ask any questions - answer is always yes
  -c, --clean[=package]	do overall clean, do package clean
  --url=url		package url
  --git=giturl		work with git tree
  --compile		force compilation
  --install		install binaries and headers
  --patch=patch		apply code patch (can be used multiple times)
  --tmpdir=dir		set temporary directory (overrides TMPDIR envval)
  --kmodules[=mods]	reinsert kernel modules or insert specified modules
  			to current kernel; more modules can be delimited
  			with ',' and arguments can be delimited with ':'
  --kmodlist		list ALSA toplevel kernel modules
  --kmodremove		remove ALSA kernel modules from kernel
  --kmodclean		remove installed ALSA kernel modules from /lib/modules
  --kmodmesg		show ALSA kernel related messages
  --run program [args]  run a program using fresh alsa-lib
  --with-debug=dbgopt	set debug options to dbgopt (for alsa-driver)
  --shell		run shell in the directory with sources
  --branch=branch	branch for git clone
  --kernel=tree		kernel build tree

Package selection:
  --driver		compile alsa-driver package (default)
  --lib			compile alsa-lib package
  --utils		compile alsa-utils package
  --plugins		compile alsa-plugins package
  --firmware		compile alsa-firmware package
  --oss			compile alsa-oss package
EOF
}

examples() {
	cat <<EOF
$0 examples:

  Install latest ALSA driver snapshot to system:

	alsa-compile.sh --driver --install

  Try new ALSA driver snapshot without installing it to system. The existing
  ALSA kernel modules are replaced with fresh ones:

	alsa-compile.sh --driver --kmodules

  Do both (installation and modules replacement):
  
  	alsa-compile.sh --driver --install --kmodules

  Install latest ALSA library snapshot to system:
  
  	alsa-compile.sh --lib --install

  Run application using latest ALSA library snapshot. The new alsa-lib is not
  installed to system:
  
  	alsa-compile.sh --run <your_program_including_arguments>

  Do not want to fetch sources? Use file: protocol to specify current or
  explicit directory containing sources:
  
  	alsa-compile.sh --driver --url=file:///home/alsa/alsa-driver
EOF
}

while :
do
	case "$1" in
	-h|--help)
		usage
		exit 0
		;;
	-e|--examples)
		examples
		exit 0
		;;
	-q|--quiet)
		quiet=true ;;
	-y|--yes)
		yes=true ;;
	-c*|--clean*)
		clean="full"
		case "$#,$1" in
		*,*=*)
			clean=`expr "z$1" : 'z-[^=]*=\(.*\)'`
			test -z "$clean" && clean="full" ;;
		1,*)
			;;
		*)
			clean="$2"
			shift ;;
		esac
		;;
	--url*)
		case "$#,$1" in
		*,*=*)
			url=`expr "z$1" : 'z-[^=]*=\(.*\)'` ;;
		1,*)
			usage ;;
		*)
			url="$2"
			shift ;;
		esac
		if test -d "$url"; then
			url="file:///$url"
		fi
		;;
	--git*)
		case "$#,$1" in
		*,*=*)
			url=`expr "z$1" : 'z-[^=]*=\(.*\)'`
			test -z "$url" && url="$gittree" ;;
		1,*)
			url="$gittree" ;;
		*)
			url="$2"
			shift ;;
		esac
		;;
	--branch*)
		case "$#,$1" in
		*,*=*)
			branch=`expr "z$1" : 'z-[^=]*=\(.*\)'` ;;
		1,*)
			usage ;;
		*)
			branch="$2"
			shift ;;
		esac
		;;
	--kernel*)
		case "$#,$1" in
		*,*=*)
			kernel=`expr "z$1" : 'z-[^=]*=\(.*\)'` ;;
		1,*)
			usage ;;
		*)
			kernel="$2"
			shift ;;
		esac
		;;
	--with-debug*)
		case "$#,$1" in
		*,*=*)
			withdebug=`expr "z$1" : 'z-[^=]*=\(.*\)'` ;;
		1,*)
			usage ;;
		*)
			withdebug="$2"
			shift ;;
		esac
		;;
	--compile)
		compile=true
		;;
	--install)
		install=true
		;;
	--patch*)
		case "$#,$1" in
		*,*=*)
			patch=`expr "z$1" : 'z-[^=]*=\(.*\)'` ;;
		1,*)
			usage ;;
		*)
			patch="$2"
			shift ;;
		esac
		patches="$patches $patch"
		;;
	--driver|--lib|--utils|--plugins|--firmware|--oss)
		pkg="$1"
		pkg=${pkg:2}
		package="alsa-$pkg"
		packagedefault=
		;;
	--run)
		package="alsa-lib"
		packagedefault=
		shift
		runargs="$@"
		break
		;;
	--tmpdir*)
		case "$#,$1" in
		*,*=*)
			tmpdir=`expr "z$1" : 'z-[^=]*=\(.*\)'` ;;
		1,*)
			usage ;;
		*)
			tmpdir="$2"
			shift ;;
		esac
		tmpdir="$tmpdir/alsa-compile-script"
		;;
	--kmodules*)
		case "$#,$1" in
		*,*=*)
			kernelmodules=`expr "z$1" : 'z-[^=]*=\(.*\)'`
			;;
		1,*)
			kernelmodules="reinstall" ;;
		*)
			kernelmodules="$2"
			shift ;;
		esac
		;;
	--kmodlist)
		kmodlist=true
		;;
	--kmodremove)
		kmodremove=true
		;;
	--kmodclean)
		dir="/lib/modules/`uname -r`/updates/alsa"
		echo "Removing kernel modules in $dir:"
		if test -d $dir; then
			if ! rm -rf $dir; then
				echo >&2 "Cannot remove tree $dir."
				exit 1
			fi
		fi
		echo "  success"
		exit 0
		;;
	--kmodmesg)
		kmodmesg=true
		;;
	--shell)
		shell=true
		;;
	*)
		test -n "$1" && echo "Unknown parameter '$1'"
		break
		;;
	esac
	shift
done
if test -z "$url"; then
	url="$baseurl$package"
	urldefault=true
fi

# Echo "true" or "false", depending on $yes and user response to prompt
# $1 is prompt message
question_bool() {
	if test "$yes" = "yes"; then
		echo "true"
	else
		echo >&2 -n "$1 (Y/ ) "
		read i
		local i=${i:0:1}
		if test "$i" = "Y" -o "$i" = "y"; then
			echo "true"
		else
			echo "false"
		fi
	fi
}	

# Set $distrib and $distribver
check_distribution() {
	distrib=$(lsb_release -ds 2> /dev/null)
	if test -z "$distrib"; then
		if test -f /etc/redhat-release; then
			distrib="Fedora"
			install_package lsb
			distrib=
		fi
		distrib=$(lsb_release -ds 2> /dev/null)
		distrib=$(echo $distrib)
	fi
	local tmp=${distrib:0:25}
	if test "$tmp" == "\"Red Hat Enterprise Linux"; then
		distrib="RHEL"
	else
		distrib=$(echo $distrib | cut -d ' ' -f 1)
	fi
	tmp=${distrib:0:1}
	if test "$tmp" = "\""; then
		distrib=${distrib:1}
	fi
	distribver=$(lsb_release -rs 2> /dev/null)
	if test -z "$distrib"; then
		echo >&2 "Unable to determine Linux distribution."
		exit 1
	fi
	if test -z "$distribver"; then
		echo >&2 "Unable to determine Linux distribution version."
		exit 1
	fi
	echo "Detected Linux distribution '$distrib $distribver'."
}

# Echo "true" if rpm installed, else "false"
# $1 is rpm name
is_rpm_installed() {
	local a=$(rpm -qi $1 | head -1 | cut -d ' ' -f 1)
	if test "$a" = "Name"; then
		echo "true"
	else
		echo "false"
	fi
}

# Echo "true" if deb installed, else "false"
is_deb_installed() {
    dpkg -l $1 2>&1 | grep -Eq '^ii'
       if test "$?" = "0"; then
               echo "true"
       else
               echo "false"
       fi
}

# Install package
# $1 is package name
install_package() {
	pkg="$1"
	case "$distrib" in
	openSUSE)
		test "$pkg" == "alsa-lib-devel" && pkg="alsa-devel"
		;;
	Fedora|RHEL|CentOS|Scientific)
		test "$pkg" == "lsb" && pkg="redhat-lsb"
		;;
	Debian|Ubuntu)
		test "$pkg" == "lsb" && pkg="lsb-release"
		test "$pkg" == "git" && pkg="git-core"
		test "$pkg" == "alsa-lib-devel" && pkg="libasound2-dev"
		test "$pkg" == "gettext-tools" && pkg="gettext-base"
		test "$pkg" == "gettext-devel" && pkg="gettext"
		test "$pkg" == "ncurses-devel" && pkg="ncurses-bin"
		;;
	*)
		echo >&2 "Cannot install $1 for unsupported distribution $distrib."
		exit 1
	esac
	echo "Trying to install package '$pkg':"
	case "$distrib" in
	openSUSE)
		zypper install $pkg
		;;
	Fedora|RHEL|CentOS|Scientific)
		yum install -y $pkg
		;;
	Debian|Ubuntu)
		apt-get install -y $pkg
		;;
	*)
		echo >&2 "Cannot install $pkg for unsupported distribution $distrib."
		exit 1
	esac
	if test $(is_rpm_installed $pkg) = "false" -a "$pkg" = "git"; then
		case "$distrib" in
		RHEL)
			install_package perl-DBI
			rm -f $tmpdir/git.rpm
			ver="1.7.9.6-1.el${distribver:0:1}.rf"
			wget -O $tmpdir/git.rpm http://packages.sw.be/git/perl-Git-$ver.$(uname -m).rpm
			if test -s $tmpdir/git.rpm; then
				rpm -Uvh --nodeps $tmpdir/git.rpm
			fi
			wget -O $tmpdir/git.rpm http://packages.sw.be/git/git-$ver.$(uname -m).rpm
			if test -s $tmpdir/git.rpm; then
				rpm -Uvh $tmpdir/git.rpm
			fi
			rm -f $tmpdir/git.rpm
			;;
		esac
	fi
	if test $(is_rpm_installed $pkg) = "false" ; then
		echo >&2 "Package '$pkg' was not installed."
		exit 1
	fi
	echo "  installed"
}

# Ensure the relevant kernel header sources for $distrib are installed
check_kernel_source() {
	echo "Checking kernel build environment:"
	case "$distrib" in
	openSUSE)
		if test $(is_rpm_installed kernel-source) = "false" ; then
			install_package kernel-source
		fi
		;;
	Fedora|RHEL|CentOS|Scientific)
		if uname --kernel-release | grep -q '\.PAE$'; then
			local kernel_devel=kernel-PAE-devel
		else
			local kernel_devel=kernel-devel
		fi
		if test $(is_rpm_installed $kernel_devel) = "false" ; then
			install_package $kernel_devel
		fi
		;;
	Debian|Ubuntu)
		local kernel_devel="linux-source-$(uname --kernel-release | sed 's/-.*$//')"
		if test $(is_deb_installed $kernel_devel) = "false" ; then
			install_package $kernel_devel
		fi
		;;
	*)
		echo >&2 "Cannot install kernel sources for unsupported distribution $distrib."
		exit 1
		;;
	esac
	echo "  passed"
}

# Cache or restore $protocol and $url and $package in $tmpdir
check_environment() {
	local env="$tmpdir/environment.base"
	if ! test -s $env; then
		if ! test -d $tmpdir ; then
			mkdir -p $tmpdir
			if ! test -d $tmpdir; then
				echo >&2 "Unable to create directory $tmpdir."
				exit 1
			fi
		fi
		echo "Using temporary tree $tmpdir."
		check_distribution
		test -x /bin/depmod && depmodbin=/bin/depmod
		test -x /sbin/depmod && depmodbin=/sbin/depmod
		if test -z "$depmodbin"; then
			echo >&2 "Unable to find depmod utility."
			exit 1
		fi	
		test -x /bin/modinfo && modinfobin=/bin/modinfo
		test -x /sbin/modinfo && modinfobin=/sbin/modinfo
		if test -z "$modinfobin"; then
			echo >&2 "Unable to find modinfo utility."
			exit 1
		fi	
		echo "protocol=$protocol" >> $env
		echo "distrib=\"$distrib\"" >> $env
		echo "distribver=\"$distribver\"" >> $env
		echo "url=\"$url\"" >> $env
		echo "package=\"$package\"" >> $env
		echo "depmodbin=\"$depmodbin\"" >> $env
		echo "modinfobin=\"$modinfobin\"" >> $env
		local b=$(basename $env)
		echo "File $b has been created."
	else
		local b=$(basename $env)
		echo "File $b is cached."
		local opackage="$package"
		local ourl="$url"
		. $env
		if test "$packagedefault" != "true"; then
			package="$opackage"
		fi
		if test "$urldefault" != "true"; then
			url="$ourl"
		fi
	fi
}

# Read/set $httpdownloader from CWD(!) and ensure tools available
check_compilation_environment() {
	local env="environment.compile"
	if ! test -s $env; then
		local a=$(wget --version | head -1 | cut -d ' ' -f 2)
		if test "$a" = "Wget"; then
			httpdownloader="wget"
		else
			local a=$(curl --version | head -1 | cut -d ' ' -f 1 )
			if test "$a" = "curl"; then
				httpdownloader="curl"
			fi
		fi
		if test -z "$httpdownloader"; then
			echo >&2 "Unable to determine HTTP downloader."
			exit 1
		fi
		local a=$(git --version | head -1 | cut -d ' ' -f 1)
		if test "$a" != "git"; then
			install_package git
		else
			echo "Program git found."
		fi
		local a=$(autoconf --version | head -1 | cut -d ' ' -f 1)
		if test "$a" != "autoconf"; then
			install_package autoconf
		else
			echo "Program autoconf found."
		fi
		local a=$(aclocal --version | head -1 | cut -d ' ' -f 1)
		if test "$a" != "aclocal"; then
			install_package automake
		else
			echo "Program aclocal found."
		fi
		local a=$(gcc --version | head -1 | cut -d ' ' -f 1)
		if test "$a" != "gcc" ; then
			install_package gcc
		else
			echo "Program gcc found."
		fi
		local a=$(patch --version | head -1 | cut -d ' ' -f 1)
		if test "$a" != "patch" ; then
			install_package patch
		else
			echo "Program patch found."
		fi
		local a=$(diff --version | head -1 | cut -d ' ' -f 1)
		if test "$a" != "diff" ; then
			install_package diffutils
		else
			echo "Program diff found."
		fi
		local a=$(make --version | head -1 | cut -d ' ' -f 1)
		local b=$(make --version | head -1 | cut -d ' ' -f 2)
		if test "$a" != "make" -a "$b" != "make" -a \
		   "$a" != "Make" -a "$b" != "Make"; then
			install_package make
		else
			echo "Program make found."
		fi
		check_kernel_source
		echo "httpdownloader=$httpdownloader" >> $env
		echo "File $env has been created."
	else
		echo "File $env is cached."
		. ./$env
	fi
	if test -z "$present_tool_git"; then
		if test "$protocol" = "git"; then
			local a=$(git --version | head -1 | cut -d ' ' -f 1)
			if test "$a" != "git"; then
				install_package git
			else
				echo "Program git found."
				echo "present_tool_git=y" >> $env
			fi
		fi
	fi
	if test -z "$present_tool_gettext"; then
		if test "$package" = "alsa-utils"; then
			local a=$(gettext --version | head -1 | cut -d ' ' -f 1)
			if test "$a" != "gettext"; then
				install_package gettext-tools
				local a=$(gettextize --version | head -1 | cut -d ' ' -f 1)
				if test -z "$a"; then
					install_package gettext-devel
				fi 
			else
				local a=$(gettextize --version | head -1 | cut -d ' ' -f 1)
				if test -z "$a"; then
					install_package gettext-devel
				else
					echo "Program gettext found."
					echo "present_tool_gettext=y" >> $env
				fi
			fi
		fi
	fi
	if test -z "$present_tool_xmlto"; then
		if test "$package" = "alsa-utils"; then
			local a=$(xmlto --version | head -1 | cut -d ' ' -f 1)
			if test "$a" != "xmlto"; then
				install_package xmlto
			else
				echo "Program xmlto found."
				echo "present_tool_xmlto=y" >> $env
			fi
		fi
	fi
	if test -z "$present_tool_alsa_lib"; then
		if test "$package" = "alsa-utils"; then
			if ! test -r "/usr/include/alsa/asoundlib.h"; then
				install_package alsa-lib-devel
			else
				echo "Package alsa-lib-devel found."
				echo "present_tool_alsa_lib=y" >> $env
			fi
		fi
	fi
	if test -z "$present_tool_ncurses"; then
		if test "$package" = "alsa-utils"; then
			local a=$(ncurses6-config --version | head -1 | cut -d '.' -f 1)
			local b=$(ncurses5-config --version | head -1 | cut -d '.' -f 1)
			if test "$a" != "5" -a "$a" != "6" -a "$b" != "5" -a "$b" != "6"; then
				install_package ncurses-devel
			else
				echo "Package ncurses-devel found."
				echo "present_tool_ncurses=y" >> $env
			fi
		fi
	fi
}

# Log and execute $@ and check success
do_cmd() {
	echo "> $@"
	$@ || exit 1
}

# Download file with $httpdownloader and check size
# $1 is url
# $2 is destination filename
download_http_file() {
	echo "Downloading '$1':"
	case "$httpdownloader" in
	wget)
		do_cmd wget -q -O $2 $1
		;;
	curl)
		do_cmd curl -s -o $2 $1
		;;
	*)
		echo >&2 "Unknown httpdownloader '$httpdownloader'."
		exit 1
		;;
	esac
	local size=$(stat -c%s $2)
	if test -z "$size" -o $size -le 0; then
		echo "  failed ($size)"
		echo >&2 "Unable to download file '$1'."
		exit 1
	else
		echo "  success ($size bytes)"
	fi
}

# Create git clone
# $1 is git url prefix
# $2 is project name and destination dirname
# $3 is the branch name
git_clone() {
	local branch="master"
	test -n "$3" && local branch="$3"
	test -z "$3" -a "$2" = "alsa-driver" && local branch="release"
	do_cmd git clone -b "$branch" "$1$2.git" "$2"
}

# Compile $package, applying $patches
do_compile() {
	local cmd="./gitcompile"
	case "$package" in
	alsa-driver)
		local dbgopt="$withdebug"
		test -z "$dbgopt" && local dbgopt="full"
		if ! test -f Rules.make && ! cd "alsa"; then
			echo >&2 "The alsa directory does not exist."
			echo >&2 "Compilation of $package failed."
			echo >&2 "Report this problem to the <alsa-devel@alsa-project.org> mailing list."
			exit 1
		fi
		local cmd="./gitcompile --with-debug=$dbgopt --with-isapnp=yes --with-sequencer=yes --with-moddir=updates/alsa"
		if test -n "$kernel"; then
			local cmd="$cmd --with-kernel=\"$kernel\""
		fi
		;;
	esac
	if test -z "$patches"; then
		case "$package" in
		alsa-driver)
			test -r acore/hwdep.o && local cmd="make"
			;;
		alsa-lib)
			test -r src/.libs/libasound.so.2.0.0 && local cmd="make"
			;;
		esac
	else
		for patch in $patches; do
			local pstrip=1
			if ! patch -s -p$pstrip -N --dry-run < $patch; then
				local pstrip=0
				if ! patch -s -p$pstrip -N --dry-run < $patch; then
					echo >&2 "Cannot apply patch $patch."
					exit 1
				fi
			fi
			echo "Applying patch $patch: "
			if ! patch -p$pstrip -N < $patch; then
				exit 1
			fi
		done
	fi
	echo "Running $cmd:"
	if ! $cmd; then
		local a=$(pwd)
		echo >&2 "Working directory $a."
		echo >&2 "Compilation of $package failed."
		echo >&2 "Report this problem to the <alsa-devel@alsa-project.org> mailing list."
		exit 1
	fi
	if ! test -f Rules.make && test "$package" = "alsa-driver"; then
		cd ..
	fi
}

# Install $package as root
do_install() {
	if ! test "$UID" -eq 0 ; then
		echo >&2 "Root priviledges required for installation."
		echo >&2 "Login as root to continue."
		exit 1
	fi
	local cmd="make install"
	case "$package" in
	alsa-driver)
		cat <<EOF
WARNING! You chose to install new ALSA kernel modules. To reuse the ALSA
kernel modules provided by the kernel package, invoke command:
  $0 --kmodclean
EOF
		if test $(question_bool "Really continue (Ctrl-C to abort)?") = "true"; then
			local cmd="make install-modules"
		fi
		;;
	esac
	do_cmd $cmd
}

# Kill processes currently accessing the audio devices
kill_audio_apps() {
	local pids0=$($fuser_prg /dev/snd/* 2> /dev/null)
	local pids1=$($fuser_prg /dev/mixer* 2> /dev/null)
	local pids2=$($fuser_prg /dev/sequencer* 2> /dev/null)
	local pids=
	for pid in $pids0 $pids1 $pids2; do
		local pids="$pids $pid"
	done
	if ! test -z "$pids"; then
		echo
		echo "WARNING! An audio application uses ALSA driver:"
		echo
		for pid in $pids; do
			ps --no-headers -p $pids || exit 1
		done
		echo
		if test $(question_bool "Would you like to kill these apps?") = "true"; then
			for pid in $pids; do
				do_cmd kill $pid
			done
			sleep 2
			local killed=
			for pid in $pids; do
				local a=$(ps --no-headers -p $pids)
				if test -n "$a"; then
					do_cmd kill -9 $pid
					local killed="true"
				fi
			done
			if test "$killed" = "true"; then
				sleep 2
				for pid in $pids; do
					local a=$(ps --no-headers -p $pids)
					if test -n "$a"; then
						echo >&2 "Unable to kill application:"
						echo >&2 "  $a"
						exit 1
					fi
				done
			fi
		else
			echo >&2 "Cannot continue with running audio applications."
			exit 1
		fi
	fi
}

# List available modules, cwd==source-tree
parse_modules() {	
	if ! test -s "$tmpdir/modules.dep"; then
		local rel=$(uname -r)
		cd modules
		for i in snd-dummy.*; do
			local i1=$(echo $i | sed -e 's/dummy/dummy1/g')
			ln -sf $i $i1 || exit 1
		done
		cd ..
		local pdst="xxxx/lib/modules/$rel"
		mkdir -p $pdst/modules || exit 1
		for i in modules/*.*o; do
			ln -sf ../../../../../$i $pdst/$i || exit 1
		done
		local p=$(pwd)
		if ! $depmodbin -b $p/xxxx ; then
			echo >&2 "depmod failed."
			exit 1
		fi
		
		if ! cp $pdst/modules.dep "$tmpdir/modules.dep" ; then
			echo >&2 "cp problem."
			exit 1
		fi
		rm -rf xxxx || exit 1
		echo "File modules.dep has been created."
	else
		echo "File modules.dep is cached."
	fi

	if ! test -s "$tmpdir/modules.top" ; then
		for i in modules/*.*o; do
			if test -r $i; then
				local a=$($modinfobin $i | grep "parm:" | grep "enable:")
				if ! test -z "$a"; then
					local a=$(basename $i | cut -d . -f 1)
					echo $a >> "$tmpdir/modules.top"
				fi
			else
				echo >&2 "permissions $tmpdir/$i problem."
				exit 1
			fi
		done
		echo "File modules.top has been created."
	else
		echo "File modules.top is cached."
	fi
}

# Echo the list of loaded sound modules
current_modules() {
	$lsmod_prg | cut -d ' ' -f 1 | grep -E "^(snd[_-]|snd$|ac97_bus$|thinkpad_acpi$)"
}

# Remove kernel modules, using two phases
# $@ is module names
my_rmmod() {
	local phase2=
	while test -n "$1"; do
		if ! $rmmod_prg $1 2> /dev/null > /dev/null; then
			local phase2="$phase2 $1"
		else
			echo "> rmmod $1"
		fi
		shift
	done
	for mod in $phase2; do
		echo "> rmmod $mod"
		if ! $rmmod_prg $mod ; then
			echo >&2 "Unable to remove kernel module $mod."
			exit 1
		fi
	done
}

# Insert kernel modules with arguments
my_insmod() {
	while test -n "$1"; do
		local xmod=
		local args=
		local nofail=
		for x in $1; do
			if test -z "$xmod"; then
				local xmod=$x
			else
				local args="$args $x"
			fi
		done
		if test "$xmod" = "snd-dummy1"; then
			args="index=999"
			nofail=true
		fi
		local xmod1=$(echo $xmod | cut -d ':' -f 1)
		if test "$xmod1" != "$xmod"; then
			local args1=$(echo $xmod | cut -d ':' -f 2-)
			args="$args $args1"
			xmod="$xmod1"
		fi
		if test -r modules/$xmod.ko; then
			local mod=modules/$xmod.ko
			echo "> insmod $mod $args"
			if test -n "$nofail"; then
				$insmod_prg $mod $args 2> /dev/null
			elif ! $insmod_prg $mod $args; then
				echo >&2 "Unable to insert kernel module $xmod.ko."
				exit 1
			fi
		else
			if test -r modules/$xmod.o; then
				local mod=modules/$xmod.o
				echo "> insmod $mod $args"
				if test -n "$nofail"; then
					$insmod_prg $mod.o $args
				elif ! $insmod_prg $mod.o $args; then
					echo >&2 "Unable to insert kernel module $xmod.o."
					exit 1
				fi
			else
				echo >&2 "Unable to find kernel module $xmod."
				exit 1
			fi
		fi
		shift
	done
}

# List latest kernel messages
# $1 is prefix
show_kernel_messages() {
	cat > $tmpdir/run.awk <<EOF
/Dummy soundcard not found or device busy/ { delete lines }
	{ lines[length(lines)+1] = \$0 }
BEGIN	{ lines[0] = "hack" }
END	{
		for (x = 2; x <= length(lines); x++)
			print prefix lines[x]
	}
EOF
	dmesg | awk -f $tmpdir/run.awk -v prefix="$1"
	rm $tmpdir/run.awk || exit 1
}

# Reload kernel modules
# $@ is list of kernel modules, default is current modules
do_kernel_modules() {
	local usermods="$@"
	local curmods=$(current_modules)
	local dst=
	if test -z "$curmods" -a -z "$usermods"; then
		echo >&2 "Unable to determine current ALSA kernel modules."
		exit 1
	fi
	if test -n "$usermods"; then
		dst="$tmpdir/modules.user"
		rm -f $dst || exit 1
	else
		dst="$tmpdir/modules.insmod"
	fi
	parse_modules
	if ! test -s $dst; then
		local topmods=$(cat "$tmpdir/modules.top")
		cat > "$tmpdir/run.awk" <<EOF
function basename(name) {
	split(name, y, "[/.]")
	return y[length(y)-1]
}
function skipempty(dst, src, delim,    x, y) {
	split(src, y, delim)
	for (x in y) {
		if (length(y[x]) > 0) {
			dst[x] = y[x]
		}
	}
}
function skipemptyuser(dst, src, delim,   x, y, z, m) {
	split(src, y, delim)
	for (x in y) {
		if (length(y[x]) > 0) {
			z = index(y[x], ":")
			if (z > 1) {
				m = substr(y[x], 0, z - 1)
				modargs[m] = substr(y[x], z)
			} else {
				m = y[x]
			}
			if (substr(m, 0, 4) != "snd-")
				m = "snd-" m
			dst[x] = m
		}
	}
}
function moduleindex(mod,   x) {
	for (x in modules) {
		if (modules[x] == mod)
			return x
	}
	return 0;
}
function addmodule(mod,    v, j, k) {
	if (moduleindex(mod) > 0)
		return
	v = split(deps[mod], j, " ")
	for (k = 1; k <= v; k++)
		addmodule(j[k])
	modules[length(modules)+1] = mod
}
function addslavemodules(mod, exclude,   m, v, j, k)
{
	for (m in deps) {
		v = split(deps[m], j, " ")
		for (k = 1; k <= v; k++) {
			if (j[k] == mod && m != exclude) {
				addmodule(m)
			}
		}
	}
}
function addtopmodule(mod,   v, j, k, z)
{
	v = split(deps[mod], j, " ")
	for (k = 1; k <= v; k++) {
		for (z = 1; z <= length(alldeps); z++) {
			if (j[k] == alldeps[z])
				addslavemodules(j[k], mod)
		}
	}
	addmodule(mod)
	addslavemodules(mod)
}
BEGIN   {
		if (length(usermods) > 0)
			skipemptyuser(acurmods, usermods, " ")
		else
			skipempty(acurmods, curmods, " ")
		skipempty(atopmods, topmods, " ")
		for (b in atopmods)
			alldeps[b] = atopmods[b]
		# hack to load HDA codec modules
		alldeps[length(alldeps)+1] = "snd-hda-codec"
	}
	{
		split(\$0, a, "[: ]")
		first = 1
		for (b = 1; b <= length(a); b++) {
			if (length(a[b]) <= 0)
				continue
			base = basename(a[b])
			if (first) {
				mod = base
				deps[mod] = ""
				first = 0
			} else {
				if (length(deps[mod]) > 0)
					deps[mod] = deps[mod] " " base
				else
					deps[mod] = base
			}
		}
		delete a

	}
END     {
		addmodule("snd-page-alloc")
		addmodule("snd-dummy1")

		# all direct toplevel modules dependencies
		for (mod in deps) {
			split(deps[mod], mods, " ")
			for (d in atopmods) {
				if (mod != atopmods[d])
					continue
				for (b in acurmods) {
					mod1 = acurmods[b]
					v = gsub("_", "-", mod1)
					if (mod != acurmods[b] && mod != mod1)
						continue
					addtopmodule(mod)
					break
				}
			}
		}

		addmodule("snd-seq")
		addmodule("snd-mixer-oss")
		for (b in modules) {
			if ("snd-pcm" == modules[b])
				addmodule("snd-pcm-oss")
		}

		for (b = 1; b <= length(modules); b++) {
			mod = modules[b]
			if (length(mod) > 0) {
				arg = ""
				for (d in modargs) {
					if (d == mod)
						arg = modargs[d]
				}
				print mod arg
			}
		}
	}
EOF
		awk -f "$tmpdir/run.awk" \
		       -v curmods="$curmods" \
		       -v usermods="$usermods" \
		       -v topmods="$topmods" \
				"$tmpdir/modules.dep" > $dst || exit 1
		rm "$tmpdir/run.awk" || exit 1
		if ! test -s $dst; then
			if test -n "$usermods"; then
				echo >&2 "Unable to determine specified ALSA kernel modules."
			else
				echo >&2 "Unable to determine current ALSA kernel modules."
			fi
			exit 1
		fi
		if test -z "$usermods"; then
			echo "File modules.insmod has been created."
		fi
	else
		if test -z "$usermods"; then
			echo "File modules.insmod is cached."
		fi
	fi
	kill_audio_apps
	my_rmmod $curmods
	dmesg > ../dmesg.txt.1
	$modprobe_prg soundcore
	my_insmod $(cat $dst)
	echo "Kernel modules ready:"
	cat /proc/asound/cards
	if ! alsactl init 2> /dev/null > /dev/null ; then
		echo "Mixer initialized using 'alsactl init' command."
	else
		echo "Use a mixer application (like alsamixer) to set reasonable volume levels."
	fi
	dmesg > ../dmesg.txt.2
	show_kernel_messages " [kmsg] "
}

# If $package is alsa-driver then reinstall $kernelmodules
kernel_modules() {
	if test "$package" != "alsa-driver"; then
		echo >&2 "--kernel-modules works only for alsa-driver package."
		exit 1
	fi
	if test "$kernelmodules" = "reinstall"; then
		do_kernel_modules
	else
		local a=$(echo $kernelmodules | sed -e 's/,/ /g')
		do_kernel_modules $a
	fi
}

# If $package is alsa-driver then list available modules
kernel_modules_list() {
	if test "$package" != "alsa-driver"; then
		echo >&2 "--kmodlist works only for alsa-driver package."
		exit 1
	fi
	parse_modules
	local topmods=$(cat "$tmpdir/modules.top")
	for mod in $topmods; do
		local desc=$($modinfobin -F description modules/$mod.*o)
		echo "$mod: $desc"
	done
}

# If $package is alsa-driver then remove current modules
kernel_modules_remove() {
	if test "$package" != "alsa-driver"; then
		echo >&2 "--kmodremove works only for alsa-driver package."
		exit 1
	fi
	local curmods=$(current_modules)
	if test -z "$curmods"; then
		echo "No ALSA kernel modules to remove."
		exit 0
	fi
	kill_audio_apps
	my_rmmod $curmods
	echo "ALSA kernel modules removed."
}

package_switch() {
	packagedir="$tmpdir/$package.dir"
	packagestatus="$tmpdir/$package.status"
	tree=
	status=
	if test -r $packagedir; then
		tree=$(cat $packagedir)
	fi
	if test -r $packagestatus; then
		status=$(cat $packagestatus)
	fi
}

do_shell() {
	do_cmd cd $tree
	export PS1="alsa-compile [\u@\h \W]\$ "
	echo >&2
	echo >&2 "*** Type 'Ctrl-D' or 'exit' to exit the debug shell ***"
	echo >&2
	do_cmd pwd
	do_cmd /bin/bash
}

rundir=$(pwd)
export LC_ALL=C
export LANGUAGE=C

if test "$kmodmesg" = "true"; then
	show_kernel_messages
	exit 0
fi

if test -n "$clean"; then
	if test "$clean" = "full"; then
		echo -n "Removing tree $tmpdir:"
		if test -d "$tmpdir"; then
			if ! rm -rf "$tmpdir"; then
				echo " failed"
				exit 1
			fi
		fi
		echo " success"
	else
		package_switch $clean
		package="$clean"
		echo -n "Removing package $package:"
		rm "$tmpdir/environment.*" 2> /dev/null
		if test "$package" = "alsa-driver"; then
			rm -rf "$tmpdir/modules.*"
			rm -rf "$tmpdir/run.awk"
		fi
		if test -n "$tree"; then
			if test -d "$tmpdir/$tree"; then
				if ! rm -rf "$tmpdir/$tree"; then
					echo " failed"
					exit 1
				fi
			fi
			rm -f "$packagedir"
			echo " success"
		elif test -d $package; then
			rm -rf $package
			echo " success"
		else
			echo " success"
		fi
	fi
	exit 0
fi

protocol=$(echo $url | cut -d ':' -f 1)
check_environment
do_cmd cd $tmpdir
package_switch $package

if test "$kmodremove" = "true"; then
	kernel_modules_remove
	exit 0
fi

if test "$kmodlist" = "true" -a -z "$compile" -a -n "$tree" -a -n "$status"; then
	do_cmd cd $tree
	kernel_modules_list
	exit 0
fi

if test -n "$kernelmodules" -a -z "$compile" -a -n "$tree" -a -n "$status"; then
	do_cmd cd $tree
	kernel_modules
	exit 0
fi

if test -n "$shell" -a -z "$compile" -a -n "$tree" -a -n "$status"; then
	do_shell
	exit 0
fi

case "$protocol" in
http|https|ftp|file)
	check_compilation_environment
	if test -n "$tree"; then
		echo "$package tree $tree is present."
		echo "Reusing it."
		echo "Use '$0 --clean=$package' command to refetch and rebuild."
	else
		snapshot="snapshot.tar.bz2"
		if test "$protocol" = "file"; then
			tree=$(echo $url | cut -d ':' -f 2)
			if test "${tree:0:1}" = "/"; then
				tree=${tree:1}
			fi
			if test "${tree:0:1}" = "/"; then
				tree=${tree:1}
			fi
			if test "${tree:0:1}" != "/"; then
				tree="$rundir/$tree"
			fi
			if test -r "$tree/gitcompile"; then
				tree="$tree"
			elif test -r "$tree/alsa/gitcompile"; then
				tree="$tree/alsa"
			elif test -r "$tree/../gitcompile"; then
				tree="$tree/.."
			elif test -r "$tree/../$package/gitcompile"; then
				tree="$tree/../$package"
			fi
			if test -d "$tree"; then
				tree=$(cd "$tree" && pwd)
			else
				echo >&2 "Fatal: $package tree '$tree' not found."
				exit 1
			fi
		else
			download_http_file $url $snapshot
			do_cmd tar xjf $snapshot
			rm $snapshot
			tree=$(ls | grep $package)
		fi
	fi
	if ! test -x $tree/gitcompile ; then
		echo >&2 "Fatal: $package tree '$tree' not found."
		exit 1
	fi
	echo "Sources unpacked to $tree"
	echo $tree > $packagedir
	do_cmd cd $tree
	do_compile
	status="compile"
	echo $status > $packagestatus
	if test "$install" = "true"; then
		do_install
	else
		echo "ALSA package $package was successfully built."
		echo "Binaries are in $tmpdir/$tree directory."
	fi
	cd ..
	;;
git)
	check_compilation_environment
	if test -n "$tree" ; then
		echo "$package tree $package is present."
		echo "Reusing it."
		echo "Use '$0 --clean=$package' command to refetch and rebuild."
	else
		git_clone $url $package $branch
		echo "$package" > $packagedir
	fi
	do_cmd cd $package
	do_compile
	status="compile"
	echo $status > $packagestatus
	if test "$install" = "true"; then
		do_install
	else
		echo "ALSA package $package was successfully built."
		echo "Binaries are in $tmpdir/$package directory."
	fi
	cd ..
	;;
*)
	echo >&2 "Unknown protocol '$protocol'."
	exit 1
esac

if test "$kmodlist" = "true"; then
	if test -z "$tree" -o -z "$status"; then
		echo >&2 "Package $package is not compiled."
		echo >&2 "Cannot list kernel modules."
		exit 1
	fi
	do_cmd cd $tree
	kernel_modules_list
	exit 0
fi

if test -n "$kernelmodules"; then
	if test -z "$tree" -o -z "$status"; then
		echo >&2 "Package $package is not compiled."
		echo >&2 "Cannot insert kernel modules."
		exit 1
	fi
	do_cmd cd $tree
	kernel_modules
	exit 0
fi

if test -n "$runargs"; then
	if test "$package" != "alsa-lib"; then
		libtree=
		libstatus=
		if test -r "$tmpdir/alsa-lib.dir"; then
			libtree=$(cat $tmpdir/alsa-lib.dir)
		fi
		if test -r "$tmpdir/alsa-lib.status"; then
			libstatus=$(cat $tmpdir/alsa-lib.status)
		fi
	else
		libtree=$tree
		libstatus=$status
	fi
	if test -z "$libtree" -o -z "$libstatus"; then
		echo >&2 "Package $package is not compiled."
		echo >&2 "Cannot use alsa-lib."
		exit 1
	fi
	f="$tmpdir/$libtree/src/.libs/libasound.so.2.0.0"
	if test -r $f; then
		do_cmd "export LD_PRELOAD=$f"
		do_cmd "export ALSA_CONFIG_PATH=\"$tmpdir/$libtree/src/conf/alsa.conf\""
		do_cmd $runargs
	else
		echo >&2 "Unable to find alsa-lib.so."
		exit 1
	fi
fi

if test -n "$shell"; then
	do_shell
fi

exit 0