ksm_pdf_tool

#!/bin/sh
####
### extrahiert alle moegliche Details/Infos aus einer PDF-Datei
### oder zerlegt die PDF-Datei in ihre einzelnen darin vorhandenen
### Komponenten
### (gedacht ist dieses Script für das KDE-Servicemenu)
### (c) Robert Johnen
###
# fuers Debuggen
#set -x

#--------------------------------------------------------------------------------------#
#------------------------------- Variablendeklarationen -------------------------------#
#--------------------------------------------------------------------------------------#
IFS=$'\t\n'                          # Trennzeichen auf TAB und NEWLINE alleine
SCRIPTNAME="${0##*/}"                # Scriptname feststellen
KURZNAME="${SCRIPTNAME%%.*}"         # Scriptname ohne Erweiterung
ARGS=($@)                            # Alle Kommandozeilenparameter in ein Array einlesen
ARGSCOUNT=$#                         # Anzahl der Kommandozeilenparameter
ERRCODE=0                            # Fehlercode auf Nullwert

# Verzeichnisstruktur zur Dateiablage bei $~> ${SCRIPTNAME} ALLES
# Da ich die Verzeichnisstruktur auch in Scribus nutze,
# habe ich diese so 1:1 uebernommen. Die PDF, wenn ich sie
# zur Fehleranalyse auseinandernehme, wird von mir mit Scribus
# wieder zusammengebastelt. Diese Variablen werden nur
# genutzt, wenn die Verzeichnisse mit mkdir erstellt werden muessen
# sollte das Vereichnis ~/Oeffentlich/Vorlagen/Scribus/NEU existieren,
# wird von dort der Verzeichnisbaum per cp -rf kopiert
# sollte dieser Verzeichnisbaum nicht mit den Variablen uebereinstimmen,
# muessen die Variablen an den dort liegenden Verzeichnisbaum angepasst werden.
# !!!!! Achtung: Leerzeichen im Verzeichnisnamen muessen maskiert werden
DIRAUDIO="Audiodaten"                # Verzeichnis für Audiodaten
DIRMIDI="${DIRAUDIO}/Midi"           # Verzeichnis Mididateien
DIRSNDFONT="${DIRAUDIO}/SoundFonts"  # Verzeichnis für SoundFonts
DIROUTPUT="Ausgabe"                  # Verzeichnis für PDF-Ausgaben
DIRBCKUP="Backup"                    # Verzeichnis für alte Versionen
DIRBCKORIG="${DIRBCKUP}/Rohdaten"    # Verzeichnis für Originaldaten
DIRIMGS="Bilddaten"                  # Verzeichnis für Bilder
DIRANIM="${DIRIMGS}/Animationen"     # Verzeichnis für Animationsdaten
DIRVECTOR="${DIRIMGS}/Grafiken"      # Verzeichnis für Vektordaten
DIRPALETTES="${DIRIMGS}/Paletten"    # Verzeichnis für Farbpaletten
DIRPROFILES="${DIRIMGS}/Profile"     # Verzeichnis für Farbprofile
DIRVIDEOS="${DIRIMGS}/Videos"        # Verzeichnis für Videodaten
DIRATTACH="Dateianhaenge"            # Verzeichnis für Dateianhänge
DIRSERIAL="Seriendruckdaten"         # Verzeichnis für Seriendruckdaten
DIRTXT="Textdaten"                   # Verzeichnis für Texte
DIRHTML="${DIRTXT}/HTML"             # Verzeichnis für HTML/XML-Dateien
DIRFONTS="${DIRTXT}/Schriften"       # Verzeichnis für Fontdateien
DIRSTYLES="${DIRTXT}/Stile"          # Verzeichnis für Stilvorlagen
DIRGRIDS="${DIRTXT}/Tabellen"        # Verzeichnis für Tabellen

# mit cp -rf die Verzeichnisstruktur aus einer Vorlage kopieren, dann
# aus dieser Variable
DIRSTRUCT="${HOME}/Oeffentlich/Vorlagen/scribus/NEU"

# Standardauflösung für Bilder in dpi
PARAM3=150
# Standardsprache für Texterkennung
PARAM4="deu"

#--------------------------------------------------------------------------------------#
#------------------------------------ Includefiles ------------------------------------#
#--------------------------------------------------------------------------------------#
#
# teste ob alle benötigten Programme installiert sind
which realpath sort uniq basename dirname tr grep awk pdfinfo oyranos-icc pdffonts pdfimages pdfdetach pdfseparate pdftops pdftocairo pdftohtml pdftotext pdftoppm pdftk pdfjam cfftot1 mutool tesseract qpdf convert > /dev/null


