#!/bin/sh
# Copyright © 2010-2014 Jonas Smedegaard <dr@jones.dk>
# Description: Recode a video into web-optimized format(s)
#
# 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, 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/>.
#
# Depends: libav-tools melt mediainfo ffmpegthumbnailer
#
# TODO: offer to skip rendering again if an output file exist already
# TODO: support --width and --height (resolving the other part from input/forced aspect ratio)

set -e

PRG=$(basename "$0")

showhelp() {
	cat <<EOF
Usage: $PRG [OPTION...] [--] [ARG=VALUE...] INPUTFILE... [ARG=VALUE...]
Encode video file in multiple web-optimized formats, and provide sample
html favoring open formats with optional non-JavaScript Flash fallback.

    --video             Video style:
                                       ref-bpp
                          talkinghead    0.1
                          action         0.15
                        (default: none)
    -p, --profile       Video format - size with optional rate suffix,
                        delimited by @ (except for widescreen labels):
                        e.g. 848x480@25 480p25 wvga@25
                        (default: none)
    -s, --size:         Video frame size:
                        [modulus 16]
                             320x240 qvga
                             640x480 vga          480p  848x480 wvga
                                                  576p 1024x576 wsvga
                            1024x768 xga       hd 720p 1280x720 wxga
                        [modulus 8]
                                                  240p  424x240 wqvga
                             480x360 hvga     nhd 360p  640x360
                             800x600 svga
                        (default: use input size)
    -a, --aspect        Display Aspect Ratio in melt format e.g. @16/9
                        (default: no aspect hinting)
    -r, --rate          Video framerate - integer or fraction:
                        e.g. 15 1001/24000 25 1001/30000
                        (default: use input framerate)
    --refbpp            Reference bits-per-pixel (relative to 360p30),
                        for computing average bitrate when not fixed.
                        (default: 0.12)
    -b, --bitrate       Fixed video bitrate in bytes: e.g. 768k 1M
                        (default: none - use variable bitrate)
    --formats           Containers and codecs to use (comma-sparated):
                                container  video codec   audio codec
                          ogg     Ogg        Theora        Vorbis
                          webm    WebM       VP8           Vorbis
                          mp4     MPEG-4     H.264         AAC
                        (default: webm,mp4)
    --h264profile       MPEG-4 AVC target profile: baseline main high
                        (default: baseline)
    --h264preset        MPEG-4 AVC target preset: slow ultrafast etc.
                        (default: medium)
    --webmpreset        WebM target preset: 360p 720p 720p50_60 etc.
                        (default: profile-related or 360p)
    --audio             Audio style:
                                  channels  compress  normalize
                          music    max 2
                          hqspeech     1
                          speech       1        X         X
                          silence      0
                        (default: none - use input channel count)
    --stem              Stem of output filenames, optionally with path
                        (default: basename of last input file)
    -t, --title         Title used in html fallback graphics
                        (default: stem)
    --filter            Add melt filter (applied to all input files)
    --sample [start]    Create only a 150 frames long sample from
                        beginning or optionally a later start frame.
    -h, --help          This help text

Examples:
    $PRG -s qvga -t "Funny guy" intro.dv myvideo.dv
    $PRG -p 480p --stem funny -t "Funny guy" myvideo.dv

Options before input files are passed to melt producer, and after to
melt avformat consumer.

Hints:
  * Use square-pixel max. 480 width (vga 480p) for widest compatibility.
  * Use a modulus 16 profile (qvga vga 480p 720p) for best compression.
  * Try lower reference bits-per-pixel until visual quality is affected.
  * Raise reference bits-per-pixel if needed, but no higher than 0.2.
    (you can inspect actual bits-per-pixel and bitrate with mediainfo)

More info:
<http://camendesign.com/code/video_for_everybody>
<http://www.streaminglearningcenter.com/articles/configuring-your-streaming-video-(for-newbies).html>
<http://en.wikipedia.org/wiki/HTML5_video>
<http://www.penguinproducer.com/2012/01/ladspa-noise-removal/>
<http://www.internetmarketingnotes.com/2010/07/free-embeddable-flash-video-flv-players-for-commercial-use/>
EOF
}

exit1() {
	response="${1:+Error: }${1:-Internal error!}"
	echo >&2 "$response"
	exit 1
}

# defaults
formats=webm,mp4
h264profile=baseline
samplelength=150

# parse cmdline options
TEMP="`getopt -s sh -o hp:s:a:r:b:t: -l help,profile:,size:,aspect:,rate:,video:,refbpp:,bitrate:,formats:,h264profile:,h264preset:,webmpreset:,audio:,stem:,title:,filter:,sample:: -n "$PRG" -- "$@"`" || exit1 "Internal getopt error."
eval set -- "$TEMP"
while true ; do
	case "$1" in
	    -h|--help) showhelp; exit;;
	    -p|--profile) profile="$2"; shift 2;;
	    -s|--size) size="$2"; shift 2;;
	    -a|--aspect) aspect="$2"; shift 2;;
	    -r|--rate) framerate="$2"; shift 2;;
	    --video) video="$2"; shift 2;;
	    --refbpp) refbpp="$2"; shift 2;;
	    -b|--bitrate) bitrate_fixed="$2"; shift 2;;
	    --formats) formats="$2"; shift 2;;
	    --h264profile) h264profile="$2"; shift 2;;
	    --h264preset) h264preset="$2"; shift 2;;
	    --webmpreset) webmpreset="$2"; shift 2;;
	    --audio) audio="$2"; shift 2;;
	    --stem) stem="$2"; shift 2;;
	    -t|--title) title="$2"; shift 2;;
	    --filter) filters="${filters:+$filters }-filter $2"; shift 2
		while [ $# -gt 0 ] ; do
			case "$1" in
			    *=*) filters="${filters:+$filters }$1"; shift;;
			    *) break;;
			esac
		done
		;;
	    --sample) sample=yes; samplestart="${2:-0}"; shift 2;;
	    --) shift; break;;
	    *) exit1 "Internal error resolving options.";;
	esac
done

# Resolve if melt is version 0.9.2 or newer
# TODO: drop when melt 0.9.2 is stable
melt_recent=$(melt -query filter=loudness | grep -i R128)

while [ $# -gt 0 ] ; do
	case "$1" in
	    *=*) _melt_in="${_melt_in:+$_melt_in }$1"; shift;;
	    *) break;;
	esac
done

while [ $# -gt 0 ] ; do
	case "$1" in
	    *=*) _melt_out="${_melt_out:+$_melt_out }$1"; shift;;
	    *) infiles="${infiles:+$infiles }$1"; shift;;
	esac
done

if [ -z "$infiles" ]; then
	showhelp
	exit1 "Too few parameters!"
fi

# input filename (mandatory)
infile_first=$(perl -e 'print pop @ARGV' $infiles)
[ -e "$infile_first" ] || exit1 "Input file missing!"

# resolve stem and title (if not explicitly set)
stem=${stem:-$(basename "$infile_first" | perl -pe 's/\.[^.]*//')}
title=${title:-$stem}

case "$profile" in
    *@*)
	while read s r foo; do
		size="${size:-$s}"
		framerate="${framerate:-$r}"
	done << EOF
$(echo "$profile" | perl -F@ -anE 'say join " ", @F')
EOF
	;;
    *p*)
	while read s r foo; do
		size="${size:-${s}p}"
		framerate="${framerate:-$r}"
	done << EOF
$(echo "$profile" | perl -Fp -anE 'say join " ", @F')
EOF
	;;
    *)
	size="$profile"
	;;
esac

case "$size" in
    qvga) size=320x240;;
    hvga) size=480x360;;
    vga) size=640x480;;
    svga) size=800x600;;
    xga) size=1024x768;;
    wqvga) size=424x240;;
    360p|nhd) size=640x360;;
    480p|wvga) size=848x480;;
    576p|wsvga) size=1024x576;;
    720p|wxga|hd) size=1280x720;;
esac

if [ -n "$size" ]; then
	while read w h foo; do
		width="${width:-$w}"
		height="${height:-$h}"
	done << EOF
$(echo "$size" | perl -Fx -anE 'say join " ", @F')
EOF
	if [ -z "$width" ] || [ -z "$height" ]; then
		exit1 "Failed to parse size \"$size\"."
	fi
fi

case "$framerate" in
    */*)
	while read d n foo; do
		framerate_den="${framerate_den:-$d}"
		framerate_num="${framerate_num:-$n}"
	done << EOF
$(echo "$framerate" | perl -Fx -anE 'say join " ", @F')
EOF
	;;
    ?*)
	framerate_den=1
	framerate_num="$framerate"
	;;
esac

while read w h r foo; do
	width_in="${width_in:-$w}"
	height_in="${height_in:-$h}"
	framerate_in="${framerate_in:-$r}"
done << EOF
$(mediainfo --Inform="Video;%Width% %Height% %FrameRate%" "$infile_first")
EOF

case "$video" in
    talkinghead)
	refbpp="${refbpp:-0.1}"
	;;
    action)
	refbpp="${refbpp:-0.15}"
	;;
    '')
	refbpp="${refbpp:-0.12}"
	;;
    *) exit1 "Unknown video style \"$video\".";;
esac

for format in $(echo "$formats" | sed -e 's/,/ /g'); do
	case $format in
	    ogg) ogg=yes;;
	    mp4) mp4=yes;;
	    webm) webm=yes;;
	    *) exit1 "Unknown format \"$format\".";;
	esac
done

case "$h264profile" in
    baseline|main)
	_melt_h264="properties=x264-medium-$h264profile ${h264preset:+-vpre=libx264-$h264preset}"
	;;
    high)
	_melt_h264="properties=x264-medium ${h264preset:+-vpre=libx264-$h264preset}"
	;;
    *) exit1 "Unknown MPEG-4 AVC profile \"$h264profile\".";;
esac

_width="${width:-$width_in}"
_height="${height:-$height_in}"

if [ -n "$_width" ] && [ -n "$_height" ]; then
	_pixels="$(($_width*$_height))"
fi
_frames="${framerate:-$framerate_in}"

if [ -n "$_pixels" ] && [ $_pixels -ge $((1024*768)) ]; then
	webmpreset="${webmpreset:-720p}"
	if [ -n "$_frames" ] && [ $_frames -gt 40 ]; then
		webmpreset="${webmpreset:-720p50_60}"
	fi
fi

bitrate="$bitrate_fixed"
# compute average bitrate from reference data and "power of .75" rule
if [ -z "$bitrate" ] && [ -n "$_pixels" ] && [ -n "$_frames" ]; then
	bitrate=$(perl -E '$refsize=640*360;' \
		-E "say int( +(($_pixels/\$refsize)**0.75*\$refsize*$_frames*$refbpp) )")
fi

# default per-codec-channel bitrates
bitrate_vorbis=64
bitrate_aac=96

case "$audio" in
    music)
	channels=2
	;;
    hqspeech)
	channels=1
	bitrate_vorbis=48
	bitrate_aac=64
	;;
    speech)
	channels=1
	bitrate_vorbis=48
	bitrate_aac=64
	compress=yes
	normalize=yes
	;;
    silence)
	channels=0
	;;
    '')
	channels=$(avprobe -v warning -show_streams "$infile_first" | perl -ne 's/channels=// and print $_')
	;;
    *) exit1 "Unknown audio style \"$audio\".";;
esac
[ $channels -le 2 ] || channels=2
[ $channels -gt 0 ] || channels=

# TODO: Check and fail if all needed tools are not available

# TODO: When verified beneficial, add option real_time=-2
melt="melt -progress"
_melt_in="${_melt_in:+$_melt_in }${sample:+in=${samplestart:-0} out=$((${samplestart:-0} + samplelength))}"
_melt_video="progressive=1${framerate:+ frame_rate_den="$framerate_den" frame_rate_num="$framerate_num"}${bitrate:+ vb=$bitrate}${size:+ s=${width:+$width}x${height:+$height}}${aspect:+ aspect=$aspect}"
_melt_ogg="$_melt_video f=ogg vcodec=libtheora${bitrate_fixed:- qscale=5}"
_melt_h264="$_melt_video $_melt_h264${bitrate_fixed:- qscale=5}"
_melt_webm="$_melt_video vpre=libvpx-${webmpreset:-360p}"
_melt_audio="${channels:+ac=$channels}"
# expand and compress (i.e. lower volume on silent and loud passages)
_melt_audio_filters_early="${compress:+-filter ladspa.1075 -filter ladspa.1073}"
# limit (i.e. avoid peaks "clipping")
_melt_audio_filters="${normalize:+-filter ladspa.1077}"
_melt_vorbis="$_melt_audio acodec=libvorbis ab=$(($channels*$bitrate_vorbis))k"
_melt_aac="$_melt_audio acodec=aac ab=$(($channels*$bitrate_aac))k"

# resolve EBU R128 audio normalizing
# TODO: normalize each infile separately when xml fed as infile keeps sync
if [ -n "$normalize" ] && [ -n "$melt_recent" ] && [ -n "$channels" ]; then
	$melt -group $_melt_in $infiles -group $_melt_audio_filters_early -filter loudness -consumer xml:$stem.xml $_melt_audio video_off=1 all=1
	_melt_loudness="$(perl -ne 'm!<property name="results">([^<]+)</property>! and print $1' $stem.xml)"
fi

if [ -n "$ogg" ]; then
	$melt -group $_melt_in $infiles -group ${channels:+$_melt_audio_filters_early${_melt_loudness:+ -filter loudness results="$_melt_loudness"} $_melt_audio_filters }$filters -consumer avformat:"$stem.ogv" $_melt_ogg $_melt_vorbis $_melt_out
fi

if [ -n "$mp4" ]; then
	[ -z "$bitrate_fixed" ] || $melt -group $_melt_in $infiles -group $filters -consumer avformat:/dev/null properties=x264-medium-pass1 $_melt_h264 $_melt_out
	$melt -group $_melt_in $infiles -group ${channels:+$_melt_audio_filters_early${_melt_loudness:+ -filter loudness results="$_melt_loudness"} $_melt_audio_filters }$filters -consumer avformat:"$stem.mp4" ${bitrate_fixed:+pass=2} $_melt_h264 $_melt_aac $_melt_out
	if [ -z "$melt_recent" ]; then
		mv "$stem.mp4" "$stem.mp4"~
		qt-faststart "$stem.mp4"~ "$stem.mp4"
		[ -f "$stem.mp4" ] && rm "$stem.mp4"~ || mv -f "$stem.mp4"~ "$stem.mp4"
	fi
fi

if [ -n "$webm" ]; then
	# TODO: use two-pass when supported by melt
	$melt -group $_melt_in $infiles -group ${channels:+$_melt_audio_filters_early${_melt_loudness:+ -filter loudness results="$_melt_loudness"} $_melt_audio_filters }$filters -consumer avformat:"$stem.webm" properties=webm $_melt_webm $_melt_vorbis $_melt_out
fi

# cleanup audio normalize hinting
rm -f $stem.xml

## JPEG preview
ffmpegthumbnailer -s0 -i "$stem.mp4" -o "$stem.jpg"

__width="${_width:+ width=\"$_width\"}"
__height="${_height:+ height=\"$_height\"}"
# Flash object needs extra space for controllers
__heightplus=${_height:+ height=\"$(($_height+4))\"}
__ogg=${ogg:+<source src=\"$stem.ogv\" type=\"video/ogg\" />
}
__webm=${webm:+<source src=\"$stem.webm\" type=\"video/webm\" />
}
__mp4=${mp4:+<source src=\"$stem.mp4\" type=\"video/mp4\" />
}
# TODO: resolve flash player to use
[ -z "$flashplayer" ] || flash=yes
[ -n "$mp4" ] || [ -z "$flash" ] || error1 "Cannot enable flash when mp4 format is disabled."
__flash=${flash:+<object$__width$__heightplus type=\"application/x-shockwave-flash\" data=\"$flashplayer.swf\">
<param name=\"movie\" value=\"$flashplayer.swf\" />
<param name=\"flashvars\" value=\"image=$stem.jpg&amp;file=$stem.mp4\" />
}
__oggfile=${ogg:+open format <a href=\"$stem.ogv\">Ogg</a>}
__webmfile=${webm:+open format <a href=\"$stem.webm\">WebM</a>}
__mp4file=${mp4:+closed Format <a href=\"$stem.mp4\">MPEG-4</a>}
[ -z "$webm" ] || [ -z "$ogg$mp4" ] || webm_and_more=yes
[ -z "$ogg" ] || [ -z "$mp4" ] || ogg_and_mp4=yes

cat >"$stem.html" <<EOF
<!-- Video for Everybody, Kroc Camen of Camen Design -->
<video$__width$__height preload controls>
$__mp4$__webm$__ogg$__flash<img src="$stem.jpg"$__width$__height alt="$title"
 title="No video playback capabilities, please download the video below" />
${flash:+</object>
}</video>
<p><strong>Download Video:</strong>
$__webmfile${webm_and_more:+,
}$__oggfile${ogg_and_mp4:+,
}$__mp4file.
</p>
EOF