Bash Medley Grid Video Player Improved

#!/bin/bash -

# vim: set tabstop=8 softtabstop=4 shiftwidth=4 smarttab noexpandtab:

${DEBUG}

#========================================================================
#          FILE:  medley
#
#         USAGE:  medley [-h|--help][-V|--version]|-a ASPECT -w WIDTH
#            -n NUMBER -f -s FILENAME [FILENAME...]
#         --help    display program help and exit
#
#         -a ASPECT aspect ratio of videos. Valid values for
#                   ASPECT are cinema|hdtv|widescreen|standard.
#                   Default is standard.
#         -w WIDTH  width of video viewport. Cannot be used with
#                   -f.
#         -n NUMBER number of viewports in a row. Valid values
#                   for NUMBER are 1-3. Default is 4.
#         -f        turn off fullscreen view when playing a list
#                   of videos sequentially. Cannot be used with
#                   -w.
#         -s        do not shuffle FILENAMEs.
#         -u
#         --usage   display a usage message and exit
#
#         -V
#         --version display the program version number and exit
#         -x        display debugging information
#
#   DESCRIPTION:  play a medley of videos simultaneously
#
#       OPTIONS:  --help, --version
#  REQUIREMENTS:  ---
#          BUGS:  ---
#         NOTES:  ---
#        AUTHOR:  Scott Bicknell (SB), [email protected]
#       COMPANY:
#       VERSION:  1.0
#       CREATED:
#      REVISION:  ---
#
# Copyright 2010 Scott Bicknell, sbicknel (at) gmail dot com
#
# 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/>.
#========================================================================


PROGNAME=${0##*/}
VERSION='2.0'
PATH="${HOME}/bin:/bin:/usr/bin:/usr/local/bin"
umask 077

# -----------------------------------------------------------------------
# Display error messages on standard error.
# -----------------------------------------------------------------------
function error () {
    printf '%s: %s\n' $PROGNAME "$@"
} >&2


# -----------------------------------------------------------------------
# Display warning messages on standard output.
# -----------------------------------------------------------------------
warning () {
    printf '%s: %s\n' $PROGNAME "$@"
}

# -----------------------------------------------------------------------
# Display messages on standard output.
# -----------------------------------------------------------------------
function message () {
    printf '%s: %s\n' $PROGNAME "$@"
}


# -----------------------------------------------------------------------
# Function for exit due to fatal program error
#   Accepts 1 argument:
#       string containing descriptive error message
# -----------------------------------------------------------------------
function error_exit () {
    error "${1:-'Unknown Error'}"
    exit 1
}


# -----------------------------------------------------------------------
# Function to handle termination signals
#   Accepts 1 argument:
#       signal_spec
# -----------------------------------------------------------------------
function signal_exit () {
    case $1 in

    INT)
        error_exit 'Program aborted by user'
    ;;

    TERM)
        error_exit 'Program terminated'
    ;;

    *)
        error_exit 'Terminating on unknown signal'
    ;;

    esac
}

trap 'signal_exit TERM' TERM HUP QUIT PIPE
trap 'signal_exit INT'  INT


# -----------------------------------------------------------------------
# Function called for a graceful exit
#   No arguments
# -----------------------------------------------------------------------
function graceful_exit () {
    exit
}


# -----------------------------------------------------------------------
# Simulate user activity to inhibit the screensaver
# -----------------------------------------------------------------------
function inhibit_screensaver () {
    qdbus org.freedesktop.ScreenSaver /ScreenSaver SimulateUserActivity
} &>/dev/null


# -----------------------------------------------------------------------
# Set player variable
# -----------------------------------------------------------------------
set_player () {
    if [[ -n "$player" ]]; then
    return 0
    fi
    if ! type -P mplayer2 &>/dev/null && ! type -P mplayer &>/dev/null; then
    error_exit 'mplayer or mplayer2 is required'
    fi
    if type -P mplayer2 &>/dev/null; then
    player=mplayer2
    elif type -P mplayer &>/dev/null; then
    player=mplayer
    fi
}


