webmize.c

#include <sys/param.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fts.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <assert.h>
#include <utime.h>
#include <sys/wait.h>
#include <signal.h>

#define VIDEO_BITRATE "1M"
#define FFMPEG "/usr/bin/ffmpeg"

static int force_update = 0;

#define ERROR(_fmt_, ...) fprintf(stderr, "*** ERROR ***: %s:%d " _fmt_ "\n", __FILE__, __LINE__, ##__VA_ARGS__ )
#define WARNING(_fmt_, ...) fprintf(stderr, "*** WARNING ***: %s:%d " _fmt_ "\n", __FILE__, __LINE__, ##__VA_ARGS__ )
#define MESSAGE(_fmt_, ...) fprintf(stdout, _fmt_ "\n", ##__VA_ARGS__ )

static int
is_video(FTSENT *ftsent)
{
  const char * const ext[] = {
    ".avi", ".AVI",
    ".mov", ".MOV",
    ".3gp", ".3GP",
    ".mp4", ".MP4",
    ".asf", ".ASF"};
  unsigned int i;
  size_t len = ftsent->fts_namelen;
  if ( len <= 4 )
    return 0;
  for ( i = 0 ; i < sizeof(ext)/sizeof(*ext) ; ++i )
    {
      assert(strlen(ext[i]) == 4);
      if ( 0 == strcmp(ftsent->fts_name+(len-4),ext[i]) )
	return 1;
    }
  
  return 0;
}

static int
getmtime(const char *dir, time_t *timep)
{
  struct stat st;
  int ret;
  ret = stat(dir, &st);
  if ( ret < 0 )
    {
      ERROR("stat(%s): %s", dir, strerror(errno));
      return ret;
    }
  if (timep)
    *timep = st.st_mtim.tv_sec;
  return 0;
}

static int
setmtime(const char *dir, time_t time)
{
  struct stat st;
  int ret;
  ret = stat(dir, &st);
  if ( ret < 0 )
    {
      ERROR("stat(%s): %s", dir, strerror(errno));
      return ret;
    }
  struct utimbuf utim = {
    .actime = st.st_atim.tv_sec,
    .modtime = time,
  };
  
  ret = utime(dir, &utim);
  if ( ret < 0 )
    ERROR("utime(%s): %s", dir, strerror(errno));
  return ret;
}

static int
probe_setmtime(const char *dir, time_t *dt)
{
  int ret;
  ret = getmtime(dir, dt);
  if ( ret < 0 )
    return ret;
  ret = setmtime(dir, *dt + 1);
  if ( ret < 0 )
    return ret;
  ret = setmtime(dir, *dt);
  return ret;
}


const char *garbage = NULL;
const char *dir_to_restore = NULL;
time_t     time_to_restore = 0;

static void cleanup(int sig)
{
  if ( garbage )
    {
      unlink(garbage);
      ERROR("signal received: %s unlinked", garbage);
    }
  garbage = NULL;
  if ( dir_to_restore )
    {
      setmtime(dir_to_restore, time_to_restore);
      ERROR("signal received: %s timestamp restored", dir_to_restore);
    }
  dir_to_restore = NULL;
  abort();
}

static int
do_convert(const char * from, const char *to)
{
  const char * const argv[] =
    { FFMPEG, "-loglevel", "error", "-i", from, "-b:v", VIDEO_BITRATE, to, NULL };
  int pid;
  int cpid;
  int ret;
  int child_status;
  garbage = to;
  pid = fork();
  switch(pid)
    {
    case 0:
      ret = execv(FFMPEG, (char**)argv);
      if ( ret < 0 )
	{
	  ERROR("Failed to execute " FFMPEG ": %s", strerror(errno));
	}
      abort();
    case -1:
      ERROR("Failed to fork");
      return 1;
    default:
      do
	{
	  cpid = wait(&ret);
	  assert( pid == cpid );
	}
      while ( !WIFEXITED(ret) );
      child_status = WEXITSTATUS(ret);
      if ( child_status != 0 )
	{
	  ERROR("failed to convert %s", from);
	  unlink(to);
	}
      garbage = NULL;
      return child_status;
    }
  abort();
}

