#!/bin/bash

############# COMMAND CALLING ############################################

_Vtest () {
  echo "##### _Vtest called"
  # Create Directories, if they don't exist
  echo "WARNING: Vtest not yet implemented"
}

_Vextract () {
  echo "##### Vextract called"
  # Create Directories, if they don't exist
  _Vdirectories
  IMOPTIONS=""
  GMICOPTIONS=""
  FFOPTIONS=""
  GMOPTIONS=""
  DCRAWOPTIONS=""


  SRC=$VIDEOSOURCE
  SCAT=$VIDEOCAT
  STAGE=ffm

  echo "MISSING: extract audio"

  if [ -f $AUDIOFILE ]; then
     echo "Skipping Audio Extraction, because $AUDIOFILE exists."
  else
     echo "Audio Extraction:"
     if [ $DURATIONOPTS = 1 ]; then
       if [ $VIDEOCAT = dng ]; then
          cp -v $VIDEOSOURCE/`basename $VIDEOSOURCE`.wav $AUDIOFILE
       else
          set -x
          ffmpeg -y -loglevel $LOGLEVELV -r $FRAMERATE -i $VIDEOSOURCE -vn \
                 -c:a copy $AUDIOFILE
          set +x
       fi
     else
       echo "Audio file extraction with time extract not yet implemented"
       #ffmpeg -y -loglevel $LOGLEVELV -r $FRAMERATE -i $VIDEOSOURCE -vn \
       #      -af "aselect=$DURATIONOPTS,asetpts=N/($FRAMERATE*TB)" \
       #      -c:a pcm_s24le $AUDIOFILE
     fi
  fi

  if [ $VIDEOCAT = dng ]; then
   ( 
    echo @dcraw
    echo '-v'
    _VreadSection EXTRACT
    echo @im
    echo ADDLUT
   ) | _Vinterpreter extract        # CAREFUL; Because of subshell in _Vinterpreter Variables don't get exported from there
                                    # therefore it must be the last command!!!
   _VclearTmp
  else
   ( 
    echo @ffm
    echo copy
    _VreadSection EXTRACT
    echo @im
    echo ADDLUT
   ) | _Vinterpreter extract        # CAREFUL; Because of subshell in _Vinterpreter Variables don't get exported from there
                                    # therefore it must be the last command!!!
   _VclearTmp
  fi



# DCRAWOPTIONS="-W +M -q 3 -H 0 -n 200 -b 1 -o 0"
# dcraw -c -T -6 $DCRAWOPTIONS $ff > $PREVIEWDIR/$VIDEONAME/rawtif/`printf %04d $fc`.tif

}


_Vhisto () {
  echo "##### Vhisto called"
  _Vdirectories
  
  IMOPTIONS=""
  GMICOPTIONS=""
  FFOPTIONS=""
  GMOPTIONS=""
  DCRAWOPTIONS=""

#  HISTOEND=0
#  LUT="hald:8"
#  LUTOPTIONS=""

  SRC=$PREVIEWDIR/$VIDEONAME/raw
  SCAT=tif
  STAGE=none

  ( _VreadSection HISTO
  ) | _Vinterpreter histo        # CAREFUL; Because of subshell in _Vinterpreter Variables don't get exported from there
				   # therefore it must be the last command!!!
}

_Vautocolor () {
  echo "##### Vpreview called"
  _Vdirectories

  IMOPTIONS=""
  GMICOPTIONS=""
  FFOPTIONS=""
  GMOPTIONS=""
  DCRAWOPTIONS=""

  SRC=$PREVIEWDIR/$VIDEONAME/hist
  SCAT=png
  STAGE=none

  ( _VreadSection AUTOCOLOR
  ) | _Vinterpreter color          # CAREFUL; Because of subshell in _Vinterpreter Variables don't get exported from there
				   # therefore it must be the last command!!!

#  SRC=$PREVIEWDIR/$VIDEONAME/color
#  SCAT=png
#  STAGE=none
#  ( _VreadSection PREVIEW
#  ) | _Vinterpreter preview        # CAREFUL; Because of subshell in _Vinterpreter Variables don't get exported from there
				   # therefore it must be the last command!!!
}


_Vpreview () {
  echo "##### Vpreview called"

  _Vdirectories

  if [ -f $PREVIEWDIR/$VIDEONAME/1lut.png ]; then
    _cleardir $PREVIEWDIR/$VIDEONAME/lut
  else
    _extractLUT_preview $PREVIEWDIR/$VIDEONAME
  fi

  IMOPTIONS=""
  GMICOPTIONS=""
  FFOPTIONS=""
  GMOPTIONS=""
  DCRAWOPTIONS=""

  SRC=$PREVIEWDIR/$VIDEONAME/raw
  SCAT=tif
  STAGE=none

  ( 
    echo @gm
    echo APPLYLUT preview
    _VreadSection PREVIEW
  ) | _Vinterpreter preview          # CAREFUL; Because of subshell in _Vinterpreter Variables don't get exported from there

}

_Vprocess () {
  echo "##### Vprocess called"
  _Vdirectories

#
#  LUTOPTIONS=""
#  LUT="hald:8"
#  IMOPTIONS=""
#  GMICOPTIONS=""
#  FFOPTIONS=""
#  STAGE=none
#  VSRC=$VIDEOSOURCE
#  VCAT=$VIDEOCAT


  # _extractLUT_preview $PREVIEWDIR/$VIDEONAME

  DESHAKE=no
  DESHAKEFILE=$PREVIEWDIR/$VIDEONAME/deshake.trf
  DESHAKEVID=$PREVIEWDIR/$VIDEONAME/deshake.mp4

  IMOPTIONS=""
  GMICOPTIONS=""
  FFOPTIONS=""
  GMOPTIONS=""
  DCRAWOPTIONS=""


  SRC=$VIDEOSOURCE
  SCAT=$VIDEOCAT
  STAGE=ffm

  if [ $VIDEOCAT = dng ]; then
   (
    echo @dcraw
    echo '-v'
    _VreadSection EXTRACT
    echo @gm
    echo APPLYLUT process
    _VreadSection PREVIEW
    _VreadSection FINAL
   ) | _Vinterpreter process          # CAREFUL; Because of subshell in _Vinterpreter Variables don't get exported from there
				   # therefore it must be the last command!!!
  else
   (
    echo @ffm
    echo copy
    _VreadSection EXTRACT
    echo @gm
    echo APPLYLUT process
    _VreadSection PREVIEW
    _VreadSection FINAL
   ) | _Vinterpreter process          # CAREFUL; Because of subshell in _Vinterpreter Variables don't get exported from there
				   # therefore it must be the last command!!!
  fi
}