#--------------------------------------------------------------------------------------#
#------------------------------- Funktionsdeklarationen -------------------------------#
#--------------------------------------------------------------------------------------#
#

#----------------- Funktion cleanup
# Errorhandler bei Scriptabbruch
#
cleanup () {
  # hier kann definiert werden, was alles
  # aufgeaeumt werden muss bevor das Script
  # wirklich abgebrochen bzw. beendet wird. 
  : # tue nichts, aber mit einem exitcode von 0, was aber bei
    # einem Abbruch den Exitcodes des Scriptes nicht ändert (!) ;-)
  # pause # warte auf einen Tastendruck
  }

trap cleanup exit

pause () {
# wartet auf beliebigen Tastendruck bevor es weiter geht
  read -s -n 1 -p "weiter mit beliebiger Taste "
  }


hilfe () {
# Ausgabe der Hilfe
  cat << EOF

  Aufruf:
  user@linux:~> ${SCRIPTNAME} <PDF-Dokument> PARAMETER1 PARAMETER2 PARAMETER3

  <PDF-Dokument> --> eine PDF-Datei beliebigen Formates / beliebiger Version

  moegliche Werte PARAMETER1:
  INFO     --> 	ermittelt soviele Informationen wie möglich schreibt
         		sie in Dateiname.pdfinfo
  TEXTEXT  --> 	extrahiert den in der PDF-Datei enthaltenen Text
		        in Dateiname.txt
	        Zur Texterkennung per OCR muss mindestens PARAMETER2
	        angegeben werden:
                    wird PARAMETER2 angegeben und ist eine natürliche
                    Zahl zwischen 150 und 600 wird er als dpi-Angabe für die
                    Texterkennung per OCR interpretiert.
                    Sollte PARAMETER2 keine nat. Zahl sein, wird er als
                    Sprachangabe für die Texterkennung per OCR
                    interpretiert und Standardauflösung (150dpi) gesetzt.
                    Wird PARAMETER3 angegeben, wird dieser als
                    Sprachangabe für die Texterkennung genutzt.
                    Ansonsten wird als Standardsprache deutsch (deu) genutzt
  IMGEXT   --> 	extrahiert alle im PDF-Dokument vorhandenen Bilder in
                Originalauflösung nach dem Schema:
	                    Dateiname-Seitenzahl-Bildnummer.[png|tiff|jpg|jp2|ppm]
	        und extrahiert aus den Bildern vorhandene Farbprofile
  SEPPAGES --> 	Erstellt aus jeder Seite der PDF-Datei ein eigenes PDF-Dokument
                nach dem Schema Dateiname-Seitenzahl.pdf
  DETACH   --> 	extrahiert alle Dateianhänge (falls denn welche existieren)
  ATTACH   --> 	hängt eine Datei als Attachment an die PDF-Datei an
                (das Original der angehaengten Datei wird geloescht)
  HTML     --> 	Erstellt aus der PDF-Datei ein HTML-Dokument (nicht schoen)
  PS       --> 	Erstellt aus der PDF-Datei eine PostScript-Datei
  ALLES    --> 	Alles was INFO, TEXTEXT IMGEXT, SEPPAGES, DETACH, HTML und PS
	        machen. Des weiteren werden vorhandene Schriftdaten extrahiert,
	        Einzelseiten in SVG- und PostScript-Dateien gewandelt, damit
	        evtl. vorhandene Vektordaten daraus haendisch extrahiert werden
	        koennen und alle Dateien in entsprechende Unterverzeichnisse
	        einsortiert.
  PDFA1B   --> 	Erstellt eine Datei im Format PDF-A-1b
  ROTL     --> 	rotiert alle Seiten um 90° gegen den Uhrzeigersinn
                im Verhaeltnis zur Ausrichtung der Originaldatei
  ROTR     --> 	rotiert alle Seiten um 90° im Uhrzeigersinn
                im Verhaeltnis zur Ausrichtung der Originaldatei
  ROTD     --> 	rotiert alle Seiten um 180°
                im Verhaeltnis zur Ausrichtung der Originaldatei
  REVERSE  -->	kehrt die Seitenreihenfolge um
  M2S      --> 	erstelle PDF mit 2 Seiten pro Blatt
  M4S      --> 	erstelle PDF mit 4 Seiten pro Blatt
  ALLFEAT  --> 	hebt alle Restriktionen innerhalb der PDF auf
                (Drucken erlaubt, Kommentiern erlaubt, usw.)
  CONVPNG  -->	konvertiert alle Seiten zu PNG-Pixelgrafiken mit der
                in PARAMETER2 angegebenen Aufloseung. Sollte PARAMETER2
                keine nat. Zahl zwischen 150 und 600 sein, wird die
                Standardaufloesung von 150dpi gesetzt
  CONVJPG  -->	konvertiert alle Seiten zu JPG-Pixelgrafiken  mit der
                in PARAMETER2 angegebenen Aufloseung. Sollte PARAMETER2
                keine nat. Zahl zwischen 150 und 600 sein, wird die
                Standardaufloesung von 150dpi gesetzt

  Benoetigt werden folgende Programme:
  realpath, basename, dirname, tr, grep, awk, sort,
  uniq, pdfinfo, oyranos-icc, pdffonts, pdfimages, pdfdetach,
  pdfseparate, pdftops, pdftocairo, pdftohtml, pdftotext, pdftoppm, pdftk,
  pdfjam, cfftot1, mutool, tesseract, qpdf, convert

EOF
  }
  
