File Coverage

blib/lib/BeamerReveal/MediaManager.pm

Criterion	Covered	Total	%
statement	66	456	14.4
branch	0	74	0.0
condition			n/a
subroutine	22	51	43.1
pod	17	22	77.2
total	105	603	17.4

# -*- cperl -*-
# ABSTRACT: MediaManager


package BeamerReveal::MediaManager;
our $VERSION = '20260408.1240'; # VERSION

use strict;
use warnings;

use Carp;
use Env;

use POSIX;

use File::Which;
use File::Path;
use File::Copy;
use File::Basename;

use Data::UUID;

use MIME::Types;
use MIME::Base64;

use IO::File;

use MCE::Hobo;
use MCE::Util;
use MCE::Shared::Scalar;

use Time::HiRes;

use BeamerReveal::TemplateStore;
use BeamerReveal::IPC::Run;
use IPC::Run qw(harness start pump finish);

use File::chdir;

use BeamerReveal::Log;

sub min { $_[$_[0] > $_[1] ] }
sub nofdigits { length( "$_[0]" ) }


sub new {
  my $class = shift;
  my ( $jobname, $odir, $base, $presentationprms, $debug ) = @_;

  my $self = {
	      jobname    => $jobname,
	      outputdir  => $odir,
	      base       => $base,
	      debug      => $debug,
	     };
  $class = (ref $class ? ref $class : $class );
  bless $self, $class;

  $self->{presentationparameters} = $presentationprms;

  ########################
  # Prepare all the paths

  $self->{videos}     = "$self->{base}/media/Videos";
  $self->{audios}     = "$self->{base}/media/Audios";
  $self->{images}     = "$self->{base}/media/Images";
  $self->{animations} = "$self->{base}/media/Animations";
  $self->{stills}     = "$self->{base}/media/Stills";
  $self->{voiceovers} = "$self->{base}/media/Voiceovers";
  $self->{iframes}    = "$self->{base}/media/Iframes";
  $self->{slides}     = "$self->{base}/media/Slides";
  $self->{reveal}     = "$self->{base}/libs";
  $self->{mtoracle}   = MIME::Types->new();

  # put ourselves in the output directory for now
  {
    local $CWD = $self->{outputdir};

    # create animation path, but don't remove contents
    for my $item ( qw(animations stills voiceovers) ) {
      File::Path::make_path( $self->{$item} );
    }

    # create all the ohter paths and also clean them
    for my $item ( qw(reveal videos audios iframes images) ) {
      File::Path::rmtree( $self->{$item} );
      File::Path::make_path( $self->{$item} );
    }
  }

  # read the relevant part of the preamble of the job
  my $texFileName = $self->{jobname};
  my $realTexFileName;
  foreach my $ext ( qw(tex ltx latex) ) {
    $realTexFileName = $texFileName . ".$ext";
    last if ( -r $realTexFileName );
  }

  my $logger = $BeamerReveal::Log::logger;

  my $texFile = IO::File->new();
  $texFile->open( "<$realTexFileName" )
    or $logger->fatal( "Error: could not open your original LaTeX source file '$realTexFileName'\n" );
  $self->{preamble} = '';
  my $line;
  do { $line = <$texFile> } until( $line =~ /\\usepackage[^{]*{beamer-reveal}/ );
  $line = "%% Preamble excerpt taken from $realTexFileName\n";
  until ( $line =~ /\\begin\{document\}/ ) {
    $self->{preamble} .= $line;
    $line = <$texFile>;
  }
  $texFile->close();
  $self->{preamble} .= "%% End of preamble excerpt\n";

  ####################################################
  # check all the preconditions for running our tools
  $self->{compiler} = File::Which::which( $self->{presentationparameters}->{compiler} )
    or $logger->fatal( "Error: your setup is incomplete, I cannot find your $self->{presentationparameters}->{compiler } compiler (should be part of your TeX installation)\n" .
		       "Make sure it is accessible in a directory on your PATH list variable\n" );

  $self->{pdftoppm} = File::Which::which( 'pdftoppm' )
    or $logger->fatal( "Error: your setup is incomplete, I cannot find pdftoppm (part of the poppler library)\n" .
		       "Install 'Poppler-utils' and make sure pdftoppm is accessible in a directory on your PATH list variable\n" );

  $self->{pdfcrop} = File::Which::which( 'pdfcrop' )
    or $logger->fatal( "Error: your setup is incomplete, I cannot find pdfcrop (should be part of your TeX installation)\n" .
		       "Make sure it is accessible in a directory on your PATH list variable\n" );
  $self->{ffmpeg} = File::Which::which( 'ffmpeg' )
    or $logger->fatal( "Error: your setup is incomplete, I cannot find ffmpeg\n" .
		       "Install 'FFmpeg' (from www.ffmpeg.org) and make sure ffmpeg is accessible in a directory on your PATH list variable\n" );

  ##########################################################################
  # We sell things, before we make the, so we need to keep a backorder list

  $self->{copyBackOrders}  = [];
  $self->{constructionBackOrders} = { 'animations' => {},
				      'stills'     => {},
				      'voiceovers' => {}
				    };

  return $self;
}


sub revealToStore {
  my $self = shift;

  my $revealTree = File::ShareDir::dist_dir( 'BeamerReveal' ) . '/libs';
  my $destTree = $self->{reveal};

  File::Copy::Recursive::dircopy( $revealTree,
				  $self->{outputdir} . '/' . $destTree );
}


sub backgroundsToStore() {
  my $self = shift;
  my ( $bgs ) = @_;
  $self->{backgrounds} = $bgs;
}


sub notesToStore() {
  my $self = shift;
  my ( $notes ) = @_;
  $self->{notes} = $notes;
}


sub slideFromStore {
  my $self = shift;
  my ( $slidectr, %optargs ) = @_;

  my $logger = $BeamerReveal::Log::logger;

  my $fileName = $self->{backgrounds}->[$slidectr];
  my $fileType = $self->{mtoracle}->mimeTypeOf( $fileName );

  if( exists $optargs{to_embed} ) {
    my $file = do {
      local $/ = undef;
      open my $fh, '<' . $self->{outputdir} . '/' . $fileName
	or $logger->fatal( "Cannot open $fileType-file $fileName to read" );
      <$fh>;
    };
    return ( $fileType, encode_base64( $file ) );
  }
  else {
    return ( $fileType, $fileName );
  }
}


sub noteFromStore {
  my $self = shift;
  my ( $notectr, %optargs ) = @_;

  my $logger = $BeamerReveal::Log::logger;

  my $fileName = $self->{notes}->[$notectr];
  my $fileType = $self->{mtoracle}->mimeTypeOf( $fileName );

  if( exists $optargs{to_embed} ) {
    my $file = do {
      local $/ = undef;
      open my $fh, '<' . $self->{outputdir} . '/' . $fileName
	or $logger->fatal( "Cannot open $fileType-file $fileName to read" );
      <$fh>;
    };
    return ( $fileType, encode_base64( $file ) );
  }
  else {
    return ( $fileType, $fileName );
  }
}


sub animationRegisterInStore {
  my $self = shift;
  my ( $animation ) = @_;

  my $logger = $BeamerReveal::Log::logger;
  $Data::Dumper::Terse = 1;
  $Data::Dumper::Indent = 0;
  my $animid  = Digest::SHA::hmac_sha256_hex( Data::Dumper->Dump( [ $animation ] ) );
  my $animdir = "$self->{animations}/$animid";
  my $fullpathid = $animdir . ".mp4";
  # correct the effective path to reside in the output directory
  $animdir = $self->{outputdir} . '/' . $animdir;

  unless ( -r ( $self->{outputdir} . '/' . $fullpathid ) ) {
    File::Path::make_path( $animdir );

    my $templateStore = BeamerReveal::TemplateStore->new();
    my $tTemplate = $templateStore->fetch( 'tex', 'animation.tex' );
    my $tStamps =
      {
       'PREAMBLE'  => $self->{preamble},
       'FRAMERATE' => $animation->{framerate},
       'DURATION'  => $animation->{duration},
       'ANIMATION' => builtin::trim($animation->{tex}),
      };
    my $fileContent = BeamerReveal::TemplateStore::stampTemplate( $tTemplate, $tStamps );

    my $nofFrames = floor( $animation->{framerate} * $animation->{duration} ) + 1;
    # one extra frame to cover the final value \progress = 1.
    my $nofCores  = MCE::Util::get_ncpu();
    if ( $nofCores > 4 ) {
      $nofCores = ceil( $nofCores / 2 );
    }

    $self->{constructionBackOrders}->{animations}->{$animid} =
      {
       animation   => $animation,
       fileContent => $fileContent,
       nofFrames   => $nofFrames,
       nofCores    => $nofCores,
      };
  }

  return $fullpathid;
}


sub animationFromStore {
  my $self = shift;
  my ( $animation, %optargs ) = @_;
  return $self->_rawFromStore( 'Animations', $animation, %optargs );
}


sub stillRegisterInStore {
  my $self = shift;
  my ( $still ) = @_;

  my $logger = $BeamerReveal::Log::logger;

  $Data::Dumper::Terse = 1;
  $Data::Dumper::Indent = 0;
  my $stillid  = Digest::SHA::hmac_sha256_hex( Data::Dumper->Dump( [ $still ] ) );
  my $stilldir = "$self->{stills}/$stillid";
  my $fullpathid = $stilldir . ".mp4";
  # correct the effective path to reside in the output directory
  $stilldir = $self->{outputdir} . '/' . $stilldir;

  unless ( -r ( $self->{outputdir} . '/' . $fullpathid ) ) {
    File::Path::make_path( $stilldir );

    my $templateStore = BeamerReveal::TemplateStore->new();
    my $tTemplate = $templateStore->fetch( 'tex', 'still.tex' );
    my $tStamps =
      {
       'PREAMBLE'  => $self->{preamble},
       'STILL' => builtin::trim($still->{tex}),
      };
    my $fileContent = BeamerReveal::TemplateStore::stampTemplate( $tTemplate, $tStamps );

    $self->{constructionBackOrders}->{stills}->{$stillid} =
      {
       still       => $still,
       fileContent => $fileContent,
      };
  }
  return $fullpathid;
}



sub stillFromStore {
  my $self = shift;
  my ( $still, %optargs ) = @_;
  return $self->_rawFromStore( 'Stills', $still, %optargs );
}


sub voiceoverRegisterInStore {
  my $self = shift;
  my ( $voiceover ) = @_;

  my $logger = $BeamerReveal::Log::logger;

  $Data::Dumper::Terse = 1;
  $Data::Dumper::Indent = 0;
  my $voiceoverid  = Digest::SHA::hmac_sha256_hex( $voiceover->{text} . "|" .
						   $voiceover->{voice} . "|" .
						   $voiceover->{ext} );
  my $voiceoverbase = "$self->{voiceovers}/$voiceoverid";
  my $fullpathid = $voiceoverbase . $voiceover->{ext};

  # this is the caching action: if the file is not readable it is not in the cache: register to generate!
  unless ( -r ( $self->{outputdir} . '/' . $fullpathid ) ) {
    $self->{constructionBackOrders}->{voiceovers}->{$voiceoverid} =
      {
       base  => $self->{outputdir} . '/' . $voiceoverbase,
       text  => $voiceover->{text},
       voice => $voiceover->{voice},
       tool  => $voiceover->{tool},
       ext   => $voiceover->{ext},
      };
  }
  return $fullpathid;
}



sub voiceoverFromStore {
  my $self = shift;
  my ( $voiceover, %optargs ) = @_;
  return $self->_rawFromStore( 'Voiceovers', $voiceover, %optargs );
}


sub processAnimationBackOrders {
  my $self = shift;
  my ( $progressId ) = @_;

  my $logger = $BeamerReveal::Log::logger;

  ####################
  # treat animations

  my $totalNofBackOrders = scalar keys %{$self->{constructionBackOrders}->{animations}};

  $logger->progress( $progressId, 1, 'reusing cached data', 1 ) unless $totalNofBackOrders;

  my $i = -1;
  while ( my ( $animid, $bo ) = each %{$self->{constructionBackOrders}->{animations}} ) {
    ++$i;
    my $animation   = $bo->{animation};
    my $fileContent = $bo->{fileContent};
    my $nofFrames   = $bo->{nofFrames};
    my $nofCores    = $bo->{nofCores};
    my $animdir     = $self->{outputdir} . '/' . $self->{animations} . '/' . $animid;

    # I cannot get multithreading/multiprocessing to work reliably on MS-Windows
    my $progress;
    my $sliceSize = $nofFrames;
    if ( $^O eq 'MSWin32' ) {
      $logger->log( 2, "- Preparing media generation of $nofFrames (alas, no parallellization on MS-Windows)" );
      $nofCores = 1;
      $progress = MCE::Shared::Scalar->new( 0 );
    } elsif ( $nofCores == 1 ) {
      $progress = MCE::Shared::Scalar->new( 0 );
    } else {
      $sliceSize = ceil( $nofFrames / $nofCores );
      $logger->log( 2, "- Preparing media generation of $nofFrames frames in $nofCores threads at $sliceSize frames per thread" );
      $progress = MCE::Shared->scalar( 0 );
    }

    # make planning
    my $frameCounter = 0;
    my $planning = [];
    for ( my $core = 0; $core < $nofCores; ++$core ) {
      # make plan for core
      my $plan = { nstart => $frameCounter,
		   nstop  => min( $frameCounter + $sliceSize, $nofFrames ),
		   nr     => $core
		 };
      $plan->{slicestart} = 1;
      $plan->{slicestop}  = $plan->{nstop} - $plan->{nstart};
      $plan->{nstop}      -= 1;

      # register plan
      push @$planning, $plan;

      # prepare for next core
      $frameCounter += $sliceSize;
    }

    $logger->progress( $progressId, 0, "animation @{[$i+1]}/$totalNofBackOrders",
		       $nofFrames + $nofCores * 3 );

    if ( $nofCores == 1 ) {
      # single-threaded
      for ( my $i = 0; $i < @$planning; ++$i ) {
	_animWork( $planning->[$i], $nofCores, $fileContent, $animdir, $self, $animation,
		   $sliceSize, $progress, $progressId );
      }
    } else {
      my @hobos;
      # multi-threaded
      for ( my $i = 0; $i < @$planning; ++$i ) {
	push @hobos, MCE::Hobo->create
	  (
	   sub {
	     _animWork( @_ )
	   }, ( $planning->[$i], $nofCores, $fileContent, $animdir, $self, $animation,
		$sliceSize, $progress, $progressId )
	  );
      }

      my $activeworkers = @hobos;
      while ( $activeworkers ) {

	my @joinable = MCE::Hobo->list_joinable();
	foreach my $hobo ( @joinable ) {
	  $hobo->join();
	  if ( my $error = $hobo->error() ) {
	    $_->kill() for MCE::Hobo->list();
	    MCE::Hobo->wait_all();
	    exit(-1);
	  }
	  --$activeworkers;
	}

 	$logger->progress( $progressId, $progress->get() );

	Time::HiRes::usleep(250);
      }

      # $_->join for @hobos;
      $logger->log( 2, "- returning to single-threaded operation" );
    }

    # rename all files in order
    my $framecounter = 0;
    for ( my $core = 0; $core < @$planning; ++$core ) {
      my $plan = $planning->[$core];
      my $coreId = sprintf( '%0' . nofdigits( $nofCores ) . 'd', $core );
      for ( my $frameno = $plan->{slicestart}; $frameno <= $plan->{slicestop}; ++$frameno ) {
	my $frameId = sprintf( '%0' . nofdigits( $sliceSize ) . 'd', $frameno );
	my $src = "$animdir/frame-$coreId-$frameId.jpg";
	my $dst = sprintf( "$animdir/frame-%06d.jpg", $framecounter++ );
	File::Copy::move( $src, $dst );
      }
    }

    # run ffmpeg or avconv
    my $cmd = [ $self->{ffmpeg}, '-r', "$animation->{framerate}", '-i', 'frame-%06d.jpg', '-vf', 'crop=iw-mod(iw\,2):ih-mod(ih\,2)', 'animation.mp4' ];
    BeamerReveal::IPC::Run::run( $cmd, 0, 8, $animdir, "Error: ffmpeg run failed" );
    File::Copy::move( "$animdir/animation.mp4",
		      "$animdir/../$animid.mp4" );


    File::Path::rmtree( $animdir ) unless( defined $self->{debug} );

    # all is done
    $logger->progress( $progressId, 1, "animation @{[$i+1]}/$totalNofBackOrders", 1 );
  }
}

sub processStillBackOrders {
  my $self = shift;
  my ( $progressId ) = @_;

  my $logger = $BeamerReveal::Log::logger;
  ###############
  # treat stills

  my $totalNofBackOrders = scalar keys %{$self->{constructionBackOrders}->{stills}};

  $logger->progress( $progressId, 1, 'reusing cached data', 1 ) unless $totalNofBackOrders;

  my $i = -1;
  while ( my ( $stillid, $bo ) = each %{$self->{constructionBackOrders}->{stills}} ) {
    ++$i;
    my $still       = $bo->{still};
    my $fileContent = $bo->{fileContent};
    my $stilldir    = $self->{outputdir} . '/' . $self->{stills} . '/' . $stillid;

    $logger->progress( $progressId, 0, "still @{[$i+1]}/$totalNofBackOrders", 5 );

    _stillWork( $fileContent, $stilldir, $self, $still, $progressId );

    # run ffmpeg or avconv
    my $cmd = [ $self->{ffmpeg}, '-r', '1', '-i', 'frame-1.jpg', '-vf', 'crop=iw-mod(iw\,2):ih-mod(ih\,2)', 'still.mp4' ];
    BeamerReveal::IPC::Run::run( $cmd, 0, 8, $stilldir, "Error: ffmpeg run failed" );
    File::Copy::move( "$stilldir/still.mp4",
		      "$stilldir/../$stillid.mp4" );

    File::Path::rmtree( $stilldir ) unless( defined $self->{debug} );

    # all is done
    $logger->progress( $progressId, 5 );
  }
}

sub processVoiceoverBackOrders {
  my $self = shift;
  my ( $progressId ) = @_;

  my $logger = $BeamerReveal::Log::logger;
  ###############
  # treat stills

  my $totalNofBackOrders = scalar keys %{$self->{constructionBackOrders}->{voiceovers}};

  $logger->progress( $progressId, 1, 'reusing cached data', 1 ) unless $totalNofBackOrders;

  my $i = -1;
  while ( my ( $voiceoverid, $bo ) = each %{$self->{constructionBackOrders}->{voiceovers}} ) {
    ++$i;
    $logger->progress( $progressId, 0, "still @{[$i+1]}/$totalNofBackOrders", 5 );

    # write files
    my $tFileName = "$bo->{base}.txt";
    my $tFile = IO::File->new();
    $tFile->open( ">$tFileName" )
      or die( "Error: cannot open '$tFileName' for writing" );
    print $tFile $bo->{text};
    $tFile->close();

    my $sFileName = "$bo->{base}$bo->{ext}";
    my $cmd = [ $bo->{tool}, $tFileName, $sFileName, $bo->{voice} ];
    BeamerReveal::IPC::Run::run( $cmd, 0, 8, undef, "Error: Text-to-speech failed" );

    unlink $tFileName unless( defined $self->{debug} );

    # all is done
    $logger->progress( $progressId, 5 );
  }
}


# =method imageFromStore()

#   $path = $mm->imageFromStore( $image )

# Fetches the unique ID of the C<$image> and returns that ID (the filename of the oject in the media store). The object is put in back-order such that it can be copied later, using C.

# =over 4

# =item . C<$image>

# the $image file to store in the media store.

# =item . C<$path>

# the path to the image (in the media store)

# =back

# =cut

sub imageFromStore {
  my $self = shift;
  my ( $image, %optargs ) = @_;
  return $self->_fromStore( 'Images', $image, %optargs );
}


sub videoFromStore {
  my $self = shift;
  my ( $video, %optargs ) = @_;
  return $self->_fromStore( 'Videos', $video, %optargs );
}


sub iframeFromStore {
  my $self = shift;
  my ( $iframe, %optargs ) = @_;
  return $self->_fromStore( 'Iframes', $iframe , %optargs);
}


sub audioFromStore {
  my $self = shift;
  my ( $audio, %optargs ) = @_;
  return $self->_fromStore( 'Audios', $audio, %optargs );
}


sub _fromStore {
  my $self = shift;
  my ( $fileType, $fileName, %optargs ) = @_;

  my $logger = $BeamerReveal::Log::logger;

  my $mimeType = $self->{mtoracle}->mimeTypeOf( $fileName );

  if ( exists $optargs{to_embed} ) {
    my $file = do {
      local $/ = undef;
      open my $fh, "<". $fileName
	or $logger->fatal( "Cannot open $fileType-file $fileName to read" );
      <$fh>;
    };

    return ( $mimeType, encode_base64( $file ) );
  } else {
    # find extension
    $logger->log(0, "### " . $fileName );
    my ( undef, undef, $ext ) = File::Basename::fileparse( $fileName, qr/\.[^.]+$/ );

    # create store id
    my $id = Data::UUID->new();
    my $fullpathid;
    do {
      my $uuid = $id->create();
      $fullpathid = "$self->{base}/media/$fileType/@{[$id->to_string( $uuid )]}$ext";
    } until ( ! -e $fullpathid );

    # register backorder
    push @{$self->{copyBackOrders}},
      {
       type => $fileType,
       from => $fileName,
       to   => $self->{outputdir} . '/' . $fullpathid,
      };

    return ( $mimeType, $fullpathid );
  }
}



sub _rawFromStore {
  my $self = shift;
  my ( $fileType, $fileName, %optargs ) = @_;

  my $logger = $BeamerReveal::Log::logger;

  my $mimeType = $self->{mtoracle}->mimeTypeOf( $fileName );

  if ( exists $optargs{to_embed} ) {
    my $file = do {
      local $/ = undef;
      open my $fh, "<". $fileName
	or $logger->fatal( "Cannot open $fileType-file $fileName to read" );
      <$fh>;
    };
    return ( $mimeType, encode_base64( $file ) );

  } else {
    return ( $mimeType, $fileName );
  }
}


sub processCopyBackOrders {
  my $self = shift;
  my ( $progressId ) = @_;

  my $logger = $BeamerReveal::Log::logger;

  my $totalNofBackOrders = @{$self->{copyBackOrders}};

  for ( my $i = 0; $i < $totalNofBackOrders; ++$i ) {
    my $bo = $self->{copyBackOrders}->[$i];

    # verify if source file exists
    $logger->fatal( "Error: cannot find media file '$bo->{from}'\n" ) unless( -r $bo->{from} );

    # report progress and copy
    $logger->progress( $progressId, $i, "file $i/$totalNofBackOrders", $totalNofBackOrders );
    File::Copy::cp( $bo->{from}, $bo->{to} );
  }
  $logger->progress( $progressId, 1, "file $totalNofBackOrders/$totalNofBackOrders", 1 );
}



sub _animWork {
  my ( $plan, $nofCores, $fileContent, $animdir, $self, $animation, $sliceSize, $progress, $progressId ) = @_;

  my $cmd;
  my $logFile = IO::File->new();
  my $coreId = sprintf( '%0' . nofdigits( $nofCores ) . 'd', $plan->{nr} );
  my $logFileName = "$animdir/animation-$coreId-overall.log";
  $logFile->open( ">$logFileName" )
    or die( "Error: cannot open logfile $logFileName" );

  say $logFile "- Generating TeX file";
  # generate TeX -file
  my $perCoreContent = BeamerReveal::TemplateStore::stampTemplate
    ( $fileContent,
      {
       SLICESTART  => $plan->{slicestart},
       SLICESTOP   => $plan->{slicestop},
       NSTART      => $plan->{nstart},
      }
    );

  my $texFileName = "$animdir/animation-$coreId.tex";
  my $texFile = IO::File->new();
  $texFile->open( ">$texFileName" )
    or die( "Error: cannot open animation file '$texFileName' for writing\n" );
  print $texFile $perCoreContent;
  $texFile->close();

  say $logFile "- Running TeX";
  # run TeX
  $cmd = [ $self->{compiler},
	   "-halt-on-error", "-interaction=nonstopmode", "-output-directory=$animdir", "$texFileName" ];
  my $logFilename = $texFileName;
  $logFilename =~ s/\.tex$/.log/;

  my $logger = $BeamerReveal::Log::logger;
  my $counter = 0;
  BeamerReveal::IPC::Run::runsmart( $cmd, 1, qr/\[(\d+)\]/,
				    sub {
				      while ( scalar @_ ) {
					my $a = shift @_;
					while ( $a > $counter ) {
					  ++$counter;
					  $progress->incr();
					  if ( $nofCores == 1 ) {
					    $logger->progress( $progressId, $progress->get() );
					  }
					}
				      }
				    },
				    $coreId,
				    4,
				    undef, # directory
				    "Error: animation generation failed: check $logFilename"
				  );

  say $logFile "- Cropping PDF file";
  # run pdfcrop
  $cmd = [ $self->{pdfcrop}, '--hires', '--margins', '-0.5', "animation-$coreId.pdf" ];
  BeamerReveal::IPC::Run::run( $cmd, $coreId, 8, $animdir, "Error: pdfcrop run failed" );
  $progress->incr();

  # run pdftoppm
  my $xrange = 2 * int( $self->{presentationparameters}->{canvaswidth} * $animation->{width} );
  my $yrange = 2 * int( $self->{presentationparameters}->{canvasheight} * $animation->{height} );

  say $logFile "- Generating jpg files";
  $cmd = [ $self->{pdftoppm},
	   '-scale-to-x', "$xrange",
	   '-scale-to-y', '-1',
	   "animation-$coreId-crop.pdf", "./frame-$coreId", '-jpeg' ];
  BeamerReveal::IPC::Run::run( $cmd, $coreId, 8, $animdir, "Error: pdftoppm run failed" );
  $progress->incr();

  # correct for too short slicesize in filenames coming from pdftoppm
  say $logFile "- Cleaning up jpg files";
  my $currentDigitCnt = nofdigits( $plan->{slicestop} );
  my $desiredDigitCnt = nofdigits( $sliceSize );
  if ( $currentDigitCnt < $desiredDigitCnt ) {
    for ( my $i = 1; $i <= $plan->{slicestop}; ++$i ) {
      my $src = sprintf( "$animdir/frame-$coreId-%0${currentDigitCnt}d.jpg", $i );
      my $dst = sprintf( "$animdir/frame-$coreId-%0${desiredDigitCnt}d.jpg", $i );
      File::Copy::move( $src, $dst );
    }
  }
  $logFile->close();

  $progress->incr();
}


sub _stillWork {
  my ( $fileContent, $stilldir, $self, $still, $progressId ) = @_;

  my $logger = $BeamerReveal::Log::logger;

  my $cmd;
  my $logFile = IO::File->new();
  my $logFileName = "$stilldir/still.log";
  $logFile->open( ">$logFileName" )
    or die( "Error: cannot open logfile $logFileName" );

  say $logFile "- Generating TeX file";
  # generate TeX -file
  my $content = BeamerReveal::TemplateStore::stampTemplate
    ( $fileContent,
      {
       PROGRESS  => $still->{progress},
      }
    );

  my $texFileName = "$stilldir/still.tex";
  my $texFile = IO::File->new();
  $texFile->open( ">$texFileName" )
    or die( "Error: cannot open still file '$texFileName' for writing\n" );
  print $texFile $content;
  $texFile->close();
  $logger->progress( $progressId, 1 );

  say $logFile "- Running TeX";
  # run TeX
  $cmd = [ $self->{compiler},
	   "-halt-on-error", "-interaction=nonstopmode", "-output-directory=$stilldir", "$texFileName" ];
  my $logFilename = $texFileName;
  $logFilename =~ s/\.tex$/.log/;

  my $counter = 0;
  BeamerReveal::IPC::Run::runsmart( $cmd, 1, qr/\[(\d+)\]/,
				    sub {},
				    1,
				    4,
				    undef, # directory
				    "Error: still generation failed: check $logFilename"
				  );
  $logger->progress( $progressId, 2 );

  say $logFile "- Cropping PDF file";
  # run pdfcrop
  $cmd = [ $self->{pdfcrop}, '--hires', '--margins', '-0.5', "still.pdf" ];
  BeamerReveal::IPC::Run::run( $cmd, 1, 8, $stilldir, "Error: pdfcrop run failed" );
  $logger->progress( $progressId, 3 );

  # run pdftoppm
  my $xrange = 2 * int( $self->{presentationparameters}->{canvaswidth} * $still->{width} );
  my $yrange = 2 * int( $self->{presentationparameters}->{canvasheight} * $still->{height} );

  say $logFile "- Generating jpg file";
  $cmd = [ $self->{pdftoppm},
	   '-scale-to-x', "$xrange",
	   '-scale-to-y', '-1',
	   "still-crop.pdf", "./frame", '-jpeg' ];
  BeamerReveal::IPC::Run::run( $cmd, 1, 8, $stilldir, "Error: pdftoppm run failed" );
  $logFile->close();
  $logger->progress( $progressId, 4 );
}


1;

__END__