static int
convert_video(FTSENT *ftsent)
{
  char dir[MAXPATHLEN];
  char webm_name[MAXPATHLEN] = {};
  int offset;
  char webm[MAXPATHLEN];
  char arch[MAXPATHLEN];
  char *last_slash;

  strncpy(dir, ftsent->fts_path, sizeof(dir));
  last_slash = rindex(dir, '/');
  assert( NULL != last_slash );
  *last_slash = '\0';
  
  time_t dt;
  int ret;

  ret = probe_setmtime(dir, &dt);
  if ( ret < 0 )
    return ret;
  dir_to_restore = dir;
  time_to_restore = dt;
  
  if ( '.' == ftsent->fts_name[0] )
    {
      offset = 1;
      strncpy(arch, ftsent->fts_path, sizeof(arch));
    }
  else
    {
      offset = 0;
      snprintf(arch, sizeof(arch), "%s/.%s", dir, ftsent->fts_name);
      struct stat st;
      ret = stat(arch, &st);
      if ( 0 == ret )
	{
	  char target[MAXPATHLEN];
	  snprintf(target, sizeof(target), "%s~", arch);
	  WARNING("%s already exists, %s moved as %s", arch, ftsent->fts_path, target);
	  ret = rename(ftsent->fts_path, target);
	  if ( ret < 0 )
	    {
	      ERROR("rename(%s, %s): %s", ftsent->fts_path, target, strerror(errno));
	      ret = 1;
	      goto end;
	    }
	  ret = 0;
	  goto end;
	}
      else if ( errno != ENOENT )
	{
	  ERROR("stat(%s): %s", arch, strerror(errno));
	  ret = 1;
	  goto end;
	}
      ret = rename(ftsent->fts_path, arch);
      if ( ret < 0 )
	{
	  ERROR("rename(%s, %s): %s", ftsent->fts_path, arch, strerror(errno));
	  ret = 1;
	  goto end;
	}
    }
  memcpy(webm_name, ftsent->fts_name + offset, ftsent->fts_namelen-4-offset);
  snprintf(webm, sizeof(webm), "%s/%s.webm", dir, webm_name);

  struct stat st_webm, st_arch;

  ret = stat(webm, &st_webm);
  if ( ret < 0 )
    {
      if ( errno != ENOENT )
	{
	  ERROR("stat(%s): %s", webm, strerror(errno));
	  ret = 1;
	  goto end;
	}
      memset(&st_webm, 0, sizeof(st_webm));
    }
  ret = stat(arch, &st_arch);
  if ( ret < 0 )
    {
      ERROR("stat(%s): %s", arch, strerror(errno));
      ret = 1;
      goto end;
    }

  if ( st_arch.st_mtim.tv_sec >= st_webm.st_mtim.tv_sec ||
       force_update )
    {
      MESSAGE("UPDATE OF: %s", arch);
      ret = do_convert(arch, webm);
    }
 end:
  if ( setmtime(dir, dt) != 0 )
    {
      ERROR("Failed to restore %s timestamp", dir);
      return 1;
    }
  dir_to_restore = NULL;
  time_to_restore = 0;
  return ret; 
}

static int
recurse(const char * path)
{
  FTS *fts;
  FTSENT *ftsent;
  char * const apath[] = { strdup(path), NULL };
  fts = fts_open(apath,FTS_NOCHDIR|FTS_NOSTAT|FTS_COMFOLLOW, NULL);
  if ( NULL == fts)
    {
      ERROR("fts_open(%s) failed", path);
      return EXIT_FAILURE;
    }
  while ((ftsent = fts_read(fts)))
    switch (ftsent->fts_info)
      {
      case FTS_F:
	if ( is_video(ftsent) )
	  if ( convert_video(ftsent) )
	    ERROR("conversion failed: %s", ftsent->fts_path);
	break;
      case FTS_SLNONE:
      case FTS_NS:
      case FTS_ERR:
	ERROR("fts_read: %s (%s)", ftsent->fts_path, strerror(errno));
      default:(void)0;
      }
  fts_close(fts);
  free(apath[0]);
  return EXIT_SUCCESS;
}

int main(int argc, char **argv)
{
  if ( 2 != argc )
    {
      ERROR("usage: %s <BASE PATH>\n", argv[0]);
      exit(EXIT_FAILURE);
    }

  if ( getenv("FORCE_UPDATE") )
    force_update = 1;
  
  signal(SIGTERM, cleanup);
  signal(SIGQUIT, cleanup);
  signal(SIGINT, cleanup);
  signal(SIGUSR1, cleanup);
  signal(SIGUSR2, cleanup);
  
  return recurse(argv[1]);
}