mdw@git.distorted.org.uk Git - dvdrip/blob - lib.c

   1 #include "lib.h"
   2
   3 const char *prog = "<unset>";
   4
   5 void set_prog(const char *p)
   6   { const char *q = strrchr(p, '/'); prog = q ? q + 1 : p; }
   7
   8 void vmoan(const char *fmt, va_list ap)
   9   { vmoan_syserr(0, fmt, ap); }
  10
  11 void vmoan_syserr(int err, const char *fmt, va_list ap)
  12 {
  13   fprintf(stderr, "%s: ", prog);
  14   vfprintf(stderr, fmt, ap);
  15   if (err) fprintf(stderr, ": %s", strerror(errno));
  16   fputc('\n', stderr);
  17 }
  18
  19 void moan(const char *fmt, ...)
  20   { va_list ap; va_start(ap, fmt); vmoan(fmt, ap); va_end(ap); }
  21
  22 void moan_syserr(int err, const char *fmt, ...)
  23   { va_list ap; va_start(ap, fmt); vmoan_syserr(err, fmt, ap); va_end(ap); }
  24
  25 void bail(const char *fmt, ...)
  26   { va_list ap; va_start(ap, fmt); vmoan(fmt, ap); va_end(ap); exit(2); }
  27
  28 void bail_syserr(int err, const char *fmt, ...)
  29 {
  30   va_list ap;
  31
  32   va_start(ap, fmt); vmoan_syserr(err, fmt, ap); va_end(ap);
  33   exit(2);
  34 }
  35
  36 double parse_float(const char **p_inout, unsigned f,
  37                    double min, double max, const char *what)
  38 {
  39   const char *p;
  40   char *q;
  41   double x;
  42   int err;
  43
  44   err = errno; errno = 0;
  45   p = *p_inout;
  46   x = strtod(p, &q);
  47   if (errno || x < min || x > max || (!(f&PNF_JUNK) && *q))
  48     bail("bad %s `%s'", what, p);
  49   *p_inout = q; errno = err;
  50   return (x);
  51 }
  52
  53 long parse_int(const char **p_inout, unsigned f,
  54                long min, long max, const char *what)
  55 {
  56   const char *p;
  57   char *q;
  58   long x;
  59   int err;
  60
  61   err = errno; errno = 0;
  62   p = *p_inout;
  63   x = strtoul(p, &q, 0);
  64   if (errno || x < min || x > max || (!(f&PNF_JUNK) && *q))
  65     bail("bad %s `%s'", what, p);
  66   *p_inout = q; errno = err;
  67   return (x);
  68 }
  69
  70 void sit(double t)
  71 {
  72   struct timeval tv;
  73   double whole = floor(t);
  74
  75   if (t) {
  76     tv.tv_sec = whole; tv.tv_usec = floor((t - whole)*1.0e6) + 1;
  77     if (select(0, 0, 0, 0, &tv) < 0) bail_syserr(errno, "failed to sleep");
  78   }
  79 }
  80
  81 void carefully_write(int fd, const void *buf, size_t sz)
  82 {
  83   const unsigned char *p = buf;
  84   ssize_t n;
  85
  86   if (fd < 0) return;
  87   while (sz) {
  88     n = write(fd, p, sz);
  89     if (n < 0) {
  90       if (errno == EINTR) continue;
  91       bail_syserr(errno, "failed to write to output file");
  92     }
  93     if (!n) bail("unexpected short write to output file");
  94     p += n; sz -= n;
  95   }
  96 }
  97
  98 void open_file_on_demand(const char *file, FILE **fp_inout, const char *what)
  99 {
 100   FILE *fp;
 101
 102   if (!*fp_inout) {
 103     fp = fopen(file, "w");
 104     if (!fp) bail_syserr(errno, "failed to open %s file `%s'", what, file);
 105     fprintf(fp, "## %s\n\n", what);
 106     *fp_inout = fp;
 107   }
 108 }
 109
 110 void check_write(FILE *fp, const char *what)
 111 {
 112   fflush(fp);
 113   if (ferror(fp)) bail_syserr(errno, "error writing %s file", what);
 114 }
 115
 116 void carefully_fclose(FILE *fp, const char *what)
 117 {
 118   if (fp && (ferror(fp) || fclose(fp)))
 119     bail_syserr(errno, "error writing %s file", what);
 120 }
 121
 122 off_t device_size(int fd, const char *file, int *blksz_out)
 123 {
 124   struct stat st;
 125   uint64_t volsz;
 126
 127   if (fstat(fd, &st))
 128     bail_syserr(errno, "failed to obtain status for `%s'", file);
 129   if (S_ISREG(st.st_mode))
 130     volsz = st.st_size;
 131   else if (S_ISBLK(st.st_mode)) {
 132     if (ioctl(fd, BLKGETSIZE64, &volsz))
 133       bail_syserr(errno, "failed to get volume size for `%s'", file);
 134     if (ioctl(fd, BLKSSZGET, blksz_out))
 135       bail_syserr(errno, "failed to get block size for `%s'", file);
 136   } else
 137     bail("can't read size for `%s': expected file or block device", file);
 138   return ((off_t)volsz);
 139 }
 140
 141 struct progress_state progress = PROGRESS_STATE_INIT;
 142 static struct banner_progress_item banner_progress;
 143
 144 static void render_banner_progress(struct progress_item *item,
 145                             struct progress_render_state *render)
 146 {
 147   struct banner_progress_item *bi = (struct banner_progress_item *)item;
 148
 149   progress_putleft(render, " %s", bi->msg);
 150   progress_shownotice(render, 4, 7);
 151 }
 152
 153 void show_banner(const char *msg)
 154 {
 155   banner_progress._base.render = render_banner_progress;
 156   progress_additem(&progress, &banner_progress._base);
 157   banner_progress.msg = msg;
 158   progress_update(&progress);
 159 }
 160
 161 void hide_banner(void)
 162 {
 163   if (!progress_removeitem(&progress, &banner_progress._base))
 164     progress_update(&progress);
 165 }
 166
 167 #ifdef notdef
 168 static void logfn(void *p, dvd_logger_level_t lev,
 169                   const char *fmt, va_list ap)
 170 {
 171   switch (lev) {
 172     case DVD_LOGGER_LEVEL_ERROR:
 173       fprintf("%s (libdvdread error): ", prog);
 174       break;
 175     case DVD_LOGGER_LEVEL_WARN:
 176       fprintf("%s (libdvdread warning): ", prog);
 177       break;
 178     default:
 179       return;
 180   }
 181   vfprintf(stderr, fmt, ap);
 182   fputc('\n', stderr);
 183 }
 184 static const dvd_logger_cb logger = { logfn };
 185 #endif
 186
 187 void open_dvd(const char *device, int mode,
 188               int *fd_out, dvd_reader_t **dvd_out)
 189 {
 190   int fd;
 191   dvd_reader_t *dvd;
 192   int bannerp = 0;
 193
 194   for (;;) {
 195     fd = open(device, mode);
 196     if (fd >= 0 || errno != ENOMEDIUM) break;
 197     if (!bannerp) {
 198       show_banner("Waiting for disc to be inserted...");
 199       bannerp = 1;
 200     }
 201     sit(0.2);
 202   }
 203   if (bannerp) hide_banner();
 204   if (fd < 0) bail_syserr(errno, "failed to open device `%s'", device);
 205   if (dvd_out) {
 206 #ifdef notdef
 207     dvd = DVDOpen2(0, &logger, device);
 208 #else
 209     dvd = DVDOpen(device);
 210 #endif
 211     if (!dvd) bail("failed to open DVD on `%s'", device);
 212     *dvd_out = dvd;
 213   }
 214   if (fd_out) *fd_out = fd;
 215   else close(fd);
 216 }
 217
 218 void store_filename(char *buf, ident id)
 219 {
 220   switch (id_kind(id)) {
 221     case RAW:
 222       sprintf(buf, "#<raw device>");
 223       break;
 224     case IFO:
 225       if (!id_title(id)) sprintf(buf, "/VIDEO_TS/VIDEO_TS.IFO");
 226       else sprintf(buf, "/VIDEO_TS/VTS_%02u_0.IFO", id_title(id));
 227       break;
 228     case BUP:
 229       if (!id_title(id)) sprintf(buf, "/VIDEO_TS/VIDEO_TS.BUP");
 230       else sprintf(buf, "/VIDEO_TS/VTS_%02u_0.BUP", id_title(id));
 231       break;
 232     case VOB:
 233       if (!id_title(id)) sprintf(buf, "/VIDEO_TS/VIDEO_TS.VOB");
 234       else
 235         sprintf(buf, "/VIDEO_TS/VTS_%02u_%u.VOB", id_title(id), id_part(id));
 236       break;
 237     default:
 238       abort();
 239   }
 240 }
 241
 242 static char *copy_string(char *p, const char *q)
 243 {
 244   while (*q) *p++ = *q++;
 245   *p = 0; return (p);
 246 }
 247
 248 static char *copy_hex(char *p, const unsigned char *q, size_t sz)
 249 {
 250   while (sz) {
 251     sprintf(p, "%02x", *q);
 252     p += 2; q++; sz--;
 253   }
 254   return (p);
 255 }
 256
 257 int dvd_id(char *p, dvd_reader_t *dvd, unsigned f, const char *file)
 258 {
 259   char volid[33];
 260   unsigned char volsetid[16], discid[16];
 261   int rc;
 262   size_t n;
 263
 264   rc = DVDUDFVolumeInfo(dvd,
 265                         volid, sizeof(volid),
 266                         volsetid, sizeof(volsetid));
 267   if (!rc) {
 268     p = copy_string(p, volid);
 269     *p++ = '-';
 270     for (n = sizeof(volsetid); n && !volsetid[n - 1]; n--);
 271     p = copy_hex(p, volsetid, n);
 272   } else if (f&DIF_MUSTVOLINF) {
 273     if (file) moan("failed to read volume info for `%s'", file);
 274     else moan("failed to read volume info");
 275     return (-1);
 276   } else
 277     p = copy_string(p, "<error reading volume info>");
 278
 279   *p++ = ':';
 280   rc = DVDDiscID(dvd, discid);
 281   if (!rc)
 282     p = copy_hex(p, discid, sizeof(discid));
 283   else if (f&DIF_MUSTIFOHASH) {
 284     if (file) moan("failed to determine disc id of `%s'", file);
 285     else moan("failed to determine disc id");
 286     return (-1);
 287   } else
 288     p = copy_string(p, "<error reading disc-id>");
 289
 290   return (0);
 291 }