#!/bin/bash
#    xsane2speech - speech directly from xsane
#    Copyright (C) 2010 - 2019 Heinrich Schwietering
# 
#    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 <https://www.gnu.org/licenses/>.
##
#
##############################################################################
#
#                               xsane2speech 0.3
#
#                       *** OCR and TTS made simple ***
#
#
##############################################################################
#
# xsane2speech is a OCR wrapper to be able to use tesseract or cuneiform
# with xsane, and utter the result via espeak or festival or save it as mp3
#
#
#
TEMP_DIR=/tmp/      # folder for temporary files (TIFF & tesseract data)
ERRORLOG="xsane2speech.log"  # file where STDERR goes
ESPEAK=espeak
CUNEIFORM=cuneiform
FESTIVAL=/PATH/TO/COMPILED/VERSION/OF/festival/bin #path for german festival and text2wave
TESSERACT=tesseract
USER=~/Dokumente/Vorlesen
SEL=/usr/local/bin/select.sh
MAINPROG=xsane2speech.sh

if [[ -z "$1" ]]
  then
  echo "Usage: $0 [OPTIONS]

  xsane2speech converts files to TIF, scans them with Tesseract or Cuneiform
  outputs the text in a file and converts it to speech

  OPTIONS:
    -i <file1>  define input file (any image-format supported)
    -o <file2>  define output-file (*.txt)
    -l <lang>  define language-data OCR engine should use
    -e <option> extra option for Cuneiform
    -z <ocr-engine> OCR engines cuneiform or tesseract (default)
    -y <synthesizer> define synthesizer festival or eSpeak (default)
    -x <settings> synthesizer settings; for festival, only [language] is possible

  Progress- & error-messages will be stored in this logfile:
     $TEMP_DIR$ERRORLOG

  xsane2tess depends on
    - XSane http://www.xsane.org/
    - ImageMagick  http://www.imagemagick.org/
    - TesseractOCR https://github.com/tesseract-ocr
    - Cuneiform-Linux https://launchpad.net/cuneiform-linux
    - eSpeak http://espeak.sourceforge.net/
    - festival http://www.cstr.ed.ac.uk/projects/festival
    - optional: german festival
    - iconv http://www.gnu.org/software/libiconv/
    - yad http://sourceforge.net/projects/yad-dialog/
    - lame http://lame.sourceforge.net/
    - mbrola https://github.com/numediart/MBROLA
  Some coding was stolen from 'ocube'
  http://www.geocities.com/thierryguy/ocube.html

"
  exit
fi

endsel(){
       { if 
           pidof yad true ; then 1>&2 #the PIDs end up in the text without the 1&>2
           $(killall -q -s SIGKILL yad)
           echo "MAIN: yad ended" 1>&2
	   rm -f /tmp/paused.txt
       fi }
}

endall(){
      echo "MAIN: text $FILE_OUT-read.txt erased" 1>&2
      echo "MAIN: ~~~+++~~~~+++~~~ xsane2speech aborted" $(date +%c) 1>&2
      $(rm -f "$TXT_FILE.txt" ; rm -f "$FILE_OUT-read.txt" ; killall -q -s SIGKILL "$MAINPROG") 1>&2
}

resetname(){
	cat "$FILE_OUT-read.txt" "$FILE_OUT" > "$FILE_OUT-new"
        mv "$FILE_OUT-new" "$FILE_OUT-read.txt"
        rm -f "$FILE_OUT.txt"
        rm -f "$FILE_OUT"
}

cleanall(){
# clean text
sed -i -r -e 's/››/"/g; s/[-—–]/-/g' "$TXT_FILE.txt" #replaces incompatibel -signs
sed -i -r -e 's/fi/fi/g; s/fl/fl/g; s/[íı]/i/g' "$TXT_FILE.txt" # fixes ligature fi, fl, signs íı
sed -i -r -e 'N;s/([[:lower:]])-\n([[:lower:]][^ ]* ?)/\1\2\n/;P;D' "$TXT_FILE.txt" #removes "Trennungen"
sed -i -r -e 's/([]I])([aäeioöuü])/\ J\2/g' "$TXT_FILE.txt" ## replace misinterpreted ]/I with J
sed -i -r -e 's/fš/ß/g' "$TXT_FILE.txt" #replaces misinterpreted fš with ß
sed -i -r -e 's/<</"/g; s/>>/"/g' "$TXT_FILE.txt" #replaces incompatible signs
}

