Merge branch 'master' of git.distorted.org.uk:~mdw/publish/public-git/dvdrip

[dvdrip] / lib.c

#include "lib.h"

const char *prog = "<unset>";

void set_prog(const char *p)
  { const char *q = strrchr(p, '/'); prog = q ? q + 1 : p; }

void vmoan(const char *fmt, va_list ap)
  { vmoan_syserr(0, fmt, ap); }

void vmoan_syserr(int err, const char *fmt, va_list ap)
{
  fprintf(stderr, "%s: ", prog);
  vfprintf(stderr, fmt, ap);
  if (err) fprintf(stderr, ": %s", strerror(errno));
  fputc('\n', stderr);
}

void moan(const char *fmt, ...)
  { va_list ap; va_start(ap, fmt); vmoan(fmt, ap); va_end(ap); }

void moan_syserr(int err, const char *fmt, ...)
  { va_list ap; va_start(ap, fmt); vmoan_syserr(err, fmt, ap); va_end(ap); }

void bail(const char *fmt, ...)
  { va_list ap; va_start(ap, fmt); vmoan(fmt, ap); va_end(ap); exit(2); }

void bail_syserr(int err, const char *fmt, ...)
{
  va_list ap;

  va_start(ap, fmt); vmoan_syserr(err, fmt, ap); va_end(ap);
  exit(2);
}

double parse_float(const char **p_inout, unsigned f,
		   double min, double max, const char *what)
{
  const char *p;
  char *q;
  double x;
  int err;

  err = errno; errno = 0;
  p = *p_inout;
  x = strtod(p, &q);
  if (errno || x < min || x > max || (!(f&PNF_JUNK) && *q))
    bail("bad %s `%s'", what, p);
  *p_inout = q; errno = err;
  return (x);
}

long parse_int(const char **p_inout, unsigned f,
	       long min, long max, const char *what)
{
  const char *p;
  char *q;
  long x;
  int err;

  err = errno; errno = 0;
  p = *p_inout;
  x = strtoul(p, &q, 0);
  if (errno || x < min || x > max || (!(f&PNF_JUNK) && *q))
    bail("bad %s `%s'", what, p);
  *p_inout = q; errno = err;
  return (x);
}

void sit(double t)
{
  struct timeval tv;
  double whole = floor(t);

  if (t) {
    tv.tv_sec = whole; tv.tv_usec = floor((t - whole)*1.0e6) + 1;
    if (select(0, 0, 0, 0, &tv) < 0) bail_syserr(errno, "failed to sleep");
  }
}

void carefully_write(int fd, const void *buf, size_t sz)
{
  const unsigned char *p = buf;
  ssize_t n;

  if (fd < 0) return;
  while (sz) {
    n = write(fd, p, sz);
    if (n < 0) {
      if (errno == EINTR) continue;
      bail_syserr(errno, "failed to write to output file");
    }
    if (!n) bail("unexpected short write to output file");
    p += n; sz -= n;
  }
}

void open_file_on_demand(const char *file, FILE **fp_inout, const char *what)
{
  FILE *fp;

  if (!*fp_inout) {
    fp = fopen(file, "w");
    if (!fp) bail_syserr(errno, "failed to open %s file `%s'", what, file);
    fprintf(fp, "## %s\n\n", what);
    *fp_inout = fp;
  }
}

void check_write(FILE *fp, const char *what)
{
  fflush(fp);
  if (ferror(fp)) bail_syserr(errno, "error writing %s file", what);
}

void carefully_fclose(FILE *fp, const char *what)
{
  if (fp && (ferror(fp) || fclose(fp)))
    bail_syserr(errno, "error writing %s file", what);
}

off_t device_size(int fd, const char *file, int *blksz_out)
{
  struct stat st;
  uint64_t volsz;

  if (fstat(fd, &st))
    bail_syserr(errno, "failed to obtain status for `%s'", file);
  if (S_ISREG(st.st_mode))
    volsz = st.st_size;
  else if (S_ISBLK(st.st_mode)) {
    if (ioctl(fd, BLKGETSIZE64, &volsz))
      bail_syserr(errno, "failed to get volume size for `%s'", file);
    if (ioctl(fd, BLKSSZGET, blksz_out))
      bail_syserr(errno, "failed to get block size for `%s'", file);
  } else
    bail("can't read size for `%s': expected file or block device", file);
  return ((off_t)volsz);
}