# -----------------------------------------------------------------------
# Display a short message about program usage. This is also used by the
# helptext function to display part of its help text.
# -----------------------------------------------------------------------
function usage () {
    cat <<- EOF

USAGE: $PROGNAME: [-a standard|cinema|hdtv|widescreen][-f][-s][-n NUM|-w NUM]|[-h|--help]
                  [-u|--usage][-V|--version]|[-x] FILE [FILE...]
EOF
}


# -----------------------------------------------------------------------
# Display the program version number
# -----------------------------------------------------------------------
function version () {
    printf '%s %s\n' $PROGNAME $VERSION
}


# -----------------------------------------------------------------------
# Function to display help message for program
#   No arguments
# -----------------------------------------------------------------------
function helptext () {
    local tab=$(printf '\t\t')

    usage
    cat << -EOF-


DESCRIPTION:

Play a medley of videos simultaneously. By default, each video is scaled to fit
in a row four viewports wide. The script fills the display with as many windows
as it can and tiles them in a grid. As each video finishes playing another
video fills the same location in the on-screen grid. The videos are played in
random order by default if shuf is installed.


Options:

-a ASPECT   Aspect ratio. This option affects vertical spacing of viewports
                in the on-screen grid. Valid names are standard, cinema, hdtv,
        and widescreen. Default is 'standard'.
        Name       | Meaning
        --------------------
        standard   |     4:3
        cinema     |    16:9
        hdtv       |  1.85:1
        widescreen |  2.35:1
-f      Turn off fullscreen mode when playing videos one at a time.
        Disables -w. Must be used with -n 1.
-s      Do not shuffle play list.  Ignored if shuf not installed

-h, --help  Display this help message and exit.
-u, --usage Display a usage message and exit.
-V, --version   Display program version and exit.

-w PIXELS       Width of a video viewport. This option affects how many
                videos are placed in a row and may affect how may rows
        are placed in the grid. Default creates a row of four
        videos and sizes the viewports to fit the width of the
        display. Cannot be used with -n.
-n NUMBER   Number of windows in a row. Cannot be used with -w. Valid
        values are 1 to 3. If NUMBER is 1, -f may be used.
-x      Display debugging output when running the program

This program requires mplayer or mplayer2.  Unsort is optional.


-EOF-
    version
}

# -----------------------------------------------------------------------
# Verify that the usage function and the helptext function both have
# documentation for each long option. Verify that the header comment
# also has each long option listed.
# -----------------------------------------------------------------------
if [[ "$1" == '--help' ]]; then
    helptext
    graceful_exit
fi
if [[ "$1" == '--version' ]]; then
    version
    graceful_exit
fi
if [[ "$1" == '--usage' ]]; then
    usage
    graceful_exit
fi