cleanfestival(){
# changes certain sign combinations festival can't use
#sed -i -r -e 's/([[:alpha:]][[:alpha:]])([0-9])/\1 \2/g; s/([[:lower:]])([[:upper:]])/\1\l\2/g' "$FILE_OUT"
sed -i -r -e 's/([[:upper:]])\.([[:upper:]])\./\1 \2 /g' "$TXT_FILE.txt" # remove dots in U.S. (example)
sed -i -r -e 's/([[:alpha:]][[:alpha:]])([0-9])/\1 \2/g' "$TXT_FILE.txt" # dissembles character-digit-digit combinationes
sed -i -r -e 's/[’‘]/`/g; s/[«»ˮ„”“‟]/"/g; s/,,/"/g' "$TXT_FILE.txt" #replaces incompatible utf-8 signs
sed -i -r -e 's/››/"/g; s/[-—]/-/g' "$TXT_FILE.txt" #replaces incompatible utf-8 signs
sed -i -r -e 's/‚/,/g' "$TXT_FILE.txt"
sed -i -r -e 's/([0-9])([[:alpha:]])/\1 \2/g' "$TXT_FILE.txt" # dissembles digit-character combinationes
iconv -t ISO8859-15 "$TXT_FILE.txt" -o "$TXT_FILE.txt" # recodes to ISO-8859-15 for festival
}

# get options...
while getopts ":i:o:l:e:z:y:x:" OPTION
  do
  case $OPTION in
    i )  # input filename (with path)
      FILE_PATH="$OPTARG"
    ;;
    o )  # output filename
      FILE_OUT_LONG="$OPTARG"
    ;;
    l )  # language selection for OCR engine
      LANGUAGE="$OPTARG"
    ;;
    e )  # format selection for cuneiform
      EXTRA="$OPTARG"
    ;;
    z )  # OCR engine
      OCRENG="$OPTARG"
    ;;
    y )  # synthesizer selection (default is eSpeak)
      SYNTH="$OPTARG"
    ;;
    x )  # Synthesizer-settings (language, speed etc)
      SYNSET="$OPTARG"
    ;;
  esac
done


# strips extension from FILE_OUT_LONG
FILE_OUT="${FILE_OUT_LONG%.*}"

# redirect STDERR to ERRORLOG
exec 2>>"$TEMP_DIR""$ERRORLOG"

#create dummy file to begin the process 
echo " " >> "$FILE_OUT".txt

echo 1>&2
echo "Start ~~~+++~~~~+++~~~" $(date +%c) 1>&2

# set variable for sound processing
{ if [[ $SYNTH == "festival" ]] ; then
   { if [[ $SYNSET == "german" ]] ; then
      SOUND=ffplay
   else
      SOUND=aplay
   fi }
else
   SOUND=espeak
   SYNTH=espeak
fi }
echo "MAIN: $SOUND set for $SEL" 1>&2

#check charset if output file exists and change it is neccesary
{ if [ -f "$FILE_OUT.txt" ] ; then
   CHECKCHAR=$(file -b "$FILE_OUT.txt")
   { if [ "$CHECKCHAR" != "empty" ] ; then 
      echo "MAIN: File exists, Charset is $CHECKCHAR" 1>&2
      mv "$FILE_OUT.txt" "$TXT_FILE.txt"
      cleanall
      { if [ $SYNTH != "festival" ] ; then
         { if [[ "$CHECKCHAR" == "ISO-8859 text" ]] ; then
            LC_ALL=C iconv -f ISO8859-15 -t UTF-8 "$TXT_FILE.txt" -o "$TXT_FILE.txt"
            echo "MAIN: Charset changed to UTF-8" 1>&2
         fi }
      else
         { if [ "$CHECKCHAR" == "UTF-8 Unicode text" ] ; then
            cleanfestival
            echo "MAIN: Charset changed to ISO8859-15" 1>&2
         fi }
      fi }
      mv "$TXT_FILE.txt" "$FILE_OUT.txt"
   fi }
fi }

TXT_FILE="$TEMP_DIR""OCRResult"
TIF_FILE="$TEMP_DIR""OCRResult".tif

# converting image into TIFF (ImageMagick]
convert "$FILE_PATH" -compress none -density 300x300 "$TIF_FILE" 1>&2