#
#--------------------------------------------------------------------------------------#
#--------------------------- bedingte Variablendeklarationen --------------------------#
#--------------------------------------------------------------------------------------#
#
if [ -e "${1}" ] # wenn Datei existiert
  then
  if file "${1}" | grep "PDF document" # und Datei ist auch ein PDF-Dokument
    then
    # Parameter mit echtem Pfad der Datei speichern
    DATEI=$(realpath "${1}")
    # Dateiname mit Erweiterung ermitteln
    DNAME=$(basename "${DATEI}")
    # Reinen Pfad extrahieren
    PFAD=$(dirname "${DATEI}")
    # Dateiname ohnen Erweiterung
    DNAMENOEXT="${DNAME%.*}"
    # nur die Extension
    DEXT="${DNAME##.*}"
    # Speicherpfad der neuen Dateien
    NPFAD="${PFAD}/${DNAMENOEXT}"
    # Was soll mit der Datei gemacht werden
    # und alles in GROSSBUCHSTABEN
#    TOOL=$(echo "${2}" | tr '[:lower:]' '[:upper:]') # das hier ist auf jeden Fall portabel
    TOOL="${2^^}" # das hier ist ein Bash-Konstrukt um alle Buchstaben in Versalien zu wandeln
    # wenn 3. Parameter vorhanden und natürliche Zahl
    # zwischen 149 und 601, verändere PARAM3 auf diese Zahl
    # wenn keine nat. Zahl, dann speichere den Inhalt in PARAM4
    [ $ARGSCOUNT -gt 2 ] && [ "${3}" =~ ^[0-9]+$ ] && [ $3 -gt 149 ] && [ $3 -lt 601 ] && PARAM3=$3 || PARAM4="${3}"
    # ist da noch ein vierter Parameter, nimm den für PARAM4
    [ $ARGSCOUNT -gt 3 ] && PARAM4="${4}"
    # Umrechnungsfaktor DTP-Punkt im mm für die Ausgaben mit awk der Seitenformate
    UF=0.3528
    # Formatbreite feststellen
    BREITE=$(pdfinfo "${DATEI}" | grep "Page size" | awk -v f=$UF '{printf "%5.0f",$3*f}')
    # Formathöhe feststellen
    HOEHE=$(pdfinfo "${DATEI}" | grep "Page size" | awk -v f=$UF '{printf "%5.0f",$5*f}')
    # HF oder QF
    # TODO : HF und QF müssen sich eigentlich um 2cm unterscheiden,
    # sonst ist es per Definition ein quadratisches Format,
    [ $BREITE -gt $HOEHE ] && QF=1 || QF=0 # Datei ist Querformat oder quadratisch bzw. Hochformat
    # dann Variablendefinition folgendermaßen ändern:
    # quadratisches Format QF=0, Querformat QF=1, Hochformat QF=2
    # in den Pfad der Originaldatei wechseln
    cd "${PFAD}"
    else
    echo "Angegebene Datei <${1}> ist kein PDF-Dokument"
    TOOL="-h"
    fi
  else
  echo "Angegebene Datei <${1}> existiert nicht"
  TOOL="-h"
  fi