# information about the current desktop from wmctrl
if wmctrl -d &>/dev/null; then
    desktopInfo=$(wmctrl -d | grep '^[0-9]* *\*')   # target the current desktop
    dimensions=$(awk '{print $4}' <<< $desktopInfo) # display dimensions
    waDimensions=$(awk '{print $9}' <<< $desktopInfo)   # work area dimensions
    waWidth=${waDimensions%x*}              # width of work area in pixels
    waHeight=${waDimensions#*x}             # height of work area in pixels
    waOrigin=$(awk '{print $8}' <<< $desktopInfo)   # X,Y origin of work area

# information about the current display if wmctrl fails
else
    dimensions=$(xdpyinfo | awk '/dimensions/ {print $2}')  # display dimensions
    waDimensions=$dimensions                    # work area dimensions
    waWidth=$(( ${waDimensions%x*} - 50 ))          # width of work area in pixels
    waHeight=$(( ${waDimensions#*x} - 50 ))         # height of work area in pixels
    waOrigin='0,0'

fi
dwidth=${dimensions%x*}     # width of display in pixels
dheight=${dimensions#*x}    # height of display in pixels
waX=${waOrigin%,*}      # X origin of work area
waY=${waOrigin#*,}      # Y origin of work area
unset dimensions
unset waDimensions
unset waOrigin

# default width of a video window
maxGridHeight=$waHeight
defaultWidth=$(echo "scale=2; $maxGridHeight / 3 * 4 / 3 " | bc | sed 's/...$//')

# mplayer/mplayer2 calling syntax differences
declare -A id
declare -A fd
declare -A asp
id[mplayer]='-identify '
fd[mplayer]='-framedrop'
asp[mplayer]='-aspect '
id[mplayer2]='--identify='
fd[mplayer2]='--framedrop'
asp[mplayer2]='--aspect='

# ratios
st='4:3'    # standard
ci='16:9'   # cinema
hd='1.85:1' # hdtv
wi='64:27'  # widescreen

# -----------------------------------------------------------------------
# Verify that the usage function and the helptext function both have
# documentation for each short option. Verify that the header comment
# also has each short option listed in the usage section.
# -----------------------------------------------------------------------
while getopts :a:fhn:suVw:x opt; do
    case $opt in

    a) # aspect ratio
        set_player
        aspect=${asp[$player]}
        case ${OPTARG,,} in

        standard)
            aspect=${aspect}$st
            aspRatio=${OPTARG,,}
            ;;

        cinema)
            aspect=${aspect}$ci
            aspRatio=${OPTARG,,}
            ;;

        hdtv)
            aspect=${aspect}$hd
            aspRatio=${OPTARG,,}
            ;;

        widescreen)
            aspect=${aspect}$wi
            aspRatio=${OPTARG,,}
            ;;

        *)
            message "$OPTARG: unsupported aspect ratio. Setting aspect ratio to standard"
            aspect=${aspect}$st
            aspRatio=standard
            ;;

        esac
        ;;

    h) # help
        helptext
        graceful_exit
        ;;

    f) # turn off fullscreen when playing videos one at a time
        full=no
        width=$(( $waWidth / 2 + 1 ))
        ;;

    n) # number of windows in a grid row
        case ${OPTARG} in

        *[!0-9]*)
            message "$OPTARG: must be a number of windows. Setting number of windows to default"
            width=$defaultWidth
            ;;

        [1-3])
            width=$(( $waWidth / $(( $OPTARG + 1 )) + 1 ))
            ;;

        *)
            message "$OPTARG: must be a number from 1 to 3. Setting number of windows to default"
            width=$defaultWidth
            ;;
        esac
        ;;

    s) # do not shuffle videos
        unsort=no
        ;;

    u) # usage
        usage
        graceful_exit
        ;;

    V) # version
        version
        graceful_exit
        ;;

    w) # width of a video window

        case $OPTARG in

        *[!0-9]*)
            message "$OPTARG: video width must be a number. Setting width to $defaultWidth"
            width=$defaultWidth
            ;;

        esac
        width=${width:-$OPTARG}
        if [[ $width -gt $waWidth ]]; then
        message "-w: width cannot exceed $dwidth. Setting width to $defaultWidth"
        width=$defaultWidth
        fi
        ;;

    x)  # set debugging output on a per-run basis. The $DEBUG
        # environment variable will enable degugging output at
        # the top of the script.
        set -x
        ;;

    :)  # process missing required parameters
        case $OPTARG in
        a) error_exit "-$OPTARG: required argument missing: standard, cinema, hdtv, or widescreen expected";;
        n) error_exit "-$OPTARG: required argument missing: 1, 2 or 3 expected";;
        w) error_exit "-$OPTARG: required argument missing: pixel width of a single video expected (e.g. 300)";;
        *) error_exit "-$OPTARG: required argument missing";;
        esac
        ;;

    *)  # process unknown options
        usage
        error_exit "Unknown option: -$OPTARG"
        ;;

    esac
done
shift $(( $OPTIND - 1 ))

if [[ $# -eq 0 ]]; then
    error_exit 'nothing to play'
fi
set_player
killall $player &>/dev/null

# if aspect is not set, try to determine aspect ratio from folder name
if [[ -z "$aspect" ]]; then
    case ${PWD##*/} in
    standard|cinema|hdtv|widescreen)
        aspRatio=${PWD##*/}
        aspect=${asp[$player]}
        case $aspRatio in

        standard)
            aspect=${aspect}$st
            ;;

        cinema)
            aspect=${aspect}$ci
            ;;

        hdtv)
            aspect=${aspect}$hd
            ;;

        widescreen)
            aspect=${aspect}$wi
            ;;

        esac
        ;;
    esac