# check for requested ocr engine
{ if [[ "$OCRENG" == "cuneiform" ]] ; then
   # start OCR 
   "$CUNEIFORM" -l "$LANGUAGE" -f smarttext -o "$TXT_FILE".txt "--$EXTRA" "$TIF_FILE"  2> /dev/null
   echo "MAIN: cuneiform -l "$LANGUAGE" -f smarttext used" 1>&2
   # remove strange signs produced by cuneiform
   sed -i -r -e 's/—/-/g; s/â€"/-/g' "$TXT_FILE".txt
   echo "MAIN: cuneiform text cleaned" 1>&2
else
   # tesseract is default, start OCR (tesseract expands output with *.txt)
   tesseract "$TIF_FILE" "$TXT_FILE" -l "$LANGUAGE" 2> /dev/null
   # distinguish between J an I, which are often identical in "Fraktur"
   { if [[ "$LANGUAGE" == "deu-frak" ]]; then
      sed -i -r -e 's/([J])([bcdfghjklmnpqrstvwxyzß])/\I\2/g' "$TXT_FILE".txt
   fi }
   echo "MAIN: tesseract -l "$LANGUAGE" used" 1>&2
fi }
cleanall
#iconv -t UTF-8 "$TXT_FILE.txt" -o "$TXT_FILE.txt"
{ if [[ "$SYNTH" == "festival" ]] ; then
   cleanfestival
   echo "MAIN: text cleaned and recoded for festival" 1>&2
fi }

# add scanned text to FILE_OUT
cat "$TXT_FILE".txt > "$FILE_OUT"

# deletes graphic file after use
rm "$TIF_FILE"

#rename file as $FILE_OUT-read.txt
{ if [ -f "$FILE_OUT-read.txt" ] ; then
   resetname
elif [ -f "$FILE_OUT.txt" ] ; then
   mv "$FILE_OUT.txt" "$FILE_OUT-read.txt"
   resetname
else 
   mv "$FILE_OUT" "$FILE_OUT-read.txt"
   rm -f "$FILE_OUT.txt"
fi }