#
#--------------------------------------------------------------------------------------#
#------------------------------------ Hauptprogramm -----------------------------------#
#--------------------------------------------------------------------------------------#
# je nach Taetigkeit anderes Feld ausfuehren
case ${TOOL} in
ALLES) # mache alles, was du unten auch machen kannst, aber in ein eigens Verzeichnis
  # erstelle Verzeichnisstruktur entweder mit cp -rf aus Verzeichnisbaum oder mit mkdir -p wenn Vorlagenverzeichnis nicht existent
  [ -d "${DIRSTRUCT}" ] && { cp -rf --  "${DIRSTRUCT}" "${DNAMENOEXT}"; rm -- "${DNAMENOEXT}"/Vorlage.sla; } || mkdir -p -- "${DIRMIDI}" "${DIRSNDFONT}" "${DIROUTPUT}" "${DIRBCKORIG}" "${DIRANIM}" "${DIRVECTOR}" "${DIRPALETTES}" "${DIRPROFILES}" "${DIRVIDEOS}" "${DIRATTACH}" "${DIRSERIAL}" "${DIRHTML}" "${DIRFONTS}" "${DIRSTYLES}" "${DIRGRIDS}"
  # wechsele dann hinein
  cd "${DNAMENOEXT}"
  # und kopiere die Originaldatei hinein
  cp -- "../${DNAME}" "${DNAME}"
  # separiere Einzelseiten als PDFs erstellen
  ${SCRIPTNAME} "${DNAME}" SEPPAGES
  # aus jeder Einzelseite
  for i in *-????.pdf
    do
    # den Text extrahieren
    ${SCRIPTNAME} "${i}" TEXTEXT
    # in Unterverzeichnis verschieben
    mv -- *.txt "${DIRTXT}/"
    # eine SVG-Datei erstellen
    pdftocairo -svg "${i}" "${i%.*}.svg"
    # in Unterverzeichnis verschieben
    mv -- *.svg "${DIRVECTOR}/"
    # eine PostScript-Datei erstellen
    pdftops "${i}"
    # in Unterverzeichnis verschieben
    mv -- *.ps "${DIRVECTOR}/"
    # Einzelseite in Backupverzeichnis verschieben
    mv -- "${i}" "${DIRBCKUP}/"
    done

  # Gesamttext aus Originaldatei extrahieren
  ${SCRIPTNAME} "${DNAME}" TEXTEXT
  # und extrahierten Gesamttext in Unterverzeichnis verschieben
  mv -- *.txt "${DIRTXT}/"

  #TODO: Tabellen aus PDF extrahieren siehe TEXTEXT)

  # extrahiere alle Bilder
  ${SCRIPTNAME} "${DNAME}" IMGEXT
  # mit jedem Bild
  for i in $(ls -p --hide=*.pdf | grep -v '/$')
    do
    # vorhandenes Profil extrahieren
    oyranos-icc -f icc -i "${i}" > "${i%.*}.profile"
    # und dieses in Profilordner verschieben
    mv -- "${i%.*}.profile" "${DIRPROFILES}/"
    # verarbeitetes Bild in Bildordner verschieben
    mv -- "${i}" "${DIRIMGS}/"
    done

  # Wandle gesamte PDF in HTML um
  pdftohtml "${DNAME}"
  # und verschiebe das ganze HTML-Gedoens in Unterverzeichnis
  for i in $(ls -p --hide=*.pdf | grep -v '/$'); do mv -- "${i}" "${DIRHTML}/"; done

  # Schriften extrahieren
  # extrahiere alles --> ist die einzige Methode, die ich kenne um
  # auch die eingebetteten Schriften aus der PDF raus zu bekommen
  mutool extract "${DNAME}"
  # CFF-Daten von Type1-Fonts in PFBinary umwandeln
  # Kerning-Daten aus *.PFM fehlen, aber mehr gibts nicht
  # kann man zwar selbst generieren, aber die haben mit
  # ordentlichem Kerning nix zu tun
  # dafür kann ich sehen, welche Zeichen in der Datei enthalten sind
  for i in *.cff; do cfftot1 "${i}" "${i%.*}.pfb"; done
  # Schriftdateien in Unterverzeichnis verschieben (das ist alles,
  # was mir an Font-Dateien einfällt, was man einbetten könnte)
  # da bin ich mir aber nicht ganz sicher
  for i in *.?tf *.odttf *.cff *.pf? *.tfm *.fon *.a?f* *.afm *.dfont *.fnt *.lwfn; do mv -- "${i}" "${DIRFONTS}/"; done
  # alles andere bis auf die Originalpdf wieder löschen
  for i in $(ls -p --hide=*.pdf | grep -v '/$'); do rm -- "${i}"; done

  # extrahiere alle Dateianhänge
  ${SCRIPTNAME} "${DNAME}" DETACH
  # und verschiebe alles was hier jetzt liegt außer der PDF in Unterverzeichnis
  for i in $(ls -p --hide=*.pdf | grep -v '/$'); do mv -- "${i}" "${DIRATTACH}/"; done

  # allgemeine Informationen aus der PDF extrahieren
  ${SCRIPTNAME} "${DNAME}" INFO
  # Originaldatei in PostScript umwandeln
  pdftops "${DNAME}"
  # folgende Dateien befinden sich jetzt im neu angelegten Verzeichnis:
  # Original-PDF, PS-Datei aus Original-PDF, extrahierte Infos (.pdfinfo)
  # Verschiebe die ins Unterverzeichnis
  mv -- *.* "${DIRBCKORIG}/"
  ;;