fi

width=${width:-$defaultWidth}                   # width of a video window
case $width in

    *[!0-9]*)
    message "$OPTARG: video width must be a number. Setting width to $defaultWidth pixels."
    width=$defaultWidth
    ;;
esac

# height of a video window
aspRatio=${aspRatio:-standard}
aspRatio=${aspRatio,,}
case $aspRatio in
     standard) height=$(echo "scale=2; $width /  4 *  3"  | bc | sed 's/...$//');;
       cinema) height=$(echo "scale=2; $width / 16 *  9"  | bc | sed 's/...$//');;
         hdtv) height=$(echo "scale=2; $width /    1.85"  | bc | sed 's/...$//');;
   widescreen) height=$(echo "scale=2; $width / 64 * 27"  | bc | sed 's/...$//');;
            *)
        message 'unsupported aspect ratio. Using standard aspect ratio to set height'
        height=$(echo "scale=2; $width / 4 *  3"  | bc | sed 's/...$//')
        ;;
esac
unset aspRatio
maxxp=$(( $waX + $waWidth - $width ))   # maximum horizontal window position

# window dimensions of the entire grid
maxWWide=$(( $waWidth / $width ))   # maximum windows wide
maxWHigh=$(( $waHeight  / $height ))    # maximum windows high
numWindows=$(( $maxWWide * $maxWHigh )) # number of windows in a grid

# pixel dimensions of the entire grid
gridWidth=$(( $maxWWide * $width ))
gridHeight=$(( $maxWHigh * $height ))
unset maxWWide
unset maxWHigh

# screen coordinates of first video window
xstart=$(( $waX + ( ( $waWidth  - $gridWidth  ) / 2 ) ))    # initial horizontal window position
ystart=$(( $waY + ( ( $waHeight - $gridHeight ) / 2 ) ))    # initial vertical window position
x=$xstart                           # horizontal window position
y=$ystart                           # vertical window position
unset dwidth
unset waWidth
unset dheight
unset waHeight
unset ystart
unset waX
unset waY

# make a list of all window positions
for (( w=1; w<=$numWindows; w++ )); do
    window[$w]="$x:$y"
    x=$(( $x + $width ))
    if [[ $x -gt $maxxp ]]; then
    x=$xstart
    y=$(( $y + $height ))
    fi
done
unset height
unset maxxp
unset xstart
unset x
unset y