# Asks for further scans to be added
END=$(DISPLAY=:0.0 yad --geometry -0-0 --title="xsane2speech" --button=Ja:2 --button=Nein:4 --text="Sollen weitere Textpassagen angehängt werden?")
ret=$?
{ if [[ $ret -eq 4 ]] ; then
   SPELLCHECK=$(DISPLAY=:0.0 yad --geometry -0-0 --timeout=10 --title="Rechtschreibung" --button=Ja:2 --button=Nein:4 --text="Rechtschreibprüfung?")
   ret=$?
   { if [[ $ret -eq 2 ]]; then
      gedit "$FILE_OUT-read.txt"
#      gnome-terminal -x hunspell -d de_old "$FILE_OUT-read.txt" #f or old german spelling
#      gnome-terminal -x aspell -c "$FILE_OUT-read.txt"
      echo "MAIN: gedit used for spellchecking" 1>&2 
   fi }
   TEXTREG=$(DISPLAY=:0.0 yad --geometry -0-0 --text="Die Text-Erkennung \nist abgeschlossen!")
   ret=$?
   rm -f "$FILE_OUT-read.txt~"
      { if [[ $ret -eq 1 ]] ; then
      endall
      fi }
   # check if direct tts or saving as mp3 is requested
   { if [[ "$SYNTH" == "festival" ]] ; then
      mp3=$(DISPLAY=:0.0 yad --geometry -0-0 --title="Ausgabe" --button=Abbruch:6 --button="als .mp3":4 --button=direkt:8 --text="Wie soll die Ausgabe erfolgen?")
   else 
      mp3=$(DISPLAY=:0.0 yad --geometry -0-0 --title="Ausgabe" --button=Abbruch:6 --button="als .mp3":4 --button=direkt:2 --button="direkt ohne Wechsel":8 --text="Wie soll die Ausgabe erfolgen?")
   fi }
   ret=$?
   { if [[ $ret -eq 6 ]] ; then
      endall
   elif [[ $ret -eq 2 ]] || [[ $ret -eq 8 ]] ; then
      # Start and options for "SEL"
      $("$SEL" "$SOUND" "$TXT_FILE.txt" "$FILE_OUT-read.txt" "$TEMP_DIR" "$ERRORLOG" "$SYNTH" "$SYNSET" "$SEL" "$MAINPROG") 2> /dev/null & 
      # check for requested synthesizer, eSpeak is default   
      { if [[ "$SYNTH" != "festival" ]] ; then
         echo "MAIN: eSpeak with options $SYNSET used for utterance"  1>&2
         $("$ESPEAK" $SYNSET -f "$FILE_OUT-read.txt" 2> /dev/null)
      else 
         echo "MAIN: festival --language $SYNSET used for utterance" 1>&2
         { if [[ "$SYNSET" == "german" ]] ; then
            # german festival is requested
            $("$FESTIVAL"/festival --heap 10000000 --language "$SYNSET" --tts "$FILE_OUT-read.txt") 2> /dev/null
            # other festival languages used -> festival in "PATH" used
         else
            $(festival --language "$SYNSET" --tts "$FILE_OUT-read.txt")  2> /dev/null
         fi }
      fi }

   endsel

      { if [[ $ret -eq 2 ]] ; then	
         { if [[ "$SYNTH" != "festival" ]] ; then
            VOICE=$(DISPLAY=:0.0 yad --geometry -0-0 --timeout=10 --title="Stimme" --button=Ja:4 --button=Nein:2 --text="Soll eine andere Stimme verwendet werden?")
            ret=$?
            LOOPSET=TESTING
            while [[ $LOOPSET == "TESTING" ]] ; do

               { if [[ $ret -eq 4 ]] ; then
               SYNSET=-v$(DISPLAY=:0.0 yad --geometry -0-0 --title="Spachkürzel" --text "eSpeak-Sprachenkürzel und ggf. Optionen eingeben:" --entry --entry-text="mb-de5 -s145 -g3")
               echo "MAIN: eSpeak with options $SYNSET used for utterance"  1>&2
   $("$SEL" "$SOUND" "$TXT_FILE.txt" "$FILE_OUT-read.txt" "$TEMP_DIR" "$ERRORLOG" "$SYNTH" "$SYNSET" "$SEL" "$MAINPROG") 2> /dev/null & # Options for "SEL"
               $("$ESPEAK" $SYNSET -f "$FILE_OUT-read.txt" 2> /dev/null) 
               endsel
               VOICE2=$(DISPLAY=:0.0 yad --geometry -0-0 --timeout=10 --title="Stimme" --button=Ja:4 --button=Nein:2 --text="Noch eine andere?")
	       ret=$?
               fi }

               { if [[ $ret -eq 2 ]] || [[ $ret -eq 70 ]] ; then
		  LOOPSET=ENDING
		  break
               fi }
            done
        fi }
      fi }

   # check if a recording is wanted after listening
   END2=$(DISPLAY=:0.0 yad --geometry -0-0 --title="mp3" --button=Ja:4 --button=Nein:2 --text="Soll eine .mp3-Datei erstellt werden?")
   ret=$?
   fi }

# set name for dirctory and file to save mp3
   { if [[ $ret -eq 4 ]] ; then 
      FILE=$(DISPLAY=:0.0 yad --file-selection --width 700 --height 500 --save --confirm-overwrite --title "Name und Ort zum Speichern auswählen" --filename="$USER"/"$FILE_OUT.mp3")
      ret=$?
      { if [[ $ret -eq 1 ]] || [[ $ret -eq 70 ]] ; then
         endall
      else
      # check for requested synthesizer
      { if [[ "$SYNTH" == "festival" ]] ; then
         { if [[ "$SYNSET" == "german" ]] ; then  
            # german festival is requested
            $($FESTIVAL/text2wave "$FILE_OUT-read.txt" -o "$TEMP_DIR"temp.wav && lame --tt ${FILE##*/} --ta Hörbuch -b 16 -h -V2 -S "$TEMP_DIR"temp.wav "$FILE") 2> /dev/null
         else
            # other festival languages used
            $(text2wave "$FILE_OUT-read.txt"  -o "$TEMP_DIR"temp.wav && lame --tt ${FILE##*/} --ta Hörbuch -b 16 -h -V2 -S "$TEMP_DIR"temp.wav "$FILE") 1>&2
         fi }

         # remove temporary wave file
         rm "$TEMP_DIR"temp.wav
      # eSpeak is default 
      else 
         $("$ESPEAK" $SYNSET -f "$FILE_OUT-read.txt" --stdout | lame --tt ${FILE##*/} --ta Hörbuch -b 16 -h -V2 -S - "$FILE") 1>&2
      fi }
      $(DISPLAY=:0.0 yad --geometry -0-0 --text="Die mp3-Erstellung \nist abgeschlossen!" --timeout=10) 1>&2
      echo "MAIN: $SYNTH --language $SYNSET used for mp3" 1>&2
      fi }
   fi }
   SAVEFILE=$(yad --geometry -0-0 --timeout=10 --text "Text aufbewahren?" --title "Textspeicherung" --button=Ja:2 --button=Nein:4)
   ret=$?
   { if [[ $ret -eq 2 ]] || [[ $ret -eq 70 ]] ; then
      mv $FILE_OUT-read.txt $FILE_OUT.txt
      echo "MAIN: text saved as $FILE_OUT.txt" 1>&2
   elif [[ $ret -eq 4 ]] ; then
      rm "$FILE_OUT-read.txt" ; echo "MAIN: text $FILE_OUT-read.txt erased" 1>&2
   fi }

fi }

# delete temporary files
rm -f "$TXT_FILE".txt
rm -f /tmp/audiofile_*
rm -f /tmp/FestplayPID.txt
rm -f /tmp/paused.txt
echo "MAIN: END ~~~+++~~~~+++~~~" $(date +%c) 1>&2

#!/bin/bash
#
#    Sound control script for xsane2speech - speech directly from xsane
#    Copyright (C) 2010, 2011, 2013, 2019 Heinrich Schwietering
# 
#    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/>.
#

exec 2>>"${4}""${5}"

SOUND="${1}"
TXT_FILE="${2}"
FILE_OUT="${3}"
TEMP_DIR="${4}"
ERRORLOG="${5}"
SYNTH="${6}"
SYNSEL="${7}"
SEL="${8}"
MAINPROG="${9}"

endall(){
   $(killall -q -s SIGKILL "$SYNTH")
      { if [[ "$SYNTH" == "festival" ]] ; then
         $(killall -q -s SIGKILL "$SOUND")
         { if [[ "$SYNSEL" != "german" ]] ; then
            $(killall -q -s SIGKILL audsp)
            sleep 0.1
            $(killall -q -s SIGKILL "$SOUND")
         fi }
      fi }
   rm -f /tmp/paused.txt
   rm -f /tmp/audiofile_*
   rm -f /tmp/FestplayPID.txt
}

#delay until "$SOUND" is started
{ for i in {1..16}; do
   { if pidof "$SOUND" true; then
      break
   else
      echo "waiting for $SOUND" 1>&2
      sleep 0.5
   fi }
done }

while pidof "$SOUND" true
   do
   action=$(DISPLAY=:0.0 yad --title Wiedergabe --geometry -0-0 --button="Pause/Play":2 --button=Beenden:4 --button=Abbruch:8 )
   ret=$?

   { if [[ $ret -eq 2 ]]; then
      { if [[ "$SOUND" == "gnome-mplayer" ]]; then
         echo $(pgrep -n mplayer) > /tmp/FestplayPID.txt
      else
	 echo $(pgrep -n "$SOUND") > /tmp/FestplayPID.txt
      fi }
      PAPID=$(cat /tmp/FestplayPID.txt)
      echo "SEL: pid $PAPID" 1>&2
      { if [ -f /tmp/paused.txt ] ; then
        sleep 0.1
	$(kill -SIGCONT "$PAPID")  
	rm -f /tmp/paused.txt
	echo "SEL: utterance resumed" 1>&2
      else   
	$(kill -SIGSTOP "$PAPID") 
	echo "SEL: paused" > /tmp/paused.txt
	echo "SEL: utterance paused" 1>&2
      fi }
   elif [[ $ret -eq 4 ]] ; then
      endall
      echo "SEL: utterance canceled" 1>&2
      sleep 0.6
      $(killall -q -s SIGKILL "$SEL")
      break
   elif [[ $ret -eq 8 ]] ; then
      endall

      rm "$TXT_FILE" 1>&2
      rm "$FILE_OUT" 1>&2
      echo "SEL: abborted ~~~+++~~~~+++~~~" $(date +%c) 1>&2
      $(killall -q -s SIGKILL "$MAINPROG")
#      sleep 0.1
      $(killall -q -s SIGKILL yad)
      $(killall -q -s SIGKILL "$SEL")
      break
   fi }
done