################# INTERPRETING THE VIDEO SCRIPT FILE

_Vinterpreter () { # $1 is VideoCommand; reads SCRIPT from stdin
      ( while read LINE; do
            echo "@@@@@@ $1: $LINE"
           _Vline $1 "$LINE" < /dev/null # the < /dev/null is for prohibiting strange error messages!
       done
       _Vfinish_$1
      )
}

_VreadSection () { # $1 is section ; puts section of SCRIPTFILE to stdout
   cat $SCRIPTFILE | awk -F\# '{print $1}' | \
      awk "BEGIN {f=0;IGNORECASE=0} \
           /^[ \t]*\$/ {next} \
           /^[ \t]*@$1/ {f=1; next} \
           /^[ \t]*@@$1/ {f=1; next} \
           /^[ \t]*@[A-Z]/ {if (f != 0) exit} \
           {if (f != 0) print}"
}

#DCRAWOPTIONS="-w +M -q 3      -n 200      -o 1"
#DCRAWOPTIONS="-W +M -q 3 -H 0 -n 200 -b 1 -o 0"

_Vline () { # $1 = operation; $2=LINE
   case "$2" in
     @dcraw)
        if [ $STAGE != dcraw ]; then
           TGT=`_othertmp $SRC`
           _cleardir $TGT
           TCAT=tif
            _VcloseStage $1
        fi
        STAGE=dcraw
        ;;
     @ffm)
        if [ $STAGE != ffm ]; then
           TGT=`_othertmp $SRC`
           _cleardir $TGT
           TCAT=tif
            _VcloseStage $1
        fi
        STAGE=ffm
        ;;
     @gm)
        if [ $STAGE != gm ]; then
           TGT=`_othertmp $SRC`
           _cleardir $TGT
           TCAT=tif
            _VcloseStage $1
        fi
        STAGE=gm
        ;;
     @gmic)
        if [ $STAGE != gmic ]; then
           TGT=`_othertmp $SRC`
           _cleardir $TGT
           TCAT=tif
            _VcloseStage $1
        fi
        STAGE=gmic
        ;;
     @im)
        if [ $STAGE != im ]; then
           TGT=`_othertmp $SRC`
           _cleardir $TGT
           TCAT=tif
            _VcloseStage $1
        fi
        STAGE=im
        ;;
     APPLYLUT*)
        rl="`_restline $2`"
        if   [ $STAGE = gm -a $SCAT = tif -a "$rl" = preview ]; then           
            if [ -f $PREVIEWDIR/$VIDEONAME/1lut.png ]; then # fixed lut
                 GMOPTIONS="$GMOPTIONS -hald-clut $PREVIEWDIR/$VIDEONAME/1lut.png"
            else # variable lut
                 LSRC=$PREVIEWDIR/$VIDEONAME/lut
                 GMOPTIONS="$GMOPTIONS -hald-clut $LSRC/@LUT@"           
            fi
        elif   [ $STAGE = gm -a $SCAT = tif -a "$rl" = process ]; then
            if [ -f $PREVIEWDIR/$VIDEONAME/1lut.png ]; then # fixed lut
                 GMOPTIONS="$GMOPTIONS -hald-clut $PREVIEWDIR/$VIDEONAME/1lut.png"
            else # variable lut
                 LSRC=$PREVIEWDIR/$VIDEONAME/lut
                 LTGT=$PREVIEWDIR/$VIDEONAME/tmp/lut
                 _generateLUTs $SRC/tif $LSRC $LTGT $SCAT
                 GMOPTIONS="$GMOPTIONS -hald-clut $LTGT/@LUT@"           
            fi
        else
            echo "ERROR: $2 with '$rl' not allowed in stage $STAGE"
            exit 17
        fi
        ;;
     ADDLUT)
        if   [ $STAGE = im ]; then
            IMOPTIONS="$IMOPTIONS -background Grey hald:8 -gravity SouthEast -append"
        else
            echo "ERROR: $2 not allowed in stage $STAGE"
            exit 17
        fi
        ;;
     DESHAKE)
        if   [ $STAGE = ffm ]; then
            _V_generateDeshakefile
            FFOPTIONS="$FFOPTIONS,vidstabtransform=input=$DESHAKEFILE"
            #FFMOPTIONS="vidstabtransform=input=$DESHAKEFILE,$FFMOPTIONS"
            DESHAKE=yes
        else
            echo "ERROR: $2 not allowed in stage $STAGE"
            exit 17
        fi
        ;;

     LEVELS*)
          rl="`_restline $2`"
          _Vlevels $rl
          if [ $STAGE = im ]; then
             IMOPTIONS="$IMOPTIONS $LEVELSTRINGIM"
          elif [ $STAGE = gm ]; then
             # GMOPTIONS="$GMOPTIONS -channel All -hald-clut $lx"
             GMOPTIONS="$GMOPTIONS $LEVELSTRINGGM"
          elif [ $STAGE = ffm ]; then
             FFMOPTIONS="$FFMOPTIONS,$LEVELSTRINGFF"
          else 
            echo "ERROR: $2 not allowed in stage $STAGE"
            exit 17
         fi
          ;;
     LUT*)
          rl="`_restline $2`"
          # echo "RESTLINE IS >$rl<"
          if [ -f "$rl" ]; then 
              lx="$rl"
          else
              lx="`cat $HOME/.vgrade.luts.conf /etc/vgrad/luts.conf | grep -v '#' | grep $rl | head -1 | cut -d = -f 2`"
              if [ ! -f $lx ]; then
	            echo "ERROR: LUT $rl not found in stage $STAGE"
	            exit 17
              fi
          fi
          echo "LUT IS >$lx<"
          if [ $STAGE = im ]; then
             IMOPTIONS="$IMOPTIONS -channel RGB $lx -hald-clut"
#          elif [ $STAGE = ffm ]; then
#             FFMOPTIONS="$FFMOPTIONS,haldclut=file=$lx"
          elif [ $STAGE = gm ]; then
             # GMOPTIONS="$GMOPTIONS -channel All -hald-clut $lx"
             GMOPTIONS="$GMOPTIONS -hald-clut $lx"
          else 
            echo "ERROR: $2 not allowed in stage $STAGE"
            exit 17
         fi
         ;;
     *)
        if   [ $STAGE = ffm ]; then
            FFOPTIONS="$FFOPTIONS,$2"
        elif [ $STAGE = gm ]; then
            GMOPTIONS="$GMOPTIONS $2"
        elif [ $STAGE = gmic ]; then
            GMICOPTIONS="$GMICOPTIONS $2"
        elif [ $STAGE = im ]; then
            IMOPTIONS="$IMOPTIONS $2"
        elif [ $STAGE = dcraw ]; then
            DCRAWOPTIONS="$DCRAWOPTIONS $2"
        fi
        ;;
   esac
}