void store_filename(char *buf, ident id)
{
  switch (id_kind(id)) {
    case RAW:
      sprintf(buf, "#<raw device>");
      break;
    case IFO:
      if (!id_title(id)) sprintf(buf, "/VIDEO_TS/VIDEO_TS.IFO");
      else sprintf(buf, "/VIDEO_TS/VTS_%02u_0.IFO", id_title(id));
      break;
    case BUP:
      if (!id_title(id)) sprintf(buf, "/VIDEO_TS/VIDEO_TS.BUP");
      else sprintf(buf, "/VIDEO_TS/VTS_%02u_0.BUP", id_title(id));
      break;
    case VOB:
      if (!id_title(id)) sprintf(buf, "/VIDEO_TS/VIDEO_TS.VOB");
      else
	sprintf(buf, "/VIDEO_TS/VTS_%02u_%u.VOB", id_title(id), id_part(id));
      break;
    default:
      abort();
  }
}

static char *copy_string(char *p, const char *q)
{
  while (*q) *p++ = *q++;
  *p = 0; return (p);
}

static char *copy_hex(char *p, const unsigned char *q, size_t sz)
{
  while (sz) {
    sprintf(p, "%02x", *q);
    p += 2; q++; sz--;
  }
  return (p);
}

int dvd_id(char *p, dvd_reader_t *dvd, unsigned f, const char *file)
{
  char volid[33];
  unsigned char volsetid[16], discid[16];
  int rc;
  size_t n;

  rc = DVDUDFVolumeInfo(dvd,
			volid, sizeof(volid),
			volsetid, sizeof(volsetid));
  if (!rc) {
    p = copy_string(p, volid);
    *p++ = '-';
    for (n = sizeof(volsetid); n && !volsetid[n - 1]; n--);
    p = copy_hex(p, volsetid, n);
  } else if (f&DIF_MUSTVOLINF) {
    if (file) moan("failed to read volume info for `%s'", file);
    else moan("failed to read volume info");
    return (-1);
  } else
    p = copy_string(p, "<error reading volume info>");

  *p++ = ':';
  rc = DVDDiscID(dvd, discid);
  if (!rc)
    p = copy_hex(p, discid, sizeof(discid));
  else if (f&DIF_MUSTIFOHASH) {
    if (file) moan("failed to determine disc id of `%s'", file);
    else moan("failed to determine disc id");
    return (-1);
  } else
    p = copy_string(p, "<error reading disc-id>");

  return (0);
}

struct progress_state progress = PROGRESS_STATE_INIT;
static struct banner_progress_item banner_progress;

static void render_banner_progress(struct progress_item *item,
			    struct progress_render_state *render)
{
  struct banner_progress_item *bi = (struct banner_progress_item *)item;

  progress_putleft(render, " %s", bi->msg);
  progress_shownotice(render, 4, 7);
}

void show_banner(const char *msg)
{
  banner_progress._base.render = render_banner_progress;
  progress_additem(&progress, &banner_progress._base);
  banner_progress.msg = msg;
  progress_update(&progress);
}

void hide_banner(void)
{
  if (!progress_removeitem(&progress, &banner_progress._base))
    progress_update(&progress);
}

#ifdef notdef
static void logfn(void *p, dvd_logger_level_t lev,
		  const char *fmt, va_list ap)
{
  switch (lev) {
    case DVD_LOGGER_LEVEL_ERROR:
      fprintf("%s (libdvdread error): ", prog);
      break;
    case DVD_LOGGER_LEVEL_WARN:
      fprintf("%s (libdvdread warning): ", prog);
      break;
    default:
      return;
  }
  vfprintf(stderr, fmt, ap);
  fputc('\n', stderr);
}
static const dvd_logger_cb logger = { logfn };
#endif

void open_dvd(const char *device, int mode,
	      int *fd_out, dvd_reader_t **dvd_out)
{
  int fd;
  dvd_reader_t *dvd;
  int bannerp = 0;

  for (;;) {
    fd = open(device, mode);
    if (fd >= 0 || errno != ENOMEDIUM) break;
    if (!bannerp) {
      show_banner("Waiting for disc to be inserted...");
      bannerp = 1;
    }
    sit(0.2);
  }
  if (bannerp) hide_banner();
  if (fd < 0) bail_syserr(errno, "failed to open device `%s'", device);
  if (dvd_out) {
#ifdef notdef
    dvd = DVDOpen2(0, &logger, device);
#else
    dvd = DVDOpen(device);
#endif
    if (!dvd) bail("failed to open DVD on `%s'", device);
    *dvd_out = dvd;
  }
  if (fd_out) *fd_out = fd;
  else close(fd);
}