INFO) # extrahiert alle Informationen aus der PDF-Datei über:
  # eingebettete oder genutzte oder auch substituierte Schriften und Subsets,
  # eingebettete Bilder,
  # eingebettete Dateien,
  # angehängte Dateien
  # allgemeine Informationen
  # Maße aller Seiten von Media-, Bleed-, Trim-, (Trim=Crop-,) (Art- oder Bounding-) Box,
  # eingebettetes JavaScript
  # enthaltene Strukturinformationen ohne Textdaten

  # Name für die Info.Datei festlegen
  TMPDATEI="${DATEI}info"
  # sind Tags in der Datei?
  GETAGGT=$(pdfinfo "${DATEI}" | grep Tag | awk '{ print $2 }')
  # ist JavaScript drin?
  JAVASCRIPT=$(pdfinfo "${DATEI}" | grep Java | awk '{ print $2 }')
  # wieviele Seiten hat die Datei
  LSEITE=$(pdfinfo "${DATEI}" | grep Pages | awk '{ print $2 }')
  echo "Informationen zu --- <${DATEI}> ---" > "${TMPDATEI}"
  echo "." >> "${TMPDATEI}"

  # wenn Schriften genutzt wurden und in irgendeiner Art in der Datei eingebunden sind
  # oder vergessen wurden einzubetten und substituiert werden, dann zeige diese
  if pdffonts "${DATEI}" | grep -E '.*(yes|no).*' > /dev/null
    then
    echo "-------------------- genutzte Schriften --------------------" >> "${TMPDATEI}"
    pdffonts "${DATEI}" >> "${TMPDATEI}"
    echo "." >> "${TMPDATEI}"
    echo "------------------ substituierte Schriften -----------------" >> "${TMPDATEI}"
    pdffonts -subst "${DATEI}" >> "${TMPDATEI}"
    echo "." >> "${TMPDATEI}"
    fi

  # Listet alle enthaltenen Bilder und Masken mit Rendering intent, Auflösung und Pixelzahl auf
  # und auf welcher Seite sie sind, aber nur wenn auch welche drin sind...
  if pdfimages -list "${DATEI}" | grep 0 > /dev/null
    then
    echo "--------------------- enthaltene Bilder --------------------" >> "${TMPDATEI}"
    pdfimages -list "${DATEI}" >> "${TMPDATEI}"
    echo "." >> "${TMPDATEI}"
    fi

  # Definierte Sonderfarben (geht auch aus der PDF-Datei mit grep im Binarymodus,
  # ist aber einfacher aus der PostScript-Datei zu holen
  # TODO: findet nicht wirklich alles, aber ist ein Anfang
  pdftops "${DATEI}" /tmp/"${DNAMENOEXT}".ps
  if grep Separation /tmp/"${DNAMENOEXT}".ps > /dev/null
    then
    echo "------------------------ Sonderfarben ----------------------" >> "${TMPDATEI}"
    grep Separation /tmp/"${DNAMENOEXT}".ps | awk '{printf "%-8s %-4s %-3s %s\n",$2,$3,$4,$5}' | sed 's/[\(\)\[\/\]//g' | sort | uniq >> "${TMPDATEI}"
    echo "." >> "${TMPDATEI}"
    fi
  rm -- /tmp/"${DNAMENOEXT}".ps

  # alle enthaltenen, angehängten Dateien auflisten
  echo "-------------------- enthaltene Dateien --------------------" >> "${TMPDATEI}"
  pdfdetach -list "${DATEI}" >> "${TMPDATEI}"
  echo "." >> "${TMPDATEI}"

  # liste allgemeine Informationen auf
  echo "-------------------- Allgemeine Infos ----------------------" >> "${TMPDATEI}"
  # Ersteller, genutztes Programm, Farbmanagement-Bibliotheken, PDF-Version, usw.
  pdfinfo "${DATEI}" >> "${TMPDATEI}"  # wenn es nur die PDF-Version sein müsste, dann würde file "${DATEI}" genügen
  # PDF/X-Konformität feststellen
  PDFX=$(pdfinfo -meta "${DATEI}" | grep pdfx | cut -d'>' -f2 | cut -d'<' -f1 | tr '@\n' ' ' | sed 's/\ \ /\ /')
  echo "PDF-X ID / Version / Conformance:${PDFX}" >> "${TMPDATEI}"
  # Definierte Darstellungsklasse
  PDFX=$(pdfinfo -meta "${DATEI}" | grep endition | cut -d'>' -f2 | cut -d'<' -f1 | tr '@\n' ' ' | sed 's/\ \ /\ /')
  echo "Rendition-Class: ${PDFX}" >> "${TMPDATEI}"
  echo "." >> "${TMPDATEI}"
  # Nachfolgende drei Positionen von podofopdfinfo mit grep -a  ersetzt, da podofopdfinfo momentan nicht maintained ist
  # und daher die Uebernahme in Distributionen nicht empfohlen wird. Ob da aber alles genauso rauskommt wie es soll habe
  # ich noch nicht vollstaendig geprueft Aber Trapping funktioniert.
  # Trapping kan sein False, True, wenn nicht definiert oder angegeben, dann keine PDF-X[34]-Konformitaet
  # Wurde die Datei mit ÜberfÜllungen erstellt oder ohne
  #podofopdfinfo C "${DATEI}" | grep Trapped | tr -d '\t' >> "${TMPDATEI}"
  grep -a "/Trapped" "${DATEI}" | tr -d '/' | sed -e "s/ /:\t/g" >> "${TMPDATEI}"
  # | awk '{printf "%-31s %s\n",$1,$2}' >> "${TMPDATEI}"
  # Liste auf, was mit der Datei alles gemacht werden darf
  # Kommentieren, drucken, ansehen, usw
  #podofopdfinfo D "${DATEI}" | grep Allowed | tr -d '\t' >> "${TMPDATEI}"
  grep -a " /Allowed" "${DATEI}" | tr -d '/' | sed -e "s/ /:\t/g" >> "${TMPDATEI}"
  # | awk 'NR==1 {printf "%s %-22s %s\n",$1,$2,$3} NR==2 {printf "%s %-18s %s\n",$1,$2,$3} NR==3 {printf "%s %-20s %s\n",$1,$2,$3} NR==4 {printf "%s %s %-4s %s\n",$1,$2,$3,$4} NR==5 {printf "%s %-21s %s\n",$1,$2,$3} NR==6 {printf "%s %-17s %s\n",$1,$2,$3} NR==7 {printf "%s %s %-13s %s\n",$1,$2,$3,$4} NR==8 {printf "%s %s %s %-12s %s\n",$1,$2,$3,$4,$5}' >> "${TMPDATEI}"
  #podofopdfinfo D "${DATEI}" | grep Enabled | tr -d '\t' >> "${TMPDATEI}"
  grep -a " /Enabled" "${DATEI}" | tr -d '/' | sed -e "s/ /:\t/g" >> "${TMPDATEI}"
  echo "." >> "${TMPDATEI}"
  # Dokumentenformat umgerechnet von pts in mm
  pdfinfo -box "${DATEI}" | grep "Page size:" | awk -v f=$UF '{printf "Format: %5.0f x %5.0f mm %s\n",$3*f,$5*f,$7}' >> "${TMPDATEI}"
  # Alle enthaltenen Boxen mit Massen zum Nullpunkt (linke obere Ecke des Dokumentes)
  pdfinfo -box "${DATEI}" | grep Box | awk -v f=$UF '{printf "%-12s %8.0f %8.0f %8.0f %8.0f    --> %5.0f x %5.0f\n",$1,$2*f,$3*f,$4*f,$5*f,($4-$2)*f,($5-$3)*f}' >> "${TMPDATEI}"
  # und jetzt im pts
  pdfinfo -box "${DATEI}" | grep "Page size:" >> "${TMPDATEI}"
  pdfinfo -box "${DATEI}" | grep Box >> "${TMPDATEI}"
  echo "." >> "${TMPDATEI}"
  echo "Umrechnungsfaktor: pts x $UF = mm" >> "${TMPDATEI}"
  echo "alle Ergebnisse in mm sind gerundet" >> "${TMPDATEI}"
  echo "." >> "${TMPDATEI}"

  # Analyse der Einzelseiten
  echo "----------- Informationen zu den einzelnen Seiten ----------" >> "${TMPDATEI}"
  for i in $( seq 1 ${LSEITE} )
    do
    # Ausrichtung der Seite (Rotationsrichtung)
    pdfinfo -f "${i}" -l "${i}" -box "${DATEI}" | grep Page.*rot >> "${TMPDATEI}"
    # Seitenformat in mm
    pdfinfo -f "${i}" -l "${i}" -box "${DATEI}" | grep Page.*size | awk -v f=$UF '{printf "%s %4.0f size: %4.0f x %4.0f mm %s\n",$1,$2,$4*f,$6*f,$8}' >> "${TMPDATEI}"
    # Boxen der Seite mit Maßen zum Nullpunkt (linke obere Ecke der Seite)
    pdfinfo -f "${i}" -l "${i}" -box "${DATEI}" | grep Box | awk -v f=$UF '{printf "%s %4.0f %-9s %5.0f %8.0f %8.0f %8.0f  --> %5.0f x %5.0f\n",$1,$2,$3,$4*f,$5*f,$6*f,$7*f,($6-$4)*f,($7-$5)*f }' >> "${TMPDATEI}"
    # und jetzt in pts
    pdfinfo -f "${i}" -l "${i}" -box "${DATEI}" | grep Page.*size >> "${TMPDATEI}"
    pdfinfo -f "${i}" -l "${i}" -box "${DATEI}" | grep Box >> "${TMPDATEI}"
    echo "." >> "${TMPDATEI}"
    done

  # wurde JavaScript genutzt
  if [ "${JAVASCRIPT}" != "no" ]
    then
    echo "------------------ enthaltenes JavaScript ------------------" >> "${TMPDATEI}"
    # dann hole die Scripte raus
    pdfinfo -js "${DATEI}" >> "${TMPDATEI}"
    echo "." >> "${TMPDATEI}"
    fi

  # gesonderte Strukturinformationen in Form von Tags vorhanden, dann raus damit
  if [ "${GETAGGT}" != "no" ]
    then
    echo "------ strukturelle Informationen und enthaltener Text -----" >> "${TMPDATEI}"
    pdfinfo -struct "${DATEI}" >> "${TMPDATEI}"
    fi
  ;;

TEXTEXT) # extrahiert den Textteil der PDF-Datei
  pdftotext "${DATEI}" "${PFAD}/${DNAMENOEXT}.txt"
  # OCR nur bei Angabe von mindestens 3 Parametern
  [ $ARGSCOUNT -gt 2 ] && pdftoppm -r "${PARAM3}" "${DATEI}" | tesseract stdin "${PFAD}/${DNAMENOEXT}-OCR" -l "${PARAM4}"
  ;;

IMGEXT) # extrahiert alle Bilder aus der PDF-Datei
  pdfimages -all -p "${DATEI}" "${DNAMENOEXT}"
  ;;

SEPPAGES) # zerlegt mehrseitige PDF-Dateien in Einzelseiten
  pdfseparate "${DATEI}" "${PFAD}/${DNAMENOEXT}-Seite-"%04d.pdf
  ;;

COLSEP)
  gs -dSAFER -dBATCH -dNOPAUSE -sDEVICE=tiffsep -r300 -sOutputFile="${DNAMENOEXT}".cmyk. "${DATEI}"
  for i in *.cmyk.*
    do 
    tiff2pdf "${i}" -o "${i}.pdf" && rm -- "${i}"
    done
  pdftk "${DATEI}" "${DNAMENOEXT}.cmyk."*.tif.pdf cat output "${DNAMENOEXT}-CMYK.pdf" && rm -- *.cmyk.*
  ;;
  
DETACH) # extrahiert alle angehängten/eingebetteten Dateien
  pdfdetach -saveall "${DATEI}"
  ;;

ATTACH) # bettet Datei(en) in eine PDF-Datei ein
  pdftk "${DATEI}" attach_file "${PARAM4}" output "${PFAD}/${DNAMENOEXT}-att.pdf" && mv -- "${PFAD}/${DNAMENOEXT}-att.pdf" "${DATEI}" && rm -- "${PARAM4}"
  ;;

HTML) # wandelt die PDF-Datei in ein HTML-Archiv um
  pdftohtml "${DATEI}"
  ;;

PS) # wandelt die PDF-Datei in eine PostScript-Datei um
  pdftops "${DATEI}"
  ;;

PDFA1B) # erstellt neue PDF-Datei in PDF-A-1b-Format
  # dazu erst mal eine PostScript-Datei erstellen
  pdftops "${DATEI}"
  # die PostScript-Datei dann als PDFA1B erstellen
  gs -dPDFA -dBATCH -dNOPAUSE -dNOOUTERSAVE -dUseCIEColor -sProcessColorModel=DeviceCMYK -sDEVICE=pdfwrite -sPDFACompatibilityPolicy=1 -sOutputFile="${DNAMENOEXT}-A1b.pdf" "${DNAMENOEXT}".ps
  # PostScript-Datei wieder loeschen
  rm -rf -- "${DNAMENOEXT}".ps
  ;;

ROTL) # alle Seiten um 90 Grad gegen den UZS drehen
  pdftk "${DATEI}" cat 1-endleft output "${DNAMENOEXT}"-ROT90.pdf
  ;;

ROTR) # alle Seiten um 90 Grad im UZS drehen
  pdftk "${DATEI}" cat 1-endright output "${DNAMENOEXT}"-ROT270.pdf
  ;;

ROTD) # alle Seiten um 180 Grad drehen
  pdftk "${DATEI}" cat 1-enddown output "${DNAMENOEXT}"-ROT180.pdf
  ;;

REVERSE) # Seitenreihenfolge umkehren
  pdftk "${DATEI}" cat r1-rend output  "${DNAMENOEXT}"-REVERSE.pdf
  ;;

M2S) # erstelle PDF mit 2 Seiten pro Blatt
  if [ $QF -eq 1 ] # ist die Datei ein Querformat
    then
    # dann erst mal alle Seiten 90° nach links rotieren
    ${SCRIPTNAME} "${DATEI}" ROTL
    # jeweils 2 Seiten zusammenbasteln aus der rotierten Datei und in eine neue Datei schreiben
    pdfjam --suffix 2pg --nup 2x1 --landscape --frame true "${DNAMENOEXT}"-ROTL.pdf
    # erste rotierte Datei löschen
    rm -rf -- "${DNAMENOEXT}"-ROTL.pdf
    # die zweiseitige Datei jetzt wieder 90° nach rechts rotieren
    ${SCRIPTNAME} "${DNAMENOEXT}"-ROTL-2pg.pdf ROTR
    # lösche die linksrotierte Datei
    rm -rf -- "${DNAMENOEXT}"-ROTL-2pg.pdf
    # benenne die entstandene zweiseitige Datei um
    mv -- "${DNAMENOEXT}"-ROTL-2pg-ROTR.pdf "${DNAMENOEXT}"-2pg.pdf
    # ich weiß nicht mehr warum, aber wenn ich das nicht bzw. auf andere Weise mache,
    # hat es beim Querformat jedes mal wie Scheiße ausgesehen
    else
    # Hochformat braucht den Quatsch oben nicht
    pdfjam --suffix 2pg --nup 2x1 --landscape --frame true "${DATEI}"
    fi
  ;;

M4S) # erstelle PDF mit 4 Seiten pro Blatt
  # auch hier muss ich zwischen Hoch und Querformat unterscheiden
  # kann mir aber den Quatsch oben aus dem QF sparen
  [ $QF -eq 1 ] && pdfjam --suffix 4pg --nup 2x2 --landscape --frame true "${DATEI}" || pdfjam --suffix 4pg --nup 2x2 --frame true "${DATEI}"
  ;;

ALLFEAT) # Alle Features der PDF-Datei einschalten
  # erstellt eine Datei ohne Owner-Passwort --> klappt nur, wenn kein User-Passwort gesetzt
  qpdf --decrypt "${DATEI}" "${DNAMENOEXT}"-NOPWD.pdf
  # jetzt bastele daraus eine PDF, mit der alles erlaubt ist
  pdftk "${DNAMENOEXT}"-NOPWD.pdf output "${DNAMENOEXT}"-AFA.pdf allow AllFeatures && rm -rf -- "${DNAMENOEXT}"-NOPWD.pdf
  # alternative:
  # gs -sPDFPasword=$PASS -q -dNOPAUSE -dBATCH -dSAFER -sDEVICE=pdfwrite -r300 -sOutputFile="${DNAMENOEXT}"-AFA.pdf -c .setpdfwrite -f "${DATEI}"
  #
  ;;

CONVPNG) # konvertiert alle Seiten zu PNG-Pixelgrafik mit der angegebenen Aufloesung
  convert -density "${PARAM3}" "${DATEI}" -quality 100 "${DNAMENOEXT}".png
  ;;

CONVJPG) # konvertiert alle Seiten zu JPG-Pixelgrafik mit der angegebenen Aufloesung
  convert -density "${PARAM3}" "${DATEI}" -quality 100 "${DNAMENOEXT}".jpg
  ;;

*) # tue nichts ;-)
  hilfe
  ;;

esac

exit $E_OK