_VcloseStage () { # $1 operation
        echo "#### Calling _VcloseStage $*"
        _VcloseStageNoFFM $1
        if [ ! -z "$FFOPTIONS" ]; then
           _VcloseStage_ffm $1
        fi
        FFOPTIONS=""
}

_VcloseStageNoFFM () { # $1 operation
        if [ ! -z "$DCRAWOPTIONS" ]; then
           _VcloseStage_dcraw $1
        fi
        if [ ! -z "$GMOPTIONS" ]; then
           _VcloseStage_gm $1
        fi
        if [ ! -z "$GMICOPTIONS" ]; then
           _VcloseStage_gmic $1
        fi
        if [ ! -z "$IMOPTIONS" ]; then
           _VcloseStage_im $1
        fi
        GMOPTIONS=""
        GMICOPTIONS=""
        IMOPTIONS=""
        DCRAWOPTIONS=""
}


_Vfinish_extract () {
   echo "#### Calling _Vfinish_extract $*"
   TGT=$PREVIEWDIR/$VIDEONAME/raw
   _cleardir $TGT
   TCAT=tif
   _VcloseStage extract

   mkdir -p $TGT/png
   mkdir -p $TGT/hist
   set -x
   ffmpeg -y -loglevel $LOGLEVELV -r 1 -i $TGT/tif/%04d.tif -vf "fps=fps=1" -f image2 -pix_fmt rgb24 $TGT/png/%04d.png
   ffmpeg -y -loglevel $LOGLEVELP -r 1 -i $TGT/png/%04d.png -vf "fps=fps=1,crop=out_w=in_w:out_h=in_h-512:x=0:y=0,format=pix_fmts=rgb24,histogram=display_mode=overlay" \
               -f image2 -pix_fmt rgb24 $TGT/hist/%04d.png
   set +x
}