# set fullscreen mode if only one window position in list
declare -A fs
if [[ ${#window[@]} -eq 1 ]] && [[ ${full:-yes} == yes ]]; then
    fs[mplayer2]='--fs'
    fs[mplayer]='-fs'
fi

unset COLUMNS   # This setting prevents some data from reaching grep

v=0 # video list index

# create an indexed list of video files, skipping files not recognized as videos
# explicite index assignment is necessary to prevent word splitting on spaces
for f in "$@"; do
    if ! [[ -f "$f" ]] ||
    ! [[ $(file --mime-type -b "$f" | awk -F/ '{print $1}') == 'video' ]] &&
    ! [[ $(file --mime-type -b "$f" | awk -F/ '{print $2}') == 'ogg'   ]]; then
    warning "Video file not recognized. $f: $(file --mime-type -b \"$f\")"

    # ensures that the number of parameters equals the number of valid video files
    # we can throw away parameters because we are storing valid ones in flist
    shift
    continue
    fi
    flist[$v]="$f"
    (( v++ ))
done

# create a list of video files in input order if shuf is not installed
if ! type -P shuf &>/dev/null || [[ ${unsort:-yes} == no ]]; then
    rlist=( "${flist[@]}" )

# create a random list of video files otherwise
else
    v=0

    # create a random list of indexes ($rn) for each video file in $flist
    # $rn is our random list of indexes into $flist
    rn=( $(for (( r=0; r<${#flist[@]}; r++ )); do
    echo $r
    done | sed 's/ /\n/g' | shuf 2>/dev/null) )

    # this random list is used to store video file names from random
    # index locations in $flist to sequential locations in $rlist
    for r in ${rn[@]}; do
    rlist[$v]="${flist[$r]}"
    (( v++ ))
    done
fi
unset v
unset flist

if [[ ${#rlist[@]} -eq 0 ]]; then
    message 'video detection failed. Try: file --mime-type -b FILE'
    error_exit 'no video files in file list'
fi

# set fullscreen mode if only one video in list
if [[ ${#rlist[@]} -eq 1 ]] && [[ ${full:-yes} == yes ]]; then
    fs[mplayer2]='--fs'
    fs[mplayer]='-fs'
fi

# video format ratios
WIDESCREEN=$(echo "scale=2; 64 / 27 * 100" | bc | sed -e 's/...$//')
HDTV=$(      echo "scale=2;    1.85 * 100" | bc | sed -e 's/...$//')
CINEMA=$(    echo "scale=2;  16 / 9 * 100" | bc | sed -e 's/...$//')
STANDARD=$(  echo "scale=2;   4 / 3 * 100" | bc | sed -e 's/...$//')

rindex=0              # index into rlist
started=0             # number of videos started in previous check

# delay between checks for empty slots.  Longer delays when playing more
# videos; shorter delays when more cpu cores are installed.
numProc=$(grep '^processor' /proc/cpuinfo | wc -l)
[[ $numProc -lt 2 ]] && numProc=2
delay=$(( $numWindows / $(( $numProc / 2 )) ))
[[ $delay -lt 1 ]] && delay=1

# play each video in an empty slot. Shift each file name off the list as each video is played.
while [[ $# -gt 0 ]]; do

    inhibit_screensaver

    # if all slots are filled with videos, sleep and skip further processing
    if [[ $(ps aux | grep 'mplayer.*noborder.*zoom.*xy.*geometry.*' | grep -v grep | wc -l) -eq $numWindows ]]; then
    if [[ $started -gt 0 ]]; then
        sleep $(( $delay - 1 ))s
        started=0
    else
        sleep ${delay}s
    fi
    continue
    fi
    started=0

    # fill empty slots with videos
    for slot in ${window[@]}; do
        if ! ps aux | grep "geometry $slot " | grep -vq grep; then

        # quit here if at end of file list
        if [[ $# -eq 0 ]]; then
        break
        fi

        # get dimensions of video
        widthDim=$($player -frames 0 ${id[$player]} ${rlist[$rindex]} 2>/dev/null | awk -F=  '/^ID_VIDEO_WIDTH/ {print $2}' 2>/dev/null)
        heightDim=$($player -frames 0 ${id[$player]} ${rlist[$rindex]} 2>/dev/null | awk -F=  '/^ID_VIDEO_HEIGHT/ {print $2}' 2>/dev/null)

        # compute format ratio
        format=$(echo "scale=2; $widthDim / $heightDim * 100" | bc | sed -e 's/...$//')

        # set aspect ratio for each video
        aspect=${asp[$player]}
        if [[ "$format" -ge "$WIDESCREEN" ]]; then
        aspect=${aspect}$wi
        elif [[ "$format" -ge "$HDTV" ]]; then
        aspect=${aspect}$hd
        elif [[ "$format" -ge "$CINEMA" ]]; then
        aspect=${aspect}$ci
        else
        aspect=${aspect}$st
        fi
        $player ${fd[$player]} $aspect -noborder -zoom ${fs[$player]} -xy $width -geometry "$slot" "${rlist[$rindex]}" &>/dev/null &
        unset rlist[$rindex]
        (( started++ ))
        (( rindex++ ))
        sleep 1s
            shift
        fi
    done
done

# inhibit the screensaver until the last video ends
while ps aux | grep 'mplayer.*noborder.*zoom.*xy.*geometry.*' | grep -vq grep; do
    sleep $delay
    inhibit_screensaver
done

graceful_exit

This version removes dependency on unsort and should work in most desktop environments, not just KDE.