#!/bin/bash

#################################################
# Script zum Schneiden von OTR-Aufnahmen
# (c) 2006,2007,2008 Hagen Meyer -- hagen@hcmeyer.de
#
# VERSION 081118-r1
#
# benutzung auf eigene gefahr...
#################################################

#######################
# CONFIG
#######################

# VORSICHT: tempdir wird komplett geleert!! Vorgabewert is empfehlenswert
#tempdir="/tmp/multicut/$$/"
tempdir="/tmp/multicut/"

# lokale cutlists (aktueller ordner) verwenden? name ist egal, wird nach inhalt ausgewaehlt
# KEIN vorrang vor heruntergeladenen cutlists bei aktiviertem download und automatischem modus
# 0: nein, 1: ja
local=1

# cutlists downloaden?
# versucht alle verfuegbaren cutlists auf cutlist.de zu finden
# 0: nein, 1: ja
download=1

# automatischer modus
# versucht, selbst die beste cutlist zu finden (lokal und internet, je nach einstellung), und verwendet diese.
# im interaktiven modus (automode=0) werden cutlists auch nach qualitaet sortiert, aber die auswahl erfolgt manuell
automode=0

# Mindest-bewertung (vom Autor) fuer cutlists (schlechter wird ignoriert).
#
# Werte:
# 5: framegenau und keine doppelten Szenen
# 4: framegenau
# 3: +/- 1 sek
# < 3: schlechter (wen interessierts? ;) )
#
# Empfehlung: 3-4. Wer will schon ungenaue schnitte??
# (wer mit avisplit schneidet kann auch schlechtere cutlists verwenden, das avisplit eh nur an keyframes schneidet)
min_rating=3

# mit welchem programm soll geschnitten werden?
# avidemux
# + kann framegenau schneiden
# - laeuft mit grafischer oberflaeche, kann daher nicht vollstaendig automatisiert werden
#   (die fragen am anfang koennen negativ beantwortet werden - die schritte werden automatisch durchgefuehrt)
# - laeuft nicht aus cronjobs (kann evtl mit "xhost +local:" erlaubt werden - untested)
# 
# avisplit (Standard, falls fehlerhafte angabe)
# - kann nur an keyframes schneiden -> schnitte sind nicht so genau, einige frames/sekunden werbung ist noch drin
# + laeuft vollstaendig auf console, daher auch gut in cronjobs einsetzbar
cutwith="avidemux"

# sollen die schnitte anschliessend mit mplayer ueberprueft werden? 
# check=1 oder 0
# mplayer wird nacheinander ca. 10 sekunden vor dem schnitt gestartet. fuer den naechsten schnitt mplayer einfach beenden (mit q)
# anfang und ende werden auch gezeigt
check=1

# Farben (nur editieren, wenn man weiss was man tut ;) )
# auskommentieren wenn man keine farben moechte

c_filename="\033[00;34m"
c_author="\033[01;37;40m"
c_rating="\033[01;33;41m"
c_cuts="\033[01;33;41m"
c_selection="\033[01;37;40m"
c_error="\033[01;31;40m"
c_info="\033[01;30;42m"
c_end="\033[00m"


# name der avidemux binary. wenn sie nicht automatisch gefunden wird, bitte hier aendern...
if type avidemux2_cli >/dev/null 2>&1 ; then
 avidemux="avidemux2_cli"
elif type avidemux2 >/dev/null 2>&1; then
 avidemux="avidemux2"
else
 avidemux="avidemux"
fi


#######################
# FUNCTIONS
#######################

# Sucht alle cutlists fuer diese datei, die beste wird spaeter gesucht...
##############################################################################################

function dlCutlists () { # filename
  cd $workdir
  filename=${1##*/}
  echo -n "Suche cutlists fuer $filename..."
  search=$( stat -c%s "$filename" )
  cd $tempdir
  rm *.xml 2>/dev/null # alte xmls loeschen, da sonst keine sichere zuordnung cutlist<->film durgefuehrt werden kann
  
  # xml herunterladen, und in einzelne abschnitte aufteilen
  wget -q -O - "http://cutlist.de/getxml.php?version=0.9.8.0&ofsb=$search" | awk -F ">" '/<id>/{split($2,tmp,"<");id=tmp[1]}/\/cutlist/{id=0}{if (id>0) {gsub("\t","");print > id ".de.xml" }}'
  
  wget -q -O - "http://cutlist.at/getxml.php?ofsb=$search" | awk -F ">" '/<id>/{split($2,tmp,"<");id=tmp[1]}/\/cutlist/{id=0}{if (id>0) {gsub("\t","");print > id ".at.xml" }}'
}

function dlCutlist () { # array-index
  cd $tempdir
  idx=$1
  wget -q -O "${cutlist[$idx]}" "${url[$idx]}"
  # "FIELD": Cutlist-Format
  if grep -q "StartFrame=" ${cutlist[$idx]} ; then
    vcf2format[$idx]=1
  elif grep -q "Start=" ${cutlist[$idx]} ; then
    vcf2format[$idx]=0
  else
    echo "ERROR: unbekanntes Cutlist-Format: ${cutlist[$idx]}" >&2
    exit 1
  fi
}

# sucht die beste cutlist fuer eine datei aus dem ordner $tempdir
#############################################################
function findBestCutlist () { # filename
  echo "Filtere Cutlists nach gegebenen Kriterien..."
  cd $tempdir
  unset cutlist
  filename=${1##*/}
  filename=${filename%TVOON*}
  i=1
  # Lade die wichtigen daten der passenden cutlists in arrays (cutlist, rating, cuts)
  # beruecksichtigt vorerst nur LOKALE cutlists, online kommt spaeter
  for cl in `find . -exec grep -iq "ApplyToFile=$filename" {} \; -print`; do
    unset url[$i]
    # FIELD: RatingByAuthor
    tmp=`grep RatingByAuthor $cl`
    tmp=${tmp%[[:cntrl:]]} # letztes zeichen loeschen (\r)
    rating[$i]=${tmp#RatingByAuthor=}
    [ ${rating[$i]} -lt $min_rating ]  && continue	# naechste cutlist, wenn rating zu gering
    # "FIELD": Cutlist-Format
    if grep -q "StartFrame=" $cl ; then
      vcf2format[$i]=1
    elif grep -q "Start=" $cl ; then
      vcf2format[$i]=0
    else
      echo "ERROR: unbekanntes Cutlist-Format: ${cl##*/}" >&2
      continue # cutlist ignorieren, unbekanntes format...
    fi
    # FIELD: Author
    tmp=`grep "^Author" $cl`
    tmp=${tmp%[[:cntrl:]]}
    author[$i]=${tmp#Author=}
    author[$i]=${author[$i]:-Unbekannt}
    # FIELD: NoOfCuts
    tmp=`grep NoOfCuts $cl`
    tmp=${tmp%[[:cntrl:]]} # letztes zeichen loeschen (\r)
    cuts[$i]=${tmp#NoOfCuts=}
    # FIELD: Comment
    tmp=`grep UserComment $cl`
    tmp=${tmp%[[:cntrl:]]} # letztes zeichen loeschen (\r)
    comment[$i]=${tmp#UserComment=}
    # verschiedene fehler...
    unset error[$i] content[$i] errordesc[$i]
    if grep -q "EPGError=1" $cl ; then
      tmp=`grep ActualContent $cl`
      tmp=${tmp%[[:cntrl:]]} # letztes zeichen loeschen (\r)
      content[$i]="Tatsaechlicher Inhalt: ${tmp#ActualContent=}"
      error[$i]=" EPG-Fehler! "
    fi
    if grep -q "MissingBeginning=1" $cl ; then
      error[$i]="${error[$i]} Anfang fehlt! "
    fi
    if grep -q "MissingEnding=1" $cl ; then
      error[$i]="${error[$i]} Ende fehlt! "
    fi
    if grep -q "MissingAudio=1" $cl ; then
      error[$i]="${error[$i]} Ton fehlt! "
    fi
    if grep -q "MissingVideo=1" $cl ; then
      error[$i]="${error[$i]} Bild fehlt! "
    fi
    if grep -q "OtherError=1" $cl ; then
      tmp=`grep OtherErrorDescription $cl`
      tmp=${tmp%[[:cntrl:]]} # letztes zeichen loeschen (\r)
      errordesc[$i]="Fehlerbeschreibung: ${tmp#OtherErrorDescription=}"
      error[$i]="${error[$i]} Sonstiger Fehler! "
    fi
    # Nicht vergessen: dateiname ;)
    cutlist[$i]=${cl##*/}
    # userrating
    if [ -f "${cutlist[$i]}.rating" ] ; then
      userrating[$i]=$( cat "${cutlist[$i]}.rating" )
    else
      unset userrating[$i]
    fi
    # erst hier increment, vorher kann das speichern dieser cutlist abgebrochen werden
    let i++
  done
  
  # nun zu den ONLINE cutlists...
  for cl in `ls *.xml 2>/dev/null` ; do
    unset error[$i] content[$i] errordesc[$i] vcf2format[$i]
    # FIELD: RatingByAuthor
    tmp=`grep "<ratingbyauthor>" $cl`
    tmp=${tmp%<*}
    rating[$i]=${tmp#*>}
    [ ${rating[$i]} -lt $min_rating ]  && continue	# naechste cutlist, wenn rating zu gering
    # FIELD: Author
    tmp=`grep "<author>" $cl`
    tmp=${tmp%<*}
    author[$i]=${tmp#*>}
    author[$i]=${author[$i]:-Unbekannt}
    # FIELD: cuts (noch nicht unterstuetzt)
    cuts[$i]="0"
    # FIELD: Comment
    tmp=`grep "<usercomment>" $cl`
    tmp=${tmp%<*}
    comment[$i]=${tmp#*>}
    # EPG-Fehler!
    tmp=`grep "<actualcontent>" $cl`
    tmp=${tmp%<*}
    tmp=${tmp#*>}
    if [ -n "$tmp" ]; then
      content[$i]="Tatsaechlicher Inhalt: ${tmp#ActualContent=}"
      error[$i]=" EPG-Fehler! "
    fi
    # FIELD: userrating
    tmp=`grep "<rating>" $cl`
    tmp=${tmp%<*}
    tmp=${tmp#*>}
    if [ -n "$tmp" ]; then
      userrating[$i]=$tmp
      tmp=`grep "<ratingcount>" $cl`
      tmp=${tmp%<*}
      userrating[$i]="${userrating[$i]}|${tmp#*>}"
    else
      unset userrating[$i]
    fi
    # dateiname 
    tmp=`grep "<name>" $cl`
    tmp=${tmp%<*}
    cutlist[$i]=${tmp#*>}
    # url
    cl=${cl##*/}
    cl=${cl%.*}
    url[$i]="http://cutlist.${cl#*.}/getfile.php?id=${cl%.*}"
    let i++
  done

  if [ ${#cutlist[@]} -eq 0 ] ; then
    echo -e "Keine passende Cutlist fuer $c_filename$filename$c_end gefunden. Abbruch."
    return 0
  fi
  sortCutlists		# gesammelte cutlists nach "qualitaet" sortieren
  [ $automode -ne 0 ] && return 1	# interaktive auswahl nicht noetig, ersten eintrag der arrays verwenden
  # interaktive auswahl...
  clear
  echo -e "\nFuer die Datei $c_filename$filename$c_end wurden folgende cutlists gefunden:\n\n"
  i=1
  while [ $i -le ${#cutlist[@]} ] ; do
    if [ -z "${vcf2format[$i]}" ] ; then
      format_string="Unbekannt"
    else
      format_string=$( [ ${vcf2format[$i]} -eq 1 ] && echo "VCF2Cutlist-Standard" || echo "Assistant-Standard" )
    fi
    printf "$c_selection[%d]$c_end\t%s von $c_author %s $c_end\n\tAutor-Wertung: $c_rating %d $c_end\t\tUser-Wertung: $c_rating %s $c_end (%d Stimmen)\n\tFormat: %s\tAnzahl Schnitte: $c_cuts %d $c_end\n\tKommentar: %s\n" $i "${cutlist[$i]}" "${author[$i]}" "${rating[$i]}" "${userrating[$i]%|*}" "${userrating[$i]#*|}" "$format_string" "${cuts[$i]}" "${comment[$i]}"
    if [ -n "${error[$i]}" ] ; then
      echo -e "\t$c_error${error[$i]}$c_end"
    fi
    if [ -n "${content[$i]}" ] ; then
      echo -e "\t${content[$i]}"
    fi
    if [ -n "${errordesc[$i]}" ] ; then
      echo -e "\t${errordesc[$i]}"
    fi
    if [ -n "${url[$i]}" ] ; then
      echo -e "\t$c_info Online - ${url[$i]%/*} $c_end"
    fi
    echo
    let i++
  done
  printf "$c_selection[0]$c_end\tKeine Auswahl. Diesen Film nicht schneiden.\n\n\n"
  read -p "Auswahl: " ret
  # hier koennte noch ein plausi-check erfolgen...
  return $ret
}

# sortiere cutlists nach "qualitaet" (absteigend): RatingByAuthor->User-Rating->VCF2Format?->NoOfCuts->ActualContent
##########################################################################################
# Erklaerung:
# RatingByAuthor gibt die beste Auskunft der Schnittqualitaet
# VCF2Format schneidet nach Frames, nicht nach zeit ==> duerfte meistens besser sein
# Mehr Cuts duerfte meistens besser sein, (ueberschuessiges Ende weg, keine Werbung uebersehen, etc.)
# ActualContent: wenn leer, dann besser (meistens gesetzt, wenn es nicht um den eigentlich aufgenommenen film geht,
# sondern um das ende des vorhergehenden o.ae.)
# !! vollautomatisch kann NIE die absolut beste cutlist gefunden werden, es ist nur der versuch eine moeglichst gute zu finden...
##########################################################################################
function sortCutlists () { # greift auf die arrays zu, die in "findBestCutlist" erstellt werden
  local changed=1
  while [ $changed -eq 1 ] ; do	
    changed=0
    i=2
    while [ $i -le ${#cutlist[@]} ] ; do
      if [ ${rating[$i-1]} -lt ${rating[$i]} ] ; then
        swap $i
        changed=1
      elif [ ${rating[$i-1]} -eq ${rating[$i]} ] && [ "${userrating[$i-1]%|*}" \< "${userrating[$i]%|*}" ] ; then
        swap $i
        changed=1
      elif [ ${rating[$i-1]} -eq ${rating[$i]} ] && [ "${userrating[$i-1]%|*}" = "${userrating[$i]%|*}" ] && [ ${vcf2format[$i-1]:-0} -lt ${vcf2format[$i]:-0} ] ; then
        swap $i
        changed=1
      elif [ ${rating[$i-1]} -eq ${rating[$i]} ] && [ "${userrating[$i-1]%|*}" = "${userrating[$i]%|*}" ] && [ ${vcf2format[$i-1]:-0} -eq ${vcf2format[$i]:-0} ] && [ ${cuts[$i-1]} -lt ${cuts[$i]} ] ; then
        swap $i
        changed=1
      elif [ ${rating[$i-1]} -eq ${rating[$i]} ] && [ "${userrating[$i-1]%|*}" = "${userrating[$i]%|*}" ] && [ ${vcf2format[$i-1]:-0} -eq ${vcf2format[$i]:-0} ] && [ ${cuts[$i-1]} -eq ${cuts[$i]} ] && [ -z "${content[$i]}" ] && [ -n "${content[$i-1]}" ]; then
        swap $i
        changed=1
      fi
      let i++
    done
  done
}

function swap () { # parameter: i: elemente i-1 und i werden (von allen arrays) vertauscht 
  local tmp=${cutlist[$1-1]}
  cutlist[$1-1]=${cutlist[$1]}
  cutlist[$1]=$tmp
  tmp=${rating[$1-1]}
  rating[$1-1]=${rating[$1]}
  rating[$1]=$tmp
  tmp=${userrating[$1-1]}
  userrating[$1-1]=${userrating[$1]}
  userrating[$1]=$tmp
  tmp=${vcf2format[$i-1]}
  vcf2format[$i-1]=${vcf2format[$i]}
  vcf2format[$i]=$tmp
  tmp=${cuts[$1-1]}
  cuts[$1-1]=${cuts[$1]}
  cuts[$1]=$tmp
  tmp=${comment[$1-1]}
  comment[$1-1]=${comment[$1]}
  comment[$1]=$tmp
  tmp=${content[$1-1]}
  content[$1-1]=${content[$1]}
  content[$1]=$tmp
  tmp=${author[$1-1]}
  author[$1-1]=${author[$1]}
  author[$1]=$tmp
  tmp=${error[$1-1]}
  error[$1-1]=${error[$1]}
  error[$1]=$tmp
  tmp=${errordesc[$1-1]}
  errordesc[$1-1]=${errordesc[$1]}
  errordesc[$1]=$tmp
  tmp=${url[$1-1]}
  url[$1-1]=${url[$1]}
  url[$1]=$tmp
}

# schneide datei mit gegebener cutlist
########################################################################
function cutfilm () { # film, cutlist, vcf2format?
  film=$1
  cutlist=$2
  vcf2format=$3
  cuts=""
  unset checktimes
  checktimes[0]=0
  checkcnt=0
  unset markerA
  unset markerB
  markercnt=0
  markersminus=0
  markerA[0]=0
  cd $tempdir
  [ $cutwith == "avidemux" ] && project_start $film
  if [ $vcf2format -eq 1 ] ; then
    lines=$( egrep "^(StartFrame|DurationFrames)" $cutlist | tr -d "\r" )
  else
    lines=$( egrep "^(Start|Duration)" $cutlist | tr -d "\r" )
  fi
  fps=$( grep FramesPerSecond $cutlist | tr -d "\r" | sed 's/FramesPerSecond=//' )
  for line in $lines ; do
    if echo $line | grep -q "Start" ; then 	######### startcut ##########
      startcut=${line##*=}
      if [ $vcf2format -eq 1 ] ; then
        if [ $cutwith == "avidemux" ] ; then
          echo -n "app.addSegment(0,$startcut," >> project.js
        elif [ $cutwith == "avisplit" ] ; then
          cuts=$cuts$startcut-
        else
          let markerB[$markercnt]=$startcut-$markersminus
          let markersminus=$markersminus+${markerB[$markercnt]}-${markerA[$markercnt]}
          let markercnt++
        fi
      else
        secs=${startcut%%.*}
        decimalsecs=$[ 10#${startcut##*.} ]
        decimalsecs=${decimalsecs::2}
        decimalsecs=${decimalsecs#0}
        if [ $cutwith == "avidemux" ] ; then
	  if type bc > /dev/null ; then
	    frames=`echo "$startcut * $fps + 0.5" | bc` # +0.5 zum runden...
	    frames=${frames%%.*}
	  else
            frames=$(( $secs*25 + ${decimalsecs:-0} / 4 ))
	  fi
          echo -n "app.addSegment(0,${frames:-0}," >> project.js
        elif [ $cutwith == "avisplit" ] ; then
          time=$( date -u -d @$secs +%T )		# wandelt sekunden.dezimalen in hh:mm:ss um...
          frames=$(( ${decimalsecs:-0} / 4 ))		# frames ausrechnen runden ist egal
          cuts=$cuts$time.$frames-			# hh:mm:ss.ms (ms ist frames, nicht millisekunden!!)
        else 
          markerB[$markercnt]=$(( $secs*25 + ${decimalsecs:-0} / 4 - $markersminus))
          let markersminus=$markersminus+${markerB[$markercnt]}-${markerA[$markercnt]}
          let markercnt++
        fi
      fi
    else					######### endcut ############
      if [ $vcf2format -eq 1 ] ; then
        if [ $cutwith == "avidemux" ] ; then
          echo "${line##*=})" >> project.js
        elif [ $cutwith == "avisplit" ] ; then
          let endcut=$startcut+${line##*=}
          cuts="$cuts$endcut,"
        else
          let markerA[$markercnt]=$startcut+${line##*=}-$markersminus
        fi
        let checkcnt++
        let checktimes[$checkcnt]=${checktimes[$checkcnt-1]}+${line##*=}/25
      else
        length=${line##*=}
        if [ $cutwith == "avisplit" ] ; then
          add_decimal $startcut ${line##*=}
          time=$( date -u -d @$solution +%T )
          decimalsecs=${solution##*.}
          decimalsecs=${decimalsecs::2}
          decimalsecs=${decimalsecs#2}
          frames=$(( ${decimalsecs:-0} / 4 ))
          cuts=$cuts$time.$frames,
        else
          decimalsecs=${length##*.}
          decimalsecs=${decimalsecs::2}
          decimalsecs=${decimalsecs#0}
          if type bc > /dev/null ; then
            frames=`echo "$length * $fps + 0.5" | bc` # +0.5 zum runden...
            frames=${frames%%.*}
          else
            frames=$(( ${length%%.*}*25 + ${decimalsecs:-0}/4 ))
          fi
          if [ $cutwith == "avidemux" ] ; then
            echo "$frames)" >> project.js
          else
            let markerA[$markercnt]=${markerA[$markercnt-1]}+$frames
          fi
        fi
        let checkcnt++
        let checktimes[$checkcnt]=${checktimes[$checkcnt-1]}+${length%%.*}
      fi
    fi
  done
  markerB[$markercnt]="ENDE"
  name=${film##*/}
  outname="$cutdir/${name%.mpg.avi}-cut.avi"
  if [ $cutwith == "avidemux" ] ; then
    project_end "$outname"
    echo "Starte $avidemux mit den errechneten Schnitten..."
    $avidemux --nogui --force-smart --run project.js --quit 2>&1 >/dev/null
    if [ $? -eq 0 ] && [ -f "$outname" ] ; then
      echo "$name erfolgreich geschnitten!"
      mv $film $uncutdir/$name
    else
      echo "Es ist ein Fehler aufgetreten! $name moeglicherweise nicht geschnitten!"
      return
    fi
  elif [ $cutwith == "avisplit" ] ; then 
    cuts=${cuts%,}	# letztes komma abtrennen...
    echo "Uebergebe die errechneten Cuts an avisplit..."
    echo avisplit -i $film -o "$outname" -t $cuts -c
    # Auftrag an avisplit uebergeben... (mergen wird hier durch -c auch erreicht)
    avisplit -i $film -o "$outname" -t $cuts -c >/dev/null
    if [ $? -eq 0 ] ; then
      echo "$name erfolgreich geschnitten!"
      mv $film $uncutdir/$name
    else
      echo "Avisplit hat einen Fehler gemeldet! $name moeglicherweise nicht geschnitten!"
      return
    fi
  else # zeige stellen zum schneiden an
    echo "Jede nachfolgende Zeile steht fuer einen Werbeblock (Frameposition). Positionieren Sie die Marker, und optimieren Sie ihre Position."
    echo "Die nachfolgende Zeile gibt die Frameposition NACH dem herausschneiden aller vorherigen Bloecke an."
    echo
    cnt=0
    while [ $cnt -le $markercnt ] ; do
      echo -e "A: ${markerA[$cnt]}\t B: ${markerB[$cnt]}"
      let cnt++
    done
    echo
    echo "Bitte stellen Sie Ihre verbesserte Cutlist auf http://cutlist.de zur Verfuegung, die Community kann nur funktionieren, wenn alle mitarbeiten!"
    echo
  fi
  ## schnittstellen ueberpruefen
  [ $check -eq 1 ] && type mplayer >/dev/null && read -p "Zur Ueberpruefung der Schnittstellen bitte Taste druecken..." -n 1
  echo "Schnitte bei folgenden Zeiten:"
  i=0
  while [ $i -lt ${#checktimes[@]} ] ; do
    date -u -d @${checktimes[$i]} +%T
    [ $check -eq 1 ] && type mplayer >/dev/null && mplayer -osdlevel 3 -ss $(( ${checktimes[$i]} - 10 )) "$outname" 1>/dev/null 2>/dev/null
    let i++
  done
}

function project_start () { # film
cat << HEADER > project.js
//AD
var app = new Avidemux();
app.load("$1");
app.rebuildIndex();
app.clearSegments();
HEADER
}

function project_end () { # save-as
cat << FOOTER >> project.js
app.video.setPostProc(3,3,0);
app.video.setFps1000(25000);
app.video.codec("Copy","CQ=4","0 ");
app.audio.reset();
app.audio.codec("copy",128,0,"");
app.audio.normalizeMode=0;
app.audio.normalizeValue=0;
app.audio.delay=0;
app.audio.mixer("NONE");
app.audio.scanVBR();
app.setContainer("AVI");
setSuccess(app.save("$1"));
FOOTER
}

# dezimales addieren
########################
function add_decimal () { # zahl1, zahl2, ==> ergebnis in $solution
  int1=${1%.*}
  int2=${2%.*}
  let ret_int=$int1+$int2
  dec1=${1#*.}
  dec2=${2#*.}
  while [ ${#dec1} -lt ${#dec2} ] ; do		# solange die erste zahl "kuerzer" ist...
    dec1=${dec1}0
  done
  while [ ${#dec2} -lt ${#dec1} ] ; do		# umgekehrt...
    dec2=${dec2}0
  done
  length=${#dec1}				# maximale laenge der nachkommastellen
  shopt -s extglob
  dec1=${dec1#*[0]}				# fuehrende nuller entfernen
  dec1=${dec1:-0}				# und sicherstellen, dass nicht leer
  dec2=${dec2#*[0]}
  dec2=${dec2:-0}
  let ret_dec=$dec1+$dec2
  if [ ${#ret_dec} -gt $length ] ; then		# laenger, also uebertragen
    let ret_int++
    ret_dec=${ret_dec#1}
  fi
  solution=$ret_int.$ret_dec
}

function help () {
cat << END
Aufruf:
$0 [options] files

Moegliche Optionen:

-x	Avidemux verwenden (framegenau)
-n	nicht schneiden, nur Schnittstellen anzeigen 
	(zum manuellen Verbessern der Schnitte, deaktiviert ueberpruefen)
-s	Avisplit verwenden (an Keyframes)

-l	Lokale Cutlists einbeziehen
-nl	Lokale Cutlists NICHT einbeziehen
-d	Cutlists downloaden
-nd	Cutlists NICHT downloaden
-c	Schnittstellen ueberpruefen (erfordert mplayer)
-nc	Schnittstellen NICHT ueberpruefen

-i	Interaktiver Modus
-a	Automatischer Modus (nur cutlist-Auswahl)

-m X	Mindest-Rating (0 bis 5)


Optionen muessen VOR den Dateien angegeben werden, wenn Optionen einen Parameter verlangen muss dieser ZWINGEND angegeben werden. Das Script fuehrt KEINE Ueberpruefung der Argumente durch, falsche Argumente koennen zu Fehlern fuehren! 

Die Standard-Optionen koennen am Anfang des Scripts eingestellt werden. Dort sind die einzelnen Optionen auch nochmal genauer beschrieben.

(c) 2006-2007 Hagen Meyer <hagenmeyer@web.de>
END
exit 1
}

#######################
# START
#######################

while [ "$1" != "${1#-}" ] ; do	# solange der naechste parameter mit "-" anfaengt...
  case ${1#-} in
    x) cutwith="avidemux"; shift;;
    n) cutwith="dontcut"; check=0;  shift;;
    s) cutwith="avisplit"; shift;;
    l) local=1; shift;;
    nl) local=0; shift;;
    d) download=1; shift;;
    nd) download=0; shift;;
    c) check=1; shift;;
    nc) check=0; shift;;
    i) automode=0; shift;;
    a) automode=1; shift;;
    m) min_rating=$2; shift 2;;
    *) help; exit 1;;
  esac
done

if [ $cutwith == "avidemux" ] && ! type $avidemux > /dev/null ; then
  echo "Bitte installieren Sie avidemux! Abbruch."
  exit 1
elif [ $cutwith == "avisplit" ] && ! type avisplit > /dev/null ; then
  echo "Bitte installieren Sie das Paket 'transcode'! Abbruch."
  exit 1
fi

# benoetigte ordner (falls nicht vorhanden) erstellen
workdir=$PWD
cd $PWD
if [ ! -d cut ] ; then
  mkdir cut
fi
cutdir=${PWD%/}/cut
if [ ! -d cut/uncut ] ; then
  mkdir cut/uncut
fi
uncutdir=${PWD%/}/cut/uncut
if [ ! -d $tempdir ] ; then
  mkdir -p $tempdir || (echo "Kann temporaeren Ordner nicht erstellen! Exit." && exit 1)
fi
tempdir=${tempdir%/}

# temporaeren ordner loeschen
rm -r $tempdir/* 2>/dev/null

# lokale cutlists kopieren (passende wird nach inhalt ausgewaehlt)
[ $local -ne 0 ] && cp *.cutlist $tempdir 2>/dev/null

# zu schneidende dateien durchgehen...
for file in ${@:-*.mpg*.avi}; do
  cd $workdir
  file=`cd ${file%/*} 2>/dev/null ; pwd`/${file##*/}	# absoluten dateinamen ermitteln
  [ $download -ne 0 ] && dlCutlists $file
  findBestCutlist $file
  usecl=$?	# zurueckgegebene cutlist verwenden. (array-index)
  [ $usecl -eq 0 ] && continue	# abbruch, film nicht schneiden
  clear 2>/dev/null	# fehler ignorieren (tritt bei cron-aufrufen auf, da $TERM nicht gesetzt ist)
  if [ -n "$url[$usecl]" ] ; then
    dlCutlist $usecl
  fi
  format_string=$( [ ${vcf2format[$usecl]} -eq 1 ] && echo "VCF2Cutlist-Standard" || echo "Assistant-Standard" )
  printf "\nSchneide Film $c_filename%s$c_end mit folgender Cutlist:\n\n%s von $c_author %s $c_end\nAutor-Wertung: $c_rating %d $c_end\t\tUser-Wertung: $c_rating %s $c_end (%d Stimmen)\nFormat: %s\tAnzahl Schnitte: $c_cuts %d $c_end\nKommentar: %s\n" ${file##*/} "${cutlist[$usecl]}" "${author[$usecl]}" "${rating[$usecl]}" "${userrating[$usecl]%|*}" "${userrating[$usecl]#*|}" "$format_string" "${cuts[$usecl]}" "${comment[$usecl]}"
  if [ -n "${error[$usecl]}" ] ; then
    echo -e "$c_error${error[$usecl]}$c_end"
  fi
  if [ -n "${content[$usecl]}" ] ; then
    echo -e "${content[$usecl]}"
  fi
  if [ -n "${errordesc[$usecl]}" ] ; then
    echo -e "${errordesc[$usecl]}"
  fi
  echo
  cutfilm $file ${cutlist[$usecl]} ${vcf2format[$usecl]}
done

# temporaeren ordner loeschen
#rm -r $tempdir 2>/dev/null