_Vfinish_histo () {
   echo "#### Calling _Vfinish_histo $*"
   TGT=$PREVIEWDIR/$VIDEONAME/hist
   _cleardir $TGT
   TCAT=png
   _VcloseStage histo

   mkdir -p $TGT/hist
   mkdir -p $TGT/cpng
   set -x
   ffmpeg -y -loglevel $LOGLEVELV -r 1 -i $TGT/png/%04d.png -vf "fps=fps=1,crop=out_w=in_w:out_h=in_h-512:x=0:y=0" -f image2 -pix_fmt rgb24 $TGT/cpng/%04d.png
   ffmpeg -y -loglevel $LOGLEVELP -r 1 -i $TGT/cpng/%04d.png -vf "fps=fps=1,format=pix_fmts=rgb24,histogram=display_mode=overlay" -f image2 -pix_fmt rgb24 $TGT/hist/%04d.png
   set +x

   if [ -f $HISTFILE ]; then rm -vf $HISTFILE ; fi

   for img in $TGT/cpng/*.png; do
      echo -n "foto_histoparms $img: "
      foto_histoparms $img | tee -a $HISTFILE
   done
}

_Vfinish_color () {
   echo "#### Calling _Vfinish_color $*"
   TGT=$PREVIEWDIR/$VIDEONAME/color
   _cleardir $TGT
   TCAT=png
   _VcloseStage color

   mkdir -p $TGT/hist
   set -x
   ffmpeg -y -loglevel $LOGLEVELP -r 1 -i $TGT/png/%04d.png -vf "fps=fps=1,crop=out_w=in_w:out_h=in_h-512:x=0:y=0,format=pix_fmts=rgb24,histogram=display_mode=overlay" \
               -f image2 -pix_fmt rgb24 $TGT/hist/%04d.png
   set +x
   _normalizeIMG $TGT/png/*.png

   cp -vf $PREVIEWDIR/$VIDEONAME/color/png/0001.png $PREVIEWDIR/$VIDEONAME/1lut.png

   gm time convert -verbose -depth 8  \
            -gravity SouthEast -crop 512x512-0-0 $PREVIEWDIR/$VIDEONAME/color/png/0001.png \
            $PREVIEWDIR/$VIDEONAME/1lut.png
	                   ##### HACK; NYI; must specify size generically
}

_Vfinish_preview () {
   echo "#### Calling _Vfinish_preview $*"
   TGT=$PREVIEWDIR/$VIDEONAME/prev
   _cleardir $TGT
   TCAT=png
   _VcloseStage preview

   mkdir -p $TGT/hist
   set -x
   # ffmpeg -y -loglevel $LOGLEVELV -r 1 -i $TGT/tif/%04d.tif -vf "fps=fps=1" -f image2 -pix_fmt rgb24 $TGT/png/%04d.png
   ffmpeg -y -loglevel $LOGLEVELP -r 1 -i $TGT/png/%04d.png -vf "fps=fps=1,crop=out_w=in_w:out_h=in_h-512:x=0:y=0,format=pix_fmts=rgb24,histogram=display_mode=overlay" \
               -f image2 -pix_fmt rgb24 $TGT/hist/%04d.png
   set +x
   _normalizeIMG $TGT/png/*.png
}


# mov, dng, avi, tif, png

_Vfinish_process () {
   echo "#### Calling _Vfinish_process $*"

   TGT=`_othertmp $SRC`
   _cleardir $TGT
   TCAT=tif
   _VcloseStageNoFFM process

  if [ -f $AUDIOFILE ]; then
    AUDIOIN="-i $AUDIOFILE"
    AUDIOSTRING="-acodec copy"
  else
    AUDIOIN=""
    AUDIOSTRING=""
  fi
  OUTFILE=`_Voutfile`
  OUTSTRING="`_Voutopt`"
  INTSTRING=`_Vintopt`
  INTFILE=`_Vintfile`

   # Video is now in $SCAT $SRC
   if [ $SCAT = tif -a $DESHAKE = no ]; then
      FO="`_nf "fps=fps=$FRAMERATE,$FFOPTIONS"`"
      set -x
      ffmpeg -y -loglevel $LOGLEVELV -r $FRAMERATE -i $SRC/tif/%06d.tif $AUDIOIN -vf "$FO" $OUTSTRING $AUDIOSTRING $OUTFILE
      set +x
   elif [ $SCAT = tif -a $DESHAKE = yes ]; then
      FO="`_nf "fps=fps=$FRAMERATE,$FFOPTIONS"`"
      set -x
      ffmpeg -y -loglevel $LOGLEVELV -r $FRAMERATE -i $SRC/tif/%06d.tif -vf "$FO" $INTSTRING -an $INTFILE
      ffmpeg -y -loglevel $LOGLEVELV -r $FRAMERATE -i $INTFILE $AUDIOIN $OUTSTRING $AUDIOSTRING $OUTFILE
      set +x
      rm -vf $INTFILE
   elif [ $SCAT = png  -a $DESHAKE = no ]; then 
      FO="`_nf "fps=fps=$FRAMERATE,$FFOPTIONS"`"
      set -x
      ffmpeg -y -loglevel $LOGLEVELV -r $FRAMERATE -i $SRC/png/%06d.png $AUDIOIN -vf "$FO" $OUTSTRING $AUDIOSTRING $OUTFILE
      set +x
   elif [ $SCAT = png  -a $DESHAKE = yes ]; then 
      FO="`_nf "fps=fps=$FRAMERATE,$FFOPTIONS"`"
      set -x
      ffmpeg -y -loglevel $LOGLEVELV -r $FRAMERATE -i $SRC/png/%06d.png -vf "$FO" $INTSTRING -an $INTFILE
      ffmpeg -y -loglevel $LOGLEVELV -r $FRAMERATE -i $INTFILE $AUDIOIN $OUTSTRING $AUDIOSTRING $OUTFILE
      set +x
      rm -vf $INTFILE
#   elif [ $SCAT = mov  -a $DESHAKE = no ]; then 
#      FO="`_nf "fps=fps=$FRAMERATE,$FFMOPTIONS"`"
#      set -x
#      ffmpeg -y -loglevel $LOGLEVELV -r $FRAMERATE -i $VSRC $AUDIOIN -vf "$FO" $OUTSTRING $AUDIOSTRING $OUTFILE
#      set +x
#   elif [ $SCAT = mov  -a $DESHAKE = yes ]; then 
#      FO="`_nf "fps=fps=$FRAMERATE,$FFMOPTIONS"`"
#      set -x
#      ffmpeg -y -loglevel $LOGLEVELV -r $FRAMERATE -i $VSRC -vf "$FO" $INTSTRING $INTFILE
#      ffmpeg -y -loglevel $LOGLEVELV -r $FRAMERATE -i $INTFILE $AUDIOIN $OUTSTRING $AUDIOSTRING $OUTFILE
#      set +x
#      rm -vf $INTFILE
   else 
      echo "Not yet implemented"
   fi


   # postprocessing
   if [ -f $OUTFILE ]; then
     _cleardir $PREVIEWDIR/$VIDEONAME/post
     mkdir -p $PREVIEWDIR/$VIDEONAME/post/png
     mkdir -p $PREVIEWDIR/$VIDEONAME/post/hist
     set -x
     ffmpeg -y -loglevel $LOGLEVELP -r $FRAMERATE -i $OUTFILE \
              -f image2 -pix_fmt rgb24 -vf "select=not(mod(n\,$EXTRACTFACTOR)),setpts=N/($FRAMERATE*TB)" \
              $PREVIEWDIR/$VIDEONAME/post/png/%04d.png
     ffmpeg -y -loglevel $LOGLEVELP -r 1 -i $PREVIEWDIR/$VIDEONAME/post/png/%04d.png -vf "fps=fps=1,format=pix_fmts=rgb24,histogram=display_mode=overlay" \
              -f image2 -pix_fmt rgb24 $PREVIEWDIR/$VIDEONAME/post/hist/%04d.png
     set +x
   fi
}


############### PROCESSING ON CLOSING STAGES ##################################

_VcloseStage_ffm () { # $1 operation
      echo "#### Calling _VcloseStage_ffm $*"
      echo "         with SRC=$SRC, SCAT=$SCAT -> TGT=$TGT, TCAT=$TCAT"
      OPERATION=$1
      if   [ $OPERATION = extract -a \( $SCAT = mov -o $SCAT = avi -o $SCAT = mp4 \) -a $TCAT = tif ]; then
           mkdir -vp $TGT/tif
			# http://superuser.com/questions/391257/extracting-one-of-every-10-frames-in-a-video-using-vlc-or-ffmpeg
           # FO="`_nf "$FFOPTIONS,select=not(mod(n\,$EXTRACTFACTOR)),setpts=N/($FRAMERATE*TB)"`"
           # FO="`_nf "$FFOPTIONS,select=not(mod(n\,$EXTRACTFACTOR))*between(t\,50\,200),setpts=N/($FRAMERATE*TB)"`"
           FO="`_nf "$FFOPTIONS,select=not(mod(n\,$EXTRACTFACTOR))*$DURATIONOPTS,setpts=N/($FRAMERATE*TB)"`"
           set -x
           ffmpeg -y -loglevel $LOGLEVELV -r $FRAMERATE -i $SRC -vf "$FO" \
              -f image2 -pix_fmt rgb48le -an $TGT/tif/%04d.tif
              # -vf fps=fps=1/4 \
              # -vf "select=not(mod(n\,100)),setpts=N/(25*TB)" \

              # $DURATIONOPTS 

           set +x
           SRC=$TGT
           SCAT=tif
      elif   [ $OPERATION = process -o  \( $SCAT = mov -o $SCAT = avi -o $SCAT = mp4 \) -a $TCAT = tif ]; then
           mkdir -vp $TGT/tif
           set -x
           FO="`_nf "$FFOPTIONS,select=$DURATIONOPTS,setpts=N/($FRAMERATE*TB)"`"
           ffmpeg -y -loglevel $LOGLEVELV -r $FRAMERATE -i $SRC -vf $FO \
              -f image2 -pix_fmt rgb48le -an $TGT/tif/%06d.tif
              # -vf fps=fps=1/4 \
              # -vf "select=not(mod(n\,100)),setpts=N/(25*TB)" \

           set +x
           SRC=$TGT
           SCAT=tif
      elif   [ $OPERATION != process -a $SCAT = tif -a $TCAT = png ]; then
           mkdir -vp $TGT/png
           FO="`_nf "fps=fps=1,$FFOPTIONS"`"
           set -x
           ffmpeg -y -loglevel $LOGLEVELV -r 1 -i $SRC/tif/%04d.tif -vf $FO \
              -f image2 -pix_fmt rgb24 -an $TGT/png/%04d.png
           set +x
           SRC=$TGT
           SCAT=png
      elif   [ $OPERATION = process -a $SCAT = tif -a $TCAT = png ]; then
           mkdir -vp $TGT/png
           FO="`_nf "fps=fps=1,$FFOPTIONS"`"
           set -x
           ffmpeg -y -loglevel $LOGLEVELV -r 1 -i $SRC/tif/%06d.tif -vf $FO \
              -f image2 -pix_fmt rgb24 -an $TGT/png/%06d.png
           set +x
           SRC=$TGT
           SCAT=png
#       elif [ $OPERATION = extract && $SCAT = avi ]; then
#       elif [ $OPERATION = extract && $SCAT = avi ]; then
      else
         echo "not yet implemented"; exit 17
      fi
}

_VcloseStage_gm () { # $1 operation
      echo "#### Calling _VcloseStage_gm $*"
      echo "         with SRC=$SRC, SCAT=$SCAT -> TGT=$TGT, TCAT=$TCAT"
      OPERATION=$1
      if   [ $SCAT = tif -a  $TCAT = tif ]; then
           echo "gm $SRC with $GMOPTIONS"
           mkdir -vp $TGT/tif
           ( for im in $SRC/tif/*.tif ; do
              imb=`basename $im .tif`
              gmo="`echo "$GMOPTIONS" | sed "1,$ s/@LUT@/$imb.png/g"`"
              echo time convert -verbose -depth 16 $gmo $im $TGT/tif/$imb.tif
           done ) | gm batch -echo on -feedback off
           SRC=$TGT
           SCAT=tif
      elif [ $SCAT = tif -a  $TCAT = png ]; then
           echo "gm $SRC with $GMOPTIONS"
           mkdir -vp $TGT/png
           ( for im in $SRC/tif/*.tif ; do
              imb=`basename $im .tif`
              gmo="`echo "$GMOPTIONS" | sed "1,$ s/@LUT@/$imb.png/g"`"
              echo time convert -verbose -depth 8 $gmo $im $TGT/png/$imb.png
           done ) | gm batch -echo on -feedback off
           SRC=$TGT
           SCAT=tif
      elif [ $SCAT = png -a  $TCAT = png ]; then
           echo "gm $SRC with $GMOPTIONS"
           mkdir -vp $TGT/png
           ( for im in $SRC/png/*.png ; do
              imb=`basename $im .png`
              gmo="`echo "$GMOPTIONS" | sed "1,$ s/@LUT@/$imb.png/g"`"
              echo time convert -verbose -depth 8 $gmo $im $TGT/png/$imb.png
           done ) | gm batch -echo on -feedback off
           SRC=$TGT
           SCAT=tif
      else
         echo "not yet implemented"; exit 17
      fi
}

_VcloseStage_gmic () { # $1 operation
      echo "#### Calling _VcloseStage_gmic $*"
      echo "         with SRC=$SRC, SCAT=$SCAT -> TGT=$TGT, TCAT=$TCAT"
      OPERATION=$1
      if   [ $SCAT = tif -a  $TCAT = tif ]; then
           echo "gmic $SRC with $GMICOPTIONS"
           SRC=$TGT
           SCAT=tif
#       elif [ $OPERATION = extract && $SCAT = avi ]; then
         echo "not yet implemented"; exit 17
      else
         echo "not yet implemented"; exit 17
      fi
}

_VcloseStage_im () { # $1 operation
      echo "#### Calling _VcloseStage_im $*"
      echo "         with SRC=$SRC, SCAT=$SCAT -> TGT=$TGT, TCAT=$TCAT"
      OPERATION=$1
      if   [ $SCAT = tif -a $TCAT = tif ]; then
           echo "converting with im from $SRC to $TGT with $IMOPTIONS"
           mkdir -vp $TGT/tif
           for img in $SRC/tif/* ; do
               # cp -v $img $TGT/tif/
               ti=$TGT/tif/`basename $img`
               set -x
               convert -verbose $img $IMOPTIONS $ti
               set +x
           done
           SRC=$TGT
           SCAT=tif
     elif   [ $SCAT = tif -a $TCAT = png ]; then
           echo "converting with im from $SRC to $TGT with $IMOPTIONS"
           mkdir -vp $TGT/png
           for img in $SRC/tif/* ; do
               # cp -v $img $TGT/tif/
               ti=$TGT/png/`basename $img .tif`.png
               set -x
               convert -verbose $img $IMOPTIONS $ti
               set +x
           done
           SRC=$TGT
           SCAT=png
     elif   [ $SCAT = png -a $TCAT = png ]; then
           echo "converting with im from $SRC to $TGT with $IMOPTIONS"
           mkdir -vp $TGT/png
           for img in $SRC/png/* ; do
               # cp -v $img $TGT/tif/
               ti=$TGT/png/`basename $img`
               set -x
               convert -verbose $img $IMOPTIONS $ti
               set +x
           done
           SRC=$TGT
           SCAT=png
#       elif [ $OPERATION = extract && $SCAT = avi ]; then
      else
         echo "not yet implemented"; exit 17
      fi
}

# DCRAWOPTIONS="-W +M -q 3 -H 0 -n 200 -b 1 -o 0"
# dcraw -c -T -6 $DCRAWOPTIONS $ff > $PREVIEWDIR/$VIDEONAME/rawtif/`printf %04d $fc`.tif

_VcloseStage_dcraw () { # $1 operation
      echo "#### Calling _VcloseStage_dcraw $*"
      echo "         with SRC=$SRC, SCAT=$SCAT -> TGT=$TGT, TCAT=$TCAT"
      OPERATION=$1
      if [ -z "$DCRAWOPTIONS" -o "$DCRAWOPTIONS" = " -v" ]; then
        # DCRAWOPTIONS="-v -W +M -q 3 -H 0 -n 200 -b 1 -o 0"
          DCRAWOPTIONS="-v -w +M -q 3 -H 2 -n 200 -b 1 -o 1 -m 2"
          
      fi
      OPERATION=$1
      if   [ $OPERATION = extract -a $SCAT = dng -a  $TCAT = tif ]; then
           echo "converting with dcraw from $SRC to $TGT with $DCRAWOPTIONS"
           mkdir -vp $TGT/tif
           if [ -d $SRC/dng ]; then
               SSRC=$SRC/dng
           else
               SSRC=$SRC
           fi
           N=0
           mkdir -vp $TGT/tif
           for img in $SSRC/*.dng ; do
               # cp -v $img $TGT/tif/
               DNGNR=`basename $img .dng | rev | cut -d _ -f 1 | rev`
               MODULO=`expr $DNGNR % $EXTRACTFACTOR`
               if [ $MODULO = 0 ]; then
                   ti=$TGT/tif/`printf '%04d' $N`.tif
                   echo  dcraw -c -T -6 $DCRAWOPTIONS $img to $ti
                         dcraw -c -T -6 $DCRAWOPTIONS $img > $ti
                   N=`expr $N + 1`
               fi
           done
           SRC=$TGT
           SCAT=tif
      elif [ $OPERATION = process -a $SCAT = dng -a  $TCAT = tif ]; then
           echo "converting with dcraw from $SRC to $TGT with $DCRAWOPTIONS"
           mkdir -vp $TGT/tif
           if [ -d $SRC/dng ]; then
               SSRC=$SRC/dng
           else
               SSRC=$SRC
           fi
           N=0
           mkdir -vp $TGT/tif
           for img in $SSRC/*.dng ; do
               # cp -v $img $TGT/tif/
               DNGNR=`basename $img .dng`
               ti=$TGT/tif/`printf '%06d' $N`.tif
               echo  dcraw -c -T -6 $DCRAWOPTIONS $img to $ti
                     dcraw -c -T -6 $DCRAWOPTIONS $img > $ti
               N=`expr $N + 1`
           done
           SRC=$TGT
           SCAT=tif
      else
         echo "not yet implemented"; exit 17
      fi
}


############# GENERAL UTILITIES ######################################


_restline() {
  echo "$*" | awk '{for (i=2;i<=NF;i++) printf("%s ",$i); printf "\n"}' | sed '1,$ s/^[ \t]*//g ; 1,$ s/[ \t]*$//g'
}

_VclearTmp () {
  if [ -d $PREVIEWDIR/$VIDEONAME/tmp ]; then
     rm -Rf $PREVIEWDIR/$VIDEONAME/tmp
  fi
  mkdir -p $PREVIEWDIR/$VIDEONAME/tmp/1
  mkdir -p $PREVIEWDIR/$VIDEONAME/tmp/2
}



_cleardir () { # $1 is dir
   if [ -d $1 ]; then
      echo "           ... Clearing $1"
      rm -Rf $1
   fi
   mkdir -p $1
}


_othertmp () {
   case $1 in
      */tmp/1)
          echo $1 | sed '1,$ s/\/tmp\/1/\/tmp\/2/'
          ;;
      */tmp/2)
          echo $1 | sed '1,$ s/\/tmp\/2/\/tmp\/1/'
          ;;
      *)
          echo $PREVIEWDIR/$VIDEONAME/tmp/1
          ;;
    esac
}

_nf () {
   echo "$*" | sed '1,$ s/,,*/,/g; 1,$ s/^,//g; 1,$ s/,$//g'
}

_varexpand () {
   echo `echo "$*" | sed "1,\\\$ s/\\\$VDIR/$VIDEOSOURCEDIR/g; s/\\\$VNAME/$VIDEONAME/g; "`
}

_normalizeIMG () {
   ( for img in $*; do
      echo time convert -verbose -depth 8  \
            -crop 1920x1080-0-0 $img \
            -gravity SouthEast -crop 512x512-0-0 -background gray -extent 1920x512+0+0 $img \
            -append $img.i
	                   ##### HACK; NYI; must specify size generically
   done ) | gm batch -echo on -feedback off
   for img in $*; do
      mv -v $img.i $img
   done
}

_extractLUT_preview () { # $1 is $PREVIEWDIR/$VIDEONAME
  echo "#### _extractLUT_preview: extracting LUTS from $1/color/png to $1/lut"
  _cleardir $1/lut
  ( for img in $1/color/png/*.png; do
      ib=`basename $img`
      echo time convert -verbose -depth 8  \
            -gravity SouthEast -crop 512x512-0-0 $img \
            $1/lut/$ib
	                   ##### HACK; NYI; must specify size generically
   done ) | gm batch -echo on -feedback off
}

_VcalculateLUT () { # $1 can be im, gm, gmic or ffm
     if [ "$LUT" = "hald:8" -a -z "$LUTOPTIONS" ]; then
         IMOPTIONS=""
         GMICOPTOPTIONS=""
         GMOPTIONS=""
         FFMOPTIONS=""
         LUT="hald:8"
         LUTOPTIONS=""
     elif [ -f "$LUT" -a -z "$LUTOPTIONS" ]; then
         if [ "$1" = im ]; then IMOPTIONS="$LUT -hald-clut" ; else IMOPTIONS="" ; fi
         if [ "$1" = gm ]; then GMOPTIONS="-hald-clut $LUT" ; else GMOPTIONS="" ; fi
         if [ "$1" = gmic ]; then GMICOPTIONS="-not-yet-implented" ; else GMICOPTIONS="" ; fi
         if [ "$1" = ffm ]; then 
             echo "LUT for ffm not implemented, because it is buggy!"
             exit 17
             FFMOPTIONS="haldclut=file=$LUT" ; 
		# ffmpeg -y -loglevel info -r 1 -i /home/mov/tmp/bm_1_2014-02-08_1458_C0001/rawpng/%04d.png -i lut.png -filter_complex '[0][1] haldclut,lutyuv=y=gammaval(1.2)' -f image2 -pix_fmt rgb24 /home/mov/tmp/bm_1_2014-02-08_1458_C0001/tmp/1/%04d.png
         else FFMOPTIONS="" ; fi
         LUT="hald:8"
         LUTOPTIONS=""
     else 
         set -x
         convert -verbose $LUT $LUTOPTIONS $PREVIEWDIR/$VIDEONAME/lut.png
         set +x
         if [ "$1" = im ]; then IMOPTIONS="$PREVIEWDIR/$VIDEONAME/lut.png -hald-clut" ; else IMOPTIONS="" ; fi
         if [ "$1" = gm ]; then GMOPTIONS="-hald-clut $PREVIEWDIR/$VIDEONAME/lut.png" ; else GMOPTIONS="" ; fi
         if [ "$1" = gmic ]; then GMICOPTIONS="-not-yet-implented" ; else GMICOPTIONS="" ; fi
         if [ "$1" = ffm ]; then 
             echo "LUT for ffm not implemented, because it is buggy!"
             exit 17
             FFMOPTIONS="haldclut=file=$PREVIEWDIR/$VIDEONAME/lut.png" ; 
         else FFMOPTIONS="" ; fi
         # IMOPTIONS="$IMOPTIONS $PREVIEWDIR/$VIDEONAME/lut.png -hald-clut"
         LUT="hald:8"
         LUTOPTIONS=""
     fi
}

_Vhistodata () { # $1 = file,  $2 = offsetL $3 = offsetR in percent
         if [ ! -f $1 ]; then
            echo "$1 missing!"
            exit 9
          fi
          REDLEFT=`cat $1 | awk '{print $1}' | awk -F, "BEGIN {val=100}; {if (\\$1<val) val=\\$1} END {print (val - ($2))}"`
          REDRIGHT=`cat $1 | awk '{print $1}' | awk -F, "BEGIN {val=0}; {if (\\$2>val) val=\\$2} END {print (val + ($3))}"`
          GREENLEFT=`cat $1 | awk '{print $2}' | awk -F, "BEGIN {val=100}; {if (\\$1<val) val=\\$1} END {print (val - ($2))}"`
          GREENRIGHT=`cat $1 | awk '{print $2}' | awk -F, "BEGIN {val=0}; {if (\\$2>val) val=\\$2} END {print (val + ($3))}"`
          BLUELEFT=`cat $1 | awk '{print $3}' | awk -F, "BEGIN {val=100}; {if (\\$1<val) val=\\$1} END {print (val - ($2))}"`
          BLUERIGHT=`cat $1 | awk '{print $3}' | awk -F, "BEGIN {val=0}; {if (\\$2>val) val=\\$2} END {print (val + ($3))}"`
          ALLLEFT=`cat $1 | awk '{print $1;print $2;print $3}' | awk -F, "BEGIN {val=100}; {if (\\$1<val) val=\\$1} END {print (val - ($2))}"`
          ALLRIGHT=`cat $1 | awk '{print $1;print $2;print $3}' | awk -F, "BEGIN {val=0}; {if (\\$2>val) val=\\$2} END {print (val + ($3))}"`
      echo "Autolevels A,A,1 A,A,1 A,A,1 would be: $REDLEFT,$REDRIGHT,1 $GREENLEFT,$GREENRIGHT,1 $BLUELEFT,$BLUERIGHT,1"
}



_Vlevels () { # expects $* restline of a LEVELS command
   echo "####LEVELING######################"
   PAR="$*"
   if [ "`expr index "$PAR" A`" != 0 -o "`expr index "$PAR" M`" != 0 ]; then # we have an A expression or M expression
       _Vhistodata $PREVIEWDIR/$VIDEONAME/histodata.txt 0 0 # gives RGB ALL LEFT RIGHT
       RL="`echo "scale=8;$REDLEFT*1.0"|bc`"
       RR="`echo "scale=8;$REDRIGHT*1.0"|bc`"
       GL="`echo "scale=8;$GREENLEFT*1.0"|bc`"
       GR="`echo "scale=8;$GREENRIGHT*1.0"|bc`"
       BL="`echo "scale=8;$BLUELEFT*1.0"|bc`"
       BR="`echo "scale=8;$BLUERIGHT*1.0"|bc`"
       AL="`echo "scale=8;$ALLLEFT*1.0"|bc`"
       AR="`echo "scale=8;$ALLRIGHT*1.0"|bc`"

       RLX="`echo $PAR | awk '{print $1}' | awk -F, '{print $1}'`"
       RLE="`echo $RLX | sed "1,\\$ s/A/$RL/g" | sed "1,\\$ s/M/$AL/g"`"
       REDLEFT="`echo "scale=8;($RLE)"|bc`"
       RRX="`echo $PAR | awk '{print $1}' | awk -F, '{print $2}'`"
       RRE="`echo $RRX | sed "1,\\$ s/A/$RR/g" | sed "1,\\$ s/M/$AR/g"`"
       REDRIGHT="`echo "scale=8;($RRE)"|bc`"
       REDGAMMA="`echo $PAR | awk '{print $1}' | awk -F, '{print $3}'`"

       GLX="`echo $PAR | awk '{print $2}' | awk -F, '{print $1}'`"
       GLE="`echo $GLX | sed "1,\\$ s/A/$GL/g" | sed "1,\\$ s/M/$AL/g"`"
       GREENLEFT="`echo "scale=8;($GLE)"|bc`"
       GRX="`echo $PAR | awk '{print $2}' | awk -F, '{print $2}'`"
       GRE="`echo $GRX | sed "1,\\$ s/A/$GR/g" | sed "1,\\$ s/M/$AR/g"`"
       GREENRIGHT="`echo "scale=8;($GRE)"|bc`"
       GREENGAMMA="`echo $PAR | awk '{print $2}' | awk -F, '{print $3}'`"

       BLX="`echo $PAR | awk '{print $3}' | awk -F, '{print $1}'`"
       BLE="`echo $BLX | sed "1,\\$ s/A/$BL/g" | sed "1,\\$ s/M/$AL/g"`"
       BLUELEFT="`echo "scale=8;($BLE)"|bc`"
       BRX="`echo $PAR | awk '{print $3}' | awk -F, '{print $2}'`"
       BRE="`echo $BRX | sed "1,\\$ s/A/$BR/g" | sed "1,\\$ s/M/$AR/g"`"
       BLUERIGHT="`echo "scale=8;($BRE)"|bc`"
       BLUEGAMMA="`echo $PAR | awk '{print $3}' | awk -F, '{print $3}'`"

       echo "Leveling with $RLX,$RRX,$REDGAMMA $GLX,$GRX,$GREENGAMMA $BLX,$BRX,$BLUEGAMMA"
       echo "Leveling with $RLE,$RRE,$REDGAMMA $GLE,$GRE,$GREENGAMMA $BLE,$BRE,$BLUEGAMMA"
#       echo "i.e. Lv. with $REDLEFT,$REDRIGHT,$REDGAMMA $GREENLEFT,$GREENRIGHT,$GREENGAMMA $BLUELEFT,$BLUERIGHT,$BLUEGAMMA"
   else
       REDLEFT="`echo $LINE | awk '{print $2}' | awk -F, '{print $1}'`"
       REDRIGHT="`echo $LINE | awk '{print $2}' | awk -F, '{print $2}'`"
       REDGAMMA="`echo $LINE | awk '{print $2}' | awk -F, '{print $3}'`"
       GREENLEFT="`echo $LINE | awk '{print $3}' | awk -F, '{print $1}'`"
       GREENRIGHT="`echo $LINE | awk '{print $3}' | awk -F, '{print $2}'`"
       GREENGAMMA="`echo $LINE | awk '{print $3}' | awk -F, '{print $3}'`"
       BLUELEFT="`echo $LINE | awk '{print $4}' | awk -F, '{print $1}'`"
       BLUERIGHT="`echo $LINE | awk '{print $4}' | awk -F, '{print $2}'`"
       BLUEGAMMA="`echo $LINE | awk '{print $3}' | awk -F, '{print $3}'`"

#       echo "Leveling with $REDLEFT,$REDRIGHT,$REDGAMMA $GREENLEFT,$GREENRIGHT,$GREENGAMMA $BLUELEFT,$BLUERIGHT,$BLUEGAMMA"
   fi

       RL="`echo "scale=8;$REDLEFT/100.0"|bc`"
       RR="`echo "scale=8;$REDRIGHT/100.0"|bc`"
       GL="`echo "scale=8;$GREENLEFT/100.0"|bc`"
       GR="`echo "scale=8;$GREENRIGHT/100.0"|bc`"
       BL="`echo "scale=8;$BLUELEFT/100.0"|bc`"
       BR="`echo "scale=8;$BLUERIGHT/100.0"|bc`"
       AL="`echo "scale=8;$ALLLEFT/100.0"|bc`"
       AR="`echo "scale=8;$ALLRIGHT/100.0"|bc`"

       LSR="r=clip(((((val/(maxval-minval))-$RL)/($RR-$RL))*(maxval-minval))+minval)"
       LSG="g=clip(((((val/(maxval-minval))-$GL)/($GR-$GL))*(maxval-minval))+minval)"
       LSB="b=clip(((((val/(maxval-minval))-$BL)/($BR-$BL))*(maxval-minval))+minval)"
   LEVELSTRINGFF="lutrgb=$LSR:$LSG:$LSB"
 
       if [ "$REDGAMMA" = "" ]; then REDGAMMA=1 ; fi
       if [ "$GREENGAMMA" = "" ]; then GREENGAMMA=1 ; fi
       if [ "$BLUEGAMMA" = "" ]; then BLUEGAMMA=1 ; fi
   LEVELSTRINGIM="-channel R -level $REDLEFT%,$REDRIGHT%,$REDGAMMA -channel G -level $GREENLEFT%,$GREENRIGHT%,$GREENGAMMA -channel B -level $BLUELEFT%,$BLUERIGHT%,$BLUEGAMMA"

   LEVELSTRINGGM="-channel Red -level $REDLEFT%,$REDRIGHT%,$REDGAMMA -channel Green -level $GREENLEFT%,$GREENRIGHT%,$GREENGAMMA -channel Blue -level $BLUELEFT%,$BLUERIGHT%,$BLUEGAMMA"

   echo "Leveling with $REDLEFT,$REDRIGHT,$REDGAMMA $GREENLEFT,$GREENRIGHT,$GREENGAMMA $BLUELEFT,$BLUERIGHT,$BLUEGAMMA"
   echo "LEVELSTRINGIM=$LEVELSTRINGIM"
   echo "LEVELSTRINGGM=$LEVELSTRINGGM"
   echo "LEVELSTRINGFF=$LEVELSTRINGFF"

   echo "######################################"
}

_V_generateDeshakefile () {
   if [ ! -f $DESHAKEFILE ]; then
         set -x
         ffmpeg -y -loglevel $LOGLEVELV -r $FRAMERATE -i $VIDEOSOURCE \
             -vf "select=$DURATIONOPTS,setpts=N/($FRAMERATE*TB),scale=1920:1080,vidstabdetect=result=$DESHAKEFILE:show=1" \
             -f mp4 -q:v 0 -r $FRAMERATE -an -vcodec mpeg4 $DESHAKEVID
             # NYI; size is hardcoded!!!
         set +x
   else
         echo "$DESHAKEFILE exists"
   fi
}

_generateLUTs () { 
     # $1 is dir of extracted images
     # $2 is dir preview luts
     # $3 is the dir where the luts belong to
     # $4 is the SCAT
   if [ $4 != tif -a $4 != png ] ; then
     echo "UNKNOWN SCAT $4"; exit 17
   fi
   _cleardir $3
   for img in $1/*.$SCAT; do
       # dir=$(dirname "img")
       # fn=$(basename "$1")
       fn=${img##*/} # ; ext=${fn##*.}; 
       enr=${fn%.*}

       n=`expr $enr + $SFRAME - 1` # the real frame number, counted from 0

       rkn=`expr \( $n / $EXTRACTFACTOR \)` # real keyframe number, counted from 0
       ofs=`expr \( $SFRAME + $EXTRACTFACTOR - 1 \) / $EXTRACTFACTOR` # offset of keyframes
       pnrl=`expr $rkn - $ofs + 1`  # number of keyframe as stored on disk to the left
       nl=`expr $rkn \* $EXTRACTFACTOR` # frame number of keyframe to the left
       pnrr=`expr $pnrl + 1` # number of keyframe as stored on disk to the right
       nr=`expr $nl + $EXTRACTFACTOR`  # frane number of keyframe to the right
       p1=`echo "scale=4;1-($n - $nl)/$EXTRACTFACTOR" | bc` # percentage for left keyframe
       p2=`echo "scale=4;1-($nr - $n)/$EXTRACTFACTOR" | bc` # percentage for right keyframe

       echo "Generating LUT for $enr; n=$n; rkn=$rkn, ofs=$ofs, mix $pnrl:$nl ($p1) with $pnrr:$nr ($p2) "

       lut1=$2/`printf "%04d\n" $pnrl`.png 
       lut2=$2/`printf "%04d\n" $pnrr`.png 
       
       if [ -f $lut1 -a -f $lut2 ]; then
             echo "                         lut1=$lut1, p1=$p1, lut2=$lut2, p2=$p2"
             _mixlut $lut1 $p1 $lut2 $p2 $3/$enr.png
       elif [ -f $lut1 -a ! -f $lut2 ]; then
             echo "                         lut=$lut1, p=1"
             cp -v $lut1 $3/$enr.png
       elif [ ! -f $lut1 -a -f $lut2 ]; then
             echo "                         lut=$lut2, p=1"
             cp -v $lut2 $3/$enr.png
       else
             echo "Error: No LUT available"
             exit 17
       fi
   done
}

_mixlut () { # lut1, p1, lut2, p2, targetlut
     set -x
     convert -verbose $1 $3 -poly "$2,1 $4,1" $5
     set +x
}