changeset 27:98951f8ec89c src

cosmetics: Sync indentation and similar changes from libdvdread 0.9.5.
author diego
date Thu, 25 Sep 2008 09:17:42 +0000
parents 0d82d0f30c98
children 96cfd8fb3b3d
files bswap.h dvd_input.c dvd_reader.c dvd_udf.c dvdread_internal.h ifo_print.c ifo_read.c ifo_types.h md5.c md5.h nav_print.c nav_read.c nav_types.h
diffstat 13 files changed, 1188 insertions(+), 1186 deletions(-) [+]
line wrap: on
line diff
--- a/bswap.h	Tue Sep 23 09:14:45 2008 +0000
+++ b/bswap.h	Thu Sep 25 09:17:42 2008 +0000
@@ -74,15 +74,15 @@
  */
 
 #elif defined(__FreeBSD__) || defined(__sun) || defined(__bsdi__) || defined(WIN32) || defined(__CYGWIN__) || defined(__BEOS__)
-#define B2N_16(x) \
- x = ((((x) & 0xff00) >> 8) | \
+#define B2N_16(x)                             \
+ x = ((((x) & 0xff00) >> 8) |                 \
       (((x) & 0x00ff) << 8))
-#define B2N_32(x) \
- x = ((((x) & 0xff000000) >> 24) | \
-      (((x) & 0x00ff0000) >>  8) | \
-      (((x) & 0x0000ff00) <<  8) | \
+#define B2N_32(x)                             \
+ x = ((((x) & 0xff000000) >> 24) |            \
+      (((x) & 0x00ff0000) >>  8) |            \
+      (((x) & 0x0000ff00) <<  8) |            \
       (((x) & 0x000000ff) << 24))
-#define B2N_64(x) \
+#define B2N_64(x)                             \
  x = ((((x) & 0xff00000000000000ULL) >> 56) | \
       (((x) & 0x00ff000000000000ULL) >> 40) | \
       (((x) & 0x0000ff0000000000ULL) >> 24) | \
--- a/dvd_input.c	Tue Sep 23 09:14:45 2008 +0000
+++ b/dvd_input.c	Thu Sep 25 09:17:42 2008 +0000
@@ -198,7 +198,7 @@
 
   pos = lseek(dev->fd, (off_t)blocks * (off_t)DVD_VIDEO_LB_LEN, SEEK_SET);
   if(pos < 0) {
-      return pos;
+    return pos;
   }
   /* assert pos % DVD_VIDEO_LB_LEN == 0 */
   return (int) (pos / DVD_VIDEO_LB_LEN);
--- a/dvd_reader.c	Tue Sep 23 09:14:45 2008 +0000
+++ b/dvd_reader.c	Thu Sep 25 09:17:42 2008 +0000
@@ -53,7 +53,7 @@
 #define lseek64 _lseeki64
 #endif
 
-#if defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) || defined(__bsdi__)|| defined(__DARWIN__)
+#if defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) || defined(__bsdi__) || defined(__DARWIN__)
 #define SYS_BSD 1
 #endif
 
@@ -73,49 +73,49 @@
 #define DEFAULT_UDF_CACHE_LEVEL 1
 
 struct dvd_reader_s {
-    /* Basic information. */
-    int isImageFile;
+  /* Basic information. */
+  int isImageFile;
 
-    /* Hack for keeping track of the css status.
-     * 0: no css, 1: perhaps (need init of keys), 2: have done init */
-    int css_state;
-    int css_title; /* Last title that we have called dvdinpute_title for. */
+  /* Hack for keeping track of the css status.
+   * 0: no css, 1: perhaps (need init of keys), 2: have done init */
+  int css_state;
+  int css_title; /* Last title that we have called dvdinpute_title for. */
 
-    /* Information required for an image file. */
-    dvd_input_t dev;
+  /* Information required for an image file. */
+  dvd_input_t dev;
 
-    /* Information required for a directory path drive. */
-    char *path_root;
+  /* Information required for a directory path drive. */
+  char *path_root;
 
-    /* Filesystem cache */
-    int udfcache_level; /* 0 - turned off, 1 - on */
-    void *udfcache;
+  /* Filesystem cache */
+  int udfcache_level; /* 0 - turned off, 1 - on */
+  void *udfcache;
 };
 
 #define TITLES_MAX 9
 
 struct dvd_file_s {
-    /* Basic information. */
-    dvd_reader_t *dvd;
+  /* Basic information. */
+  dvd_reader_t *dvd;
 
-    /* Hack for selecting the right css title. */
-    int css_title;
+  /* Hack for selecting the right css title. */
+  int css_title;
 
-    /* Information required for an image file. */
-    uint32_t lb_start;
-    uint32_t seek_pos;
+  /* Information required for an image file. */
+  uint32_t lb_start;
+  uint32_t seek_pos;
 
-    /* Information required for a directory path drive. */
-    size_t title_sizes[ TITLES_MAX ];
-    dvd_input_t title_devs[ TITLES_MAX ];
+  /* Information required for a directory path drive. */
+  size_t title_sizes[ TITLES_MAX ];
+  dvd_input_t title_devs[ TITLES_MAX ];
 
-    /* Calculated at open-time, size in blocks. */
-    ssize_t filesize;
+  /* Calculated at open-time, size in blocks. */
+  ssize_t filesize;
 };
 
 int UDFReadBlocksRaw( dvd_reader_t *device, uint32_t lb_number,
-                     size_t block_count, unsigned char *data,
-                     int encrypted );
+                      size_t block_count, unsigned char *data,
+                      int encrypted );
 
 /**
  * Set the level of caching on udf
@@ -156,68 +156,67 @@
 /* Loop over all titles and call dvdcss_title to crack the keys. */
 static int initAllCSSKeys( dvd_reader_t *dvd )
 {
-    struct timeval all_s, all_e;
-    struct timeval t_s, t_e;
-    char filename[ MAX_UDF_FILE_NAME_LEN ];
-    uint32_t start, len;
-    int title;
+  struct timeval all_s, all_e;
+  struct timeval t_s, t_e;
+  char filename[ MAX_UDF_FILE_NAME_LEN ];
+  uint32_t start, len;
+  int title;
 
-    char *nokeys_str = getenv("DVDREAD_NOKEYS");
-    if(nokeys_str != NULL)
-      return 0;
+  char *nokeys_str = getenv("DVDREAD_NOKEYS");
+  if(nokeys_str != NULL)
+    return 0;
 
-    fprintf( stderr, "\n" );
-    fprintf( stderr, "libdvdread: Attempting to retrieve all CSS keys\n" );
-    fprintf( stderr, "libdvdread: This can take a _long_ time, "
-             "please be patient\n\n" );
-
-    gettimeofday(&all_s, NULL);
+  fprintf( stderr, "\n" );
+  fprintf( stderr, "libdvdread: Attempting to retrieve all CSS keys\n" );
+  fprintf( stderr, "libdvdread: This can take a _long_ time, "
+           "please be patient\n\n" );
+  gettimeofday(&all_s, NULL);
 
-    for( title = 0; title < 100; title++ ) {
-        gettimeofday( &t_s, NULL );
-        if( title == 0 ) {
-            sprintf( filename, "/VIDEO_TS/VIDEO_TS.VOB" );
-        } else {
-            sprintf( filename, "/VIDEO_TS/VTS_%02d_%d.VOB", title, 0 );
-        }
-        start = UDFFindFile( dvd, filename, &len );
-        if( start != 0 && len != 0 ) {
-            /* Perform CSS key cracking for this title. */
-            fprintf( stderr, "libdvdread: Get key for %s at 0x%08x\n",
-                     filename, start );
-            if( dvdinput_title( dvd->dev, (int)start ) < 0 ) {
-                fprintf( stderr, "libdvdread: Error cracking CSS key for %s (0x%08x)\n", filename, start);
-            }
-            gettimeofday( &t_e, NULL );
-            fprintf( stderr, "libdvdread: Elapsed time %ld\n",
-                     (long int) t_e.tv_sec - t_s.tv_sec );
-        }
+  for( title = 0; title < 100; title++ ) {
+    gettimeofday( &t_s, NULL );
+    if( title == 0 ) {
+      sprintf( filename, "/VIDEO_TS/VIDEO_TS.VOB" );
+    } else {
+      sprintf( filename, "/VIDEO_TS/VTS_%02d_%d.VOB", title, 0 );
+    }
+    start = UDFFindFile( dvd, filename, &len );
+    if( start != 0 && len != 0 ) {
+      /* Perform CSS key cracking for this title. */
+      fprintf( stderr, "libdvdread: Get key for %s at 0x%08x\n",
+               filename, start );
+      if( dvdinput_title( dvd->dev, (int)start ) < 0 ) {
+        fprintf( stderr, "libdvdread: Error cracking CSS key for %s (0x%08x)\n", filename, start);
+      }
+      gettimeofday( &t_e, NULL );
+      fprintf( stderr, "libdvdread: Elapsed time %ld\n",
+               (long int) t_e.tv_sec - t_s.tv_sec );
+    }
 
-        if( title == 0 ) continue;
+    if( title == 0 ) continue;
 
-        gettimeofday( &t_s, NULL );
-        sprintf( filename, "/VIDEO_TS/VTS_%02d_%d.VOB", title, 1 );
-        start = UDFFindFile( dvd, filename, &len );
-        if( start == 0 || len == 0 ) break;
+    gettimeofday( &t_s, NULL );
+    sprintf( filename, "/VIDEO_TS/VTS_%02d_%d.VOB", title, 1 );
+    start = UDFFindFile( dvd, filename, &len );
+    if( start == 0 || len == 0 ) break;
 
-        /* Perform CSS key cracking for this title. */
-        fprintf( stderr, "libdvdread: Get key for %s at 0x%08x\n",
-                 filename, start );
-        if( dvdinput_title( dvd->dev, (int)start ) < 0 ) {
-            fprintf( stderr, "libdvdread: Error cracking CSS key for %s (0x%08x)!!\n", filename, start);
-        }
-        gettimeofday( &t_e, NULL );
-        fprintf( stderr, "libdvdread: Elapsed time %ld\n",
-                 (long int) t_e.tv_sec - t_s.tv_sec );
+    /* Perform CSS key cracking for this title. */
+    fprintf( stderr, "libdvdread: Get key for %s at 0x%08x\n",
+             filename, start );
+    if( dvdinput_title( dvd->dev, (int)start ) < 0 ) {
+      fprintf( stderr, "libdvdread: Error cracking CSS key for %s (0x%08x)!!\n", filename, start);
     }
-    title--;
+    gettimeofday( &t_e, NULL );
+    fprintf( stderr, "libdvdread: Elapsed time %ld\n",
+             (long int) t_e.tv_sec - t_s.tv_sec );
+  }
+  title--;
 
-    fprintf( stderr, "libdvdread: Found %d VTS's\n", title );
-    gettimeofday(&all_e, NULL);
-    fprintf( stderr, "libdvdread: Elapsed time %ld\n",
-             (long int) all_e.tv_sec - all_s.tv_sec );
+  fprintf( stderr, "libdvdread: Found %d VTS's\n", title );
+  gettimeofday(&all_e, NULL);
+  fprintf( stderr, "libdvdread: Elapsed time %ld\n",
+           (long int) all_e.tv_sec - all_s.tv_sec );
 
-    return 0;
+  return 0;
 }
 
 
@@ -227,60 +226,59 @@
  */
 static dvd_reader_t *DVDOpenImageFile( const char *location, int have_css )
 {
-    dvd_reader_t *dvd;
-    dvd_input_t dev;
+  dvd_reader_t *dvd;
+  dvd_input_t dev;
 
-    dev = dvdinput_open( location );
-    if( !dev ) {
-        fprintf( stderr, "libdvdread: Can't open %s for reading\n", location );
-        return NULL;
-    }
+  dev = dvdinput_open( location );
+  if( !dev ) {
+    fprintf( stderr, "libdvdread: Can't open %s for reading\n", location );
+    return NULL;
+  }
 
-    dvd = (dvd_reader_t *) malloc( sizeof( dvd_reader_t ) );
-    if( !dvd ) {
-        dvdinput_close(dev);
-        return NULL;
-    }
-    dvd->isImageFile = 1;
-    dvd->dev = dev;
-    dvd->path_root = NULL;
+  dvd = (dvd_reader_t *) malloc( sizeof( dvd_reader_t ) );
+  if( !dvd ) {
+    dvdinput_close(dev);
+    return NULL;
+  }
+  dvd->isImageFile = 1;
+  dvd->dev = dev;
+  dvd->path_root = NULL;
 
-    dvd->udfcache_level = DEFAULT_UDF_CACHE_LEVEL;
-    dvd->udfcache = NULL;
+  dvd->udfcache_level = DEFAULT_UDF_CACHE_LEVEL;
+  dvd->udfcache = NULL;
 
-    if( have_css ) {
-      /* Only if DVDCSS_METHOD = title, a bit if it's disc or if
-       * DVDCSS_METHOD = key but region missmatch. Unfortunaly we
-       * don't have that information. */
+  if( have_css ) {
+    /* Only if DVDCSS_METHOD = title, a bit if it's disc or if
+     * DVDCSS_METHOD = key but region missmatch. Unfortunaly we
+     * don't have that information. */
 
-      dvd->css_state = 1; /* Need key init. */
-    }
-    dvd->css_title = 0;
+    dvd->css_state = 1; /* Need key init. */
+  }
+  dvd->css_title = 0;
 
-    return dvd;
+  return dvd;
 }
 
 static dvd_reader_t *DVDOpenPath( const char *path_root )
 {
-    dvd_reader_t *dvd;
+  dvd_reader_t *dvd;
 
-    dvd = (dvd_reader_t *) malloc( sizeof( dvd_reader_t ) );
-    if( !dvd ) return NULL;
-    dvd->isImageFile = 0;
-    dvd->dev = 0;
-    dvd->path_root = strdup( path_root );
-    if(!dvd->path_root) {
-      free(dvd);
-      return 0;
-    }
+  dvd = (dvd_reader_t *) malloc( sizeof( dvd_reader_t ) );
+  if( !dvd ) return NULL;
+  dvd->isImageFile = 0;
+  dvd->dev = 0;
+  dvd->path_root = strdup( path_root );
+  if(!dvd->path_root) {
+    free(dvd);
+    return 0;
+  }
+  dvd->udfcache_level = DEFAULT_UDF_CACHE_LEVEL;
+  dvd->udfcache = NULL;
 
-    dvd->udfcache_level = DEFAULT_UDF_CACHE_LEVEL;
-    dvd->udfcache = NULL;
+  dvd->css_state = 0; /* Only used in the UDF path */
+  dvd->css_title = 0; /* Only matters in the UDF path */
 
-    dvd->css_state = 0; /* Only used in the UDF path */
-    dvd->css_title = 0; /* Only matters in the UDF path */
-
-    return dvd;
+  return dvd;
 }
 
 #if defined(__sun)
@@ -289,19 +287,19 @@
    /vol/rdsk/<name> */
 static char *sun_block2char( const char *path )
 {
-    char *new_path;
+  char *new_path;
 
-    /* Must contain "/dsk/" */
-    if( !strstr( path, "/dsk/" ) ) return (char *) strdup( path );
+  /* Must contain "/dsk/" */
+  if( !strstr( path, "/dsk/" ) ) return (char *) strdup( path );
 
-    /* Replace "/dsk/" with "/rdsk/" */
-    new_path = malloc( strlen(path) + 2 );
-    strcpy( new_path, path );
-    strcpy( strstr( new_path, "/dsk/" ), "" );
-    strcat( new_path, "/rdsk/" );
-    strcat( new_path, strstr( path, "/dsk/" ) + strlen( "/dsk/" ) );
+  /* Replace "/dsk/" with "/rdsk/" */
+  new_path = malloc( strlen(path) + 2 );
+  strcpy( new_path, path );
+  strcpy( strstr( new_path, "/dsk/" ), "" );
+  strcat( new_path, "/rdsk/" );
+  strcat( new_path, strstr( path, "/dsk/" ) + strlen( "/dsk/" ) );
 
-    return new_path;
+  return new_path;
 }
 #endif
 
@@ -313,252 +311,253 @@
    BSD/OS  /dev/sr0c (if not mounted) or /dev/rsr0c ('c' any letter will do) */
 static char *bsd_block2char( const char *path )
 {
-    char *new_path;
+  char *new_path;
 
-    /* If it doesn't start with "/dev/" or does start with "/dev/r" exit */
-    if( !strncmp( path, "/dev/",  5 ) || strncmp( path, "/dev/r", 6 ) )
-      return (char *) strdup( path );
+  /* If it doesn't start with "/dev/" or does start with "/dev/r" exit */
+  if( !strncmp( path, "/dev/",  5 ) || strncmp( path, "/dev/r", 6 ) )
+    return (char *) strdup( path );
 
-    /* Replace "/dev/" with "/dev/r" */
-    new_path = malloc( strlen(path) + 2 );
-    strcpy( new_path, "/dev/r" );
-    strcat( new_path, path + strlen( "/dev/" ) );
+  /* Replace "/dev/" with "/dev/r" */
+  new_path = malloc( strlen(path) + 2 );
+  strcpy( new_path, "/dev/r" );
+  strcat( new_path, path + strlen( "/dev/" ) );
 
-    return new_path;
+  return new_path;
 }
 #endif
 
+
 dvd_reader_t *DVDOpen( const char *ppath )
 {
-    struct stat fileinfo;
-    int ret;
-    int have_css;
-        dvd_reader_t *ret_val = NULL;
-    char *dev_name = NULL;
-        char *path;
+  struct stat fileinfo;
+  int ret, have_css;
+  dvd_reader_t *ret_val = NULL;
+  char *dev_name = NULL;
+  char *path;
 
 #ifdef _MSC_VER
-        int len;
+      int len;
 #endif
 
-    if( ppath == NULL )
-      return 0;
+  if( ppath == NULL )
+    return 0;
 
-        path = strdup(ppath);
-    if( path == NULL )
-      return 0;
+      path = strdup(ppath);
+  if( path == NULL )
+    return 0;
 
-    /* Try to open libdvdcss or fall back to standard functions */
-    have_css = dvdinput_setup();
+  /* Try to open libdvdcss or fall back to standard functions */
+  have_css = dvdinput_setup();
 
 #ifdef _MSC_VER
-        /* Strip off the trailing \ if it is not a drive */
-        len = strlen(path);
-        if ((len > 1) &&
-                (path[len - 1] == '\\')  &&
-                (path[len - 2] != ':'))
-        {
-                path[len-1] = '\0';
-        }
+  /* Strip off the trailing \ if it is not a drive */
+  len = strlen(path);
+  if ((len > 1) &&
+      (path[len - 1] == '\\')  &&
+      (path[len - 2] != ':'))
+  {
+    path[len-1] = '\0';
+  }
 #endif
 
-    ret = stat( path, &fileinfo );
+  ret = stat( path, &fileinfo );
 
-    if( ret < 0 ) {
+  if( ret < 0 ) {
 
-        /* maybe "host:port" url? try opening it with acCeSS library */
-        if( strchr(path,':') ) {
-                        ret_val = DVDOpenImageFile( path, have_css );
-                        free(path);
-                return ret_val;
-        }
-
-        /* If we can't stat the file, give up */
-        fprintf( stderr, "libdvdread: Can't stat %s\n", path );
-        perror("");
-        free(path);
-        return NULL;
+    /* maybe "host:port" url? try opening it with acCeSS library */
+    if( strchr(path,':') ) {
+                    ret_val = DVDOpenImageFile( path, have_css );
+                    free(path);
+            return ret_val;
     }
 
-    /* First check if this is a block/char device or a file*/
-    if( S_ISBLK( fileinfo.st_mode ) ||
-        S_ISCHR( fileinfo.st_mode ) ||
-        S_ISREG( fileinfo.st_mode ) ) {
+    /* If we can't stat the file, give up */
+    fprintf( stderr, "libdvdread: Can't stat %s\n", path );
+    perror("");
+    free(path);
+    return NULL;
+  }
 
-        /**
-         * Block devices and regular files are assumed to be DVD-Video images.
-         */
+  /* First check if this is a block/char device or a file*/
+  if( S_ISBLK( fileinfo.st_mode ) ||
+      S_ISCHR( fileinfo.st_mode ) ||
+      S_ISREG( fileinfo.st_mode ) ) {
+
+    /**
+     * Block devices and regular files are assumed to be DVD-Video images.
+     */
 #if defined(__sun)
-        ret_val = DVDOpenImageFile( sun_block2char( path ), have_css );
+    ret_val = DVDOpenImageFile( sun_block2char( path ), have_css );
 #elif defined(SYS_BSD)
-        ret_val = DVDOpenImageFile( bsd_block2char( path ), have_css );
+    ret_val = DVDOpenImageFile( bsd_block2char( path ), have_css );
 #else
-        ret_val = DVDOpenImageFile( path, have_css );
+    ret_val = DVDOpenImageFile( path, have_css );
 #endif
 
-        free(path);
-        return ret_val;
+    free(path);
+    return ret_val;
 
-    } else if( S_ISDIR( fileinfo.st_mode ) ) {
-        dvd_reader_t *auth_drive = 0;
-        char *path_copy;
+  } else if( S_ISDIR( fileinfo.st_mode ) ) {
+    dvd_reader_t *auth_drive = 0;
+    char *path_copy;
 #if defined(SYS_BSD)
-        struct fstab* fe;
+    struct fstab* fe;
 #elif defined(__sun) || defined(__linux__)
-        FILE *mntfile;
+    FILE *mntfile;
 #endif
 
-        /* XXX: We should scream real loud here. */
-        if( !(path_copy = strdup( path ) ) ) {
-                free(path);
-                return NULL;
-        }
+    /* XXX: We should scream real loud here. */
+    if( !(path_copy = strdup( path ) ) ) {
+      free(path);
+      return NULL;
+    }
 
 #ifndef WIN32 /* don't have fchdir, and getcwd( NULL, ... ) is strange */
               /* Also WIN32 does not have symlinks, so we don't need this bit of code. */
 
-        /* Resolve any symlinks and get the absolut dir name. */
-        {
-            char *new_path;
-            int cdir = open( ".", O_RDONLY );
+    /* Resolve any symlinks and get the absolut dir name. */
+    {
+      char *new_path;
+      int cdir = open( ".", O_RDONLY );
 
-            if( cdir >= 0 ) {
-                chdir( path_copy );
-                new_path = malloc(PATH_MAX+1);
-                if(!new_path) {
-                  free(path);
-                  return NULL;
-                }
-                getcwd(new_path, PATH_MAX );
-                fchdir( cdir );
-                close( cdir );
-                    free( path_copy );
-                    path_copy = new_path;
-            }
+      if( cdir >= 0 ) {
+        chdir( path_copy );
+        new_path = malloc(PATH_MAX+1);
+        if(!new_path) {
+          free(path);
+          return NULL;
         }
+        getcwd(new_path, PATH_MAX );
+        fchdir( cdir );
+        close( cdir );
+          free( path_copy );
+          path_copy = new_path;
+      }
+    }
 #endif
-        /**
-         * If we're being asked to open a directory, check if that directory
-         * is the mountpoint for a DVD-ROM which we can use instead.
-         */
+
+    /**
+     * If we're being asked to open a directory, check if that directory
+     * is the mountpoint for a DVD-ROM which we can use instead.
+     */
 
-        if( strlen( path_copy ) > 1 ) {
-            if( path_copy[ strlen( path_copy ) - 1 ] == '/' )
-                path_copy[ strlen( path_copy ) - 1 ] = '\0';
-        }
+    if( strlen( path_copy ) > 1 ) {
+      if( path_copy[ strlen( path_copy ) - 1 ] == '/' ) {
+        path_copy[ strlen( path_copy ) - 1 ] = '\0';
+      }
+    }
 
-        if( strlen( path_copy ) > TITLES_MAX ) {
-            if( !strcasecmp( &(path_copy[ strlen( path_copy ) - TITLES_MAX ]),
-                             "/video_ts" ) ) {
-              path_copy[ strlen( path_copy ) - TITLES_MAX ] = '\0';
-            }
-        }
+    if( strlen( path_copy ) > TITLES_MAX ) {
+      if( !strcasecmp( &(path_copy[ strlen( path_copy ) - TITLES_MAX ]),
+                       "/video_ts" ) ) {
+        path_copy[ strlen( path_copy ) - TITLES_MAX ] = '\0';
+      }
+    }
 
-        if(path_copy[0] == '\0') {
-            path_copy[0] = '/';
-            path_copy[1] = '\0';
-        }
+    if(path_copy[0] == '\0') {
+      path_copy[0] = '/';
+      path_copy[1] = '\0';
+    }
 
 #if defined(SYS_BSD)
-        if( ( fe = getfsfile( path_copy ) ) ) {
-            dev_name = bsd_block2char( fe->fs_spec );
-            fprintf( stderr,
-                     "libdvdread: Attempting to use device %s"
-                     " mounted on %s for CSS authentication\n",
-                     dev_name,
-                     fe->fs_file );
-            auth_drive = DVDOpenImageFile( dev_name, have_css );
-        }
+    if( ( fe = getfsfile( path_copy ) ) ) {
+      dev_name = bsd_block2char( fe->fs_spec );
+      fprintf( stderr,
+               "libdvdread: Attempting to use device %s"
+               " mounted on %s for CSS authentication\n",
+               dev_name,
+               fe->fs_file );
+      auth_drive = DVDOpenImageFile( dev_name, have_css );
+    }
 #elif defined(__sun)
-        mntfile = fopen( MNTTAB, "r" );
-        if( mntfile ) {
-            struct mnttab mp;
-            int res;
+    mntfile = fopen( MNTTAB, "r" );
+    if( mntfile ) {
+      struct mnttab mp;
+      int res;
 
-            while( ( res = getmntent( mntfile, &mp ) ) != -1 ) {
-                if( res == 0 && !strcmp( mp.mnt_mountp, path_copy ) ) {
-                    dev_name = sun_block2char( mp.mnt_special );
-                    fprintf( stderr,
-                             "libdvdread: Attempting to use device %s"
-                             " mounted on %s for CSS authentication\n",
-                             dev_name,
-                             mp.mnt_mountp );
-                    auth_drive = DVDOpenImageFile( dev_name, have_css );
-                    break;
-                }
-            }
-            fclose( mntfile );
+      while( ( res = getmntent( mntfile, &mp ) ) != -1 ) {
+        if( res == 0 && !strcmp( mp.mnt_mountp, path_copy ) ) {
+          dev_name = sun_block2char( mp.mnt_special );
+          fprintf( stderr,
+                   "libdvdread: Attempting to use device %s"
+                   " mounted on %s for CSS authentication\n",
+                   dev_name,
+                   mp.mnt_mountp );
+          auth_drive = DVDOpenImageFile( dev_name, have_css );
+          break;
         }
+      }
+      fclose( mntfile );
+    }
 #elif defined(__linux__)
-        mntfile = fopen( MOUNTED, "r" );
-        if( mntfile ) {
-            struct mntent *me;
+    mntfile = fopen( MOUNTED, "r" );
+    if( mntfile ) {
+      struct mntent *me;
 
-            while( ( me = getmntent( mntfile ) ) ) {
-                if( !strcmp( me->mnt_dir, path_copy ) ) {
-                    fprintf( stderr,
-                             "libdvdread: Attempting to use device %s"
-                             " mounted on %s for CSS authentication\n",
-                             me->mnt_fsname,
-                             me->mnt_dir );
-                    auth_drive = DVDOpenImageFile( me->mnt_fsname, have_css );
-                    dev_name = strdup(me->mnt_fsname);
-                    break;
-                }
-            }
-            fclose( mntfile );
+      while( ( me = getmntent( mntfile ) ) ) {
+        if( !strcmp( me->mnt_dir, path_copy ) ) {
+          fprintf( stderr,
+                   "libdvdread: Attempting to use device %s"
+                   " mounted on %s for CSS authentication\n",
+                   me->mnt_fsname,
+                   me->mnt_dir );
+          auth_drive = DVDOpenImageFile( me->mnt_fsname, have_css );
+          dev_name = strdup(me->mnt_fsname);
+          break;
         }
+      }
+      fclose( mntfile );
+    }
 #elif defined(_MSC_VER)
     auth_drive = DVDOpenImageFile( path, have_css );
 #endif
 
 #ifndef _MSC_VER
-        if( !dev_name ) {
-          fprintf( stderr, "libdvdread: Couldn't find device name.\n" );
-        } else if( !auth_drive ) {
-            fprintf( stderr, "libdvdread: Device %s inaccessible, "
-                     "CSS authentication not available.\n", dev_name );
-        }
+    if( !dev_name ) {
+      fprintf( stderr, "libdvdread: Couldn't find device name.\n" );
+    } else if( !auth_drive ) {
+      fprintf( stderr, "libdvdread: Device %s inaccessible, "
+               "CSS authentication not available.\n", dev_name );
+    }
 #else
-        if( !auth_drive ) {
-            fprintf( stderr, "libdvdread: Device %s inaccessible, "
-                     "CSS authentication not available.\n", dev_name );
-        }
+    if( !auth_drive ) {
+        fprintf( stderr, "libdvdread: Device %s inaccessible, "
+                 "CSS authentication not available.\n", dev_name );
+    }
 #endif
 
-        free( dev_name );
-        free( path_copy );
-
-        /**
-         * If we've opened a drive, just use that.
-         */
-        if( auth_drive ) {
-                free(path);
-                return auth_drive;
-        }
+    free( dev_name );
+    free( path_copy );
 
-        /**
-         * Otherwise, we now try to open the directory tree instead.
-         */
-        ret_val = DVDOpenPath( path );
-                free( path );
-                return ret_val;
+    /**
+     * If we've opened a drive, just use that.
+     */
+    if( auth_drive ) {
+      free(path);
+      return auth_drive;
     }
+    /**
+     * Otherwise, we now try to open the directory tree instead.
+     */
+    ret_val = DVDOpenPath( path );
+      free( path );
+      return ret_val;
+  }
 
-    /* If it's none of the above, screw it. */
-    fprintf( stderr, "libdvdread: Could not open %s\n", path );
-        free( path );
-    return NULL;
+  /* If it's none of the above, screw it. */
+  fprintf( stderr, "libdvdread: Could not open %s\n", path );
+    free( path );
+  return NULL;
 }
 
 void DVDClose( dvd_reader_t *dvd )
 {
-    if( dvd ) {
-        if( dvd->dev ) dvdinput_close( dvd->dev );
-        if( dvd->path_root ) free( dvd->path_root );
-        if( dvd->udfcache ) FreeUDFCache( dvd->udfcache );
-        free( dvd );
-    }
+  if( dvd ) {
+    if( dvd->dev ) dvdinput_close( dvd->dev );
+    if( dvd->path_root ) free( dvd->path_root );
+    if( dvd->udfcache ) FreeUDFCache( dvd->udfcache );
+    free( dvd );
+  }
 }
 
 /**
@@ -566,28 +565,28 @@
  */
 static dvd_file_t *DVDOpenFileUDF( dvd_reader_t *dvd, char *filename )
 {
-    uint32_t start, len;
-    dvd_file_t *dvd_file;
+  uint32_t start, len;
+  dvd_file_t *dvd_file;
 
-    start = UDFFindFile( dvd, filename, &len );
-    if( !start ) {
-      fprintf( stderr, "libdvdnav:DVDOpenFileUDF:UDFFindFile %s failed\n", filename );
-      return NULL;
-    }
+  start = UDFFindFile( dvd, filename, &len );
+  if( !start ) {
+    fprintf( stderr, "libdvdnav:DVDOpenFileUDF:UDFFindFile %s failed\n", filename );
+    return NULL;
+  }
 
-    dvd_file = (dvd_file_t *) malloc( sizeof( dvd_file_t ) );
-    if( !dvd_file ) {
-      fprintf( stderr, "libdvdnav:DVDOpenFileUDF:malloc failed\n" );
-      return NULL;
-    }
-    dvd_file->dvd = dvd;
-    dvd_file->lb_start = start;
-    dvd_file->seek_pos = 0;
-    memset( dvd_file->title_sizes, 0, sizeof( dvd_file->title_sizes ) );
-    memset( dvd_file->title_devs, 0, sizeof( dvd_file->title_devs ) );
-    dvd_file->filesize = len / DVD_VIDEO_LB_LEN;
+  dvd_file = (dvd_file_t *) malloc( sizeof( dvd_file_t ) );
+  if( !dvd_file ) {
+    fprintf( stderr, "libdvdnav:DVDOpenFileUDF:malloc failed\n" );
+    return NULL;
+  }
+  dvd_file->dvd = dvd;
+  dvd_file->lb_start = start;
+  dvd_file->seek_pos = 0;
+  memset( dvd_file->title_sizes, 0, sizeof( dvd_file->title_sizes ) );
+  memset( dvd_file->title_devs, 0, sizeof( dvd_file->title_devs ) );
+  dvd_file->filesize = len / DVD_VIDEO_LB_LEN;
 
-    return dvd_file;
+  return dvd_file;
 }
 
 /**
@@ -598,55 +597,54 @@
  */
 static int findDirFile( const char *path, const char *file, char *filename )
 {
-    DIR *dir;
-    struct dirent *ent;
+  DIR *dir;
+  struct dirent *ent;
 
-    dir = opendir( path );
-    if( !dir ) return -2;
+  dir = opendir( path );
+  if( !dir ) return -2;
 
-    while( ( ent = readdir( dir ) ) != NULL ) {
-        if( !strcasecmp( ent->d_name, file ) ) {
-            sprintf( filename, "%s%s%s", path,
-                     ( ( path[ strlen( path ) - 1 ] == '/' ) ? "" : "/" ),
-                     ent->d_name );
-            closedir( dir );
-            return 0;
-        }
+  while( ( ent = readdir( dir ) ) != NULL ) {
+    if( !strcasecmp( ent->d_name, file ) ) {
+      sprintf( filename, "%s%s%s", path,
+               ( ( path[ strlen( path ) - 1 ] == '/' ) ? "" : "/" ),
+               ent->d_name );
+      closedir(dir);
+      return 0;
     }
-
-    closedir( dir );
-    return -1;
+  }
+  closedir(dir);
+  return -1;
 }
 
 static int findDVDFile( dvd_reader_t *dvd, const char *file, char *filename )
 {
-    char video_path[ PATH_MAX + 1 ];
-    const char *nodirfile;
-    int ret;
+  char video_path[ PATH_MAX + 1 ];
+  const char *nodirfile;
+  int ret;
 
-    /* Strip off the directory for our search */
-    if( !strncasecmp( "/VIDEO_TS/", file, 10 ) ) {
-        nodirfile = &(file[ 10 ]);
-    } else {
-        nodirfile = file;
-    }
+  /* Strip off the directory for our search */
+  if( !strncasecmp( "/VIDEO_TS/", file, 10 ) ) {
+    nodirfile = &(file[ 10 ]);
+  } else {
+    nodirfile = file;
+  }
 
-    ret = findDirFile( dvd->path_root, nodirfile, filename );
+  ret = findDirFile( dvd->path_root, nodirfile, filename );
+  if( ret < 0 ) {
+    /* Try also with adding the path, just in case. */
+    sprintf( video_path, "%s/VIDEO_TS/", dvd->path_root );
+    ret = findDirFile( video_path, nodirfile, filename );
     if( ret < 0 ) {
-        /* Try also with adding the path, just in case. */
-        sprintf( video_path, "%s/VIDEO_TS/", dvd->path_root );
-        ret = findDirFile( video_path, nodirfile, filename );
-        if( ret < 0 ) {
-            /* Try with the path, but in lower case. */
-            sprintf( video_path, "%s/video_ts/", dvd->path_root );
-            ret = findDirFile( video_path, nodirfile, filename );
-            if( ret < 0 ) {
-                return 0;
-            }
-        }
+      /* Try with the path, but in lower case. */
+      sprintf( video_path, "%s/video_ts/", dvd->path_root );
+      ret = findDirFile( video_path, nodirfile, filename );
+      if( ret < 0 ) {
+        return 0;
+      }
     }
+  }
 
-    return 1;
+  return 1;
 }
 
 /**
@@ -654,263 +652,264 @@
  */
 static dvd_file_t *DVDOpenFilePath( dvd_reader_t *dvd, char *filename )
 {
-    char full_path[ PATH_MAX + 1 ];
-    dvd_file_t *dvd_file;
-    struct stat fileinfo;
-    dvd_input_t dev;
+  char full_path[ PATH_MAX + 1 ];
+  dvd_file_t *dvd_file;
+  struct stat fileinfo;
+  dvd_input_t dev;
 
-    /* Get the full path of the file. */
-    if( !findDVDFile( dvd, filename, full_path ) ) {
-      fprintf( stderr, "libdvdnav:DVDOpenFilePath:findDVDFile %s failed\n", filename );
-      return NULL;
-    }
+  /* Get the full path of the file. */
+  if( !findDVDFile( dvd, filename, full_path ) ) {
+    fprintf( stderr, "libdvdnav:DVDOpenFilePath:findDVDFile %s failed\n", filename );
+    return NULL;
+  }
 
-    dev = dvdinput_open( full_path );
-    if( !dev ) {
-      fprintf( stderr, "libdvdnav:DVDOpenFilePath:dvdinput_open %s failed\n", full_path );
-      return NULL;
-    }
+  dev = dvdinput_open( full_path );
+  if( !dev ) {
+    fprintf( stderr, "libdvdnav:DVDOpenFilePath:dvdinput_open %s failed\n", full_path );
+    return NULL;
+  }
 
-    dvd_file = (dvd_file_t *) malloc( sizeof( dvd_file_t ) );
-    if( !dvd_file ) {
-      fprintf( stderr, "libdvdnav:DVDOpenFilePath:dvd_file malloc failed\n" );
-      dvdinput_close(dev);
-      return NULL;
-    }
-    dvd_file->dvd = dvd;
-    dvd_file->lb_start = 0;
-    dvd_file->seek_pos = 0;
-    memset( dvd_file->title_sizes, 0, sizeof( dvd_file->title_sizes ) );
-    memset( dvd_file->title_devs, 0, sizeof( dvd_file->title_devs ) );
-    dvd_file->filesize = 0;
+  dvd_file = (dvd_file_t *) malloc( sizeof( dvd_file_t ) );
+  if( !dvd_file ) {
+    fprintf( stderr, "libdvdnav:DVDOpenFilePath:dvd_file malloc failed\n" );
+    dvdinput_close(dev);
+    return NULL;
+  }
+  dvd_file->dvd = dvd;
+  dvd_file->lb_start = 0;
+  dvd_file->seek_pos = 0;
+  memset( dvd_file->title_sizes, 0, sizeof( dvd_file->title_sizes ) );
+  memset( dvd_file->title_devs, 0, sizeof( dvd_file->title_devs ) );
+  dvd_file->filesize = 0;
 
-    if( stat( full_path, &fileinfo ) < 0 ) {
-        fprintf( stderr, "libdvdread: Can't stat() %s.\n", filename );
-        free( dvd_file );
-        return NULL;
-    }
-    dvd_file->title_sizes[ 0 ] = fileinfo.st_size / DVD_VIDEO_LB_LEN;
-    dvd_file->title_devs[ 0 ] = dev;
-    dvd_file->filesize = dvd_file->title_sizes[ 0 ];
+  if( stat( full_path, &fileinfo ) < 0 ) {
+    fprintf( stderr, "libdvdread: Can't stat() %s.\n", filename );
+    free( dvd_file );
+    return NULL;
+  }
+  dvd_file->title_sizes[ 0 ] = fileinfo.st_size / DVD_VIDEO_LB_LEN;
+  dvd_file->title_devs[ 0 ] = dev;
+  dvd_file->filesize = dvd_file->title_sizes[ 0 ];
 
-    return dvd_file;
+  return dvd_file;
 }
 
 static dvd_file_t *DVDOpenVOBUDF( dvd_reader_t *dvd, int title, int menu )
 {
-    char filename[ MAX_UDF_FILE_NAME_LEN ];
-    uint32_t start, len;
-    dvd_file_t *dvd_file;
+  char filename[ MAX_UDF_FILE_NAME_LEN ];
+  uint32_t start, len;
+  dvd_file_t *dvd_file;
 
-    if( title == 0 ) {
-        sprintf( filename, "/VIDEO_TS/VIDEO_TS.VOB" );
-    } else {
-        sprintf( filename, "/VIDEO_TS/VTS_%02d_%d.VOB", title, menu ? 0 : 1 );
-    }
-    start = UDFFindFile( dvd, filename, &len );
-    if( start == 0 ) return NULL;
+  if( title == 0 ) {
+    sprintf( filename, "/VIDEO_TS/VIDEO_TS.VOB" );
+  } else {
+    sprintf( filename, "/VIDEO_TS/VTS_%02d_%d.VOB", title, menu ? 0 : 1 );
+  }
+  start = UDFFindFile( dvd, filename, &len );
+  if( start == 0 ) return NULL;
 
-    dvd_file = (dvd_file_t *) malloc( sizeof( dvd_file_t ) );
-    if( !dvd_file ) return NULL;
-    dvd_file->dvd = dvd;
-    /*Hack*/ dvd_file->css_title = title << 1 | menu;
-    dvd_file->lb_start = start;
-    dvd_file->seek_pos = 0;
-    memset( dvd_file->title_sizes, 0, sizeof( dvd_file->title_sizes ) );
-    memset( dvd_file->title_devs, 0, sizeof( dvd_file->title_devs ) );
-    dvd_file->filesize = len / DVD_VIDEO_LB_LEN;
+  dvd_file = (dvd_file_t *) malloc( sizeof( dvd_file_t ) );
+  if( !dvd_file ) return NULL;
+  dvd_file->dvd = dvd;
+  /*Hack*/ dvd_file->css_title = title << 1 | menu;
+  dvd_file->lb_start = start;
+  dvd_file->seek_pos = 0;
+  memset( dvd_file->title_sizes, 0, sizeof( dvd_file->title_sizes ) );
+  memset( dvd_file->title_devs, 0, sizeof( dvd_file->title_devs ) );
+  dvd_file->filesize = len / DVD_VIDEO_LB_LEN;
 
-    /* Calculate the complete file size for every file in the VOBS */
-    if( !menu ) {
-        int cur;
+  /* Calculate the complete file size for every file in the VOBS */
+  if( !menu ) {
+    int cur;
 
-        for( cur = 2; cur < 10; cur++ ) {
-            sprintf( filename, "/VIDEO_TS/VTS_%02d_%d.VOB", title, cur );
-            if( !UDFFindFile( dvd, filename, &len ) ) break;
-            dvd_file->filesize += len / DVD_VIDEO_LB_LEN;
-        }
+    for( cur = 2; cur < 10; cur++ ) {
+      sprintf( filename, "/VIDEO_TS/VTS_%02d_%d.VOB", title, cur );
+      if( !UDFFindFile( dvd, filename, &len ) ) break;
+      dvd_file->filesize += len / DVD_VIDEO_LB_LEN;
     }
+  }
 
-    if( dvd->css_state == 1 /* Need key init */ ) {
-        initAllCSSKeys( dvd );
-        dvd->css_state = 2;
-    }
-    /*
-    if( dvdinput_title( dvd_file->dvd->dev, (int)start ) < 0 ) {
-        fprintf( stderr, "libdvdread: Error cracking CSS key for %s\n",
-                 filename );
-    }
-    */
+  if( dvd->css_state == 1 /* Need key init */ ) {
+    initAllCSSKeys( dvd );
+    dvd->css_state = 2;
+  }
+  /*
+  if( dvdinput_title( dvd_file->dvd->dev, (int)start ) < 0 ) {
+      fprintf( stderr, "libdvdread: Error cracking CSS key for %s\n",
+               filename );
+  }
+  */
 
-    return dvd_file;
+  return dvd_file;
 }
 
 static dvd_file_t *DVDOpenVOBPath( dvd_reader_t *dvd, int title, int menu )
 {
-    char filename[ MAX_UDF_FILE_NAME_LEN ];
-    char full_path[ PATH_MAX + 1 ];
-    struct stat fileinfo;
-    dvd_file_t *dvd_file;
-    int i;
+  char filename[ MAX_UDF_FILE_NAME_LEN ];
+  char full_path[ PATH_MAX + 1 ];
+  struct stat fileinfo;
+  dvd_file_t *dvd_file;
+  int i;
 
-    dvd_file = (dvd_file_t *) malloc( sizeof( dvd_file_t ) );
-    if( !dvd_file ) return NULL;
-    dvd_file->dvd = dvd;
-    /*Hack*/ dvd_file->css_title = title << 1 | menu;
-    dvd_file->lb_start = 0;
-    dvd_file->seek_pos = 0;
-    memset( dvd_file->title_sizes, 0, sizeof( dvd_file->title_sizes ) );
-    memset( dvd_file->title_devs, 0, sizeof( dvd_file->title_devs ) );
-    dvd_file->filesize = 0;
-
-    if( menu ) {
-        dvd_input_t dev;
-
-        if( title == 0 ) {
-            sprintf( filename, "VIDEO_TS.VOB" );
-        } else {
-            sprintf( filename, "VTS_%02i_0.VOB", title );
-        }
-        if( !findDVDFile( dvd, filename, full_path ) ) {
-            free( dvd_file );
-            return NULL;
-        }
+  dvd_file = (dvd_file_t *) malloc( sizeof( dvd_file_t ) );
+  if( !dvd_file ) return NULL;
+  dvd_file->dvd = dvd;
+  /*Hack*/ dvd_file->css_title = title << 1 | menu;
+  dvd_file->lb_start = 0;
+  dvd_file->seek_pos = 0;
+  memset( dvd_file->title_sizes, 0, sizeof( dvd_file->title_sizes ) );
+  memset( dvd_file->title_devs, 0, sizeof( dvd_file->title_devs ) );
+  dvd_file->filesize = 0;
 
-        dev = dvdinput_open( full_path );
-        if( dev == NULL ) {
-            free( dvd_file );
-            return NULL;
-        }
-
-        if( stat( full_path, &fileinfo ) < 0 ) {
-            fprintf( stderr, "libdvdread: Can't stat() %s.\n", filename );
-            dvdinput_close(dev);
-            free( dvd_file );
-            return NULL;
-        }
-        dvd_file->title_sizes[ 0 ] = fileinfo.st_size / DVD_VIDEO_LB_LEN;
-        dvd_file->title_devs[ 0 ] = dev;
-        dvdinput_title( dvd_file->title_devs[0], 0);
-        dvd_file->filesize = dvd_file->title_sizes[ 0 ];
-
-    } else {
-        for( i = 0; i < TITLES_MAX; ++i ) {
+  if( menu ) {
+    dvd_input_t dev;
 
-            sprintf( filename, "VTS_%02i_%i.VOB", title, i + 1 );
-            if( !findDVDFile( dvd, filename, full_path ) ) {
-                break;
-            }
-
-            if( stat( full_path, &fileinfo ) < 0 ) {
-                fprintf( stderr, "libdvdread: Can't stat() %s.\n", filename );
-                break;
-            }
+    if( title == 0 ) {
+      sprintf( filename, "VIDEO_TS.VOB" );
+    } else {
+      sprintf( filename, "VTS_%02i_0.VOB", title );
+    }
+    if( !findDVDFile( dvd, filename, full_path ) ) {
+      free( dvd_file );
+      return NULL;
+    }
 
-            dvd_file->title_sizes[ i ] = fileinfo.st_size / DVD_VIDEO_LB_LEN;
-            dvd_file->title_devs[ i ] = dvdinput_open( full_path );
-            dvdinput_title( dvd_file->title_devs[ i ], 0 );
-            dvd_file->filesize += dvd_file->title_sizes[ i ];
-        }
-        if( !dvd_file->title_devs[ 0 ] ) {
-            free( dvd_file );
-            return NULL;
-        }
+    dev = dvdinput_open( full_path );
+    if( dev == NULL ) {
+      free( dvd_file );
+      return NULL;
     }
 
-    return dvd_file;
+    if( stat( full_path, &fileinfo ) < 0 ) {
+      fprintf( stderr, "libdvdread: Can't stat() %s.\n", filename );
+      dvdinput_close(dev);
+      free( dvd_file );
+      return NULL;
+    }
+    dvd_file->title_sizes[ 0 ] = fileinfo.st_size / DVD_VIDEO_LB_LEN;
+    dvd_file->title_devs[ 0 ] = dev;
+    dvdinput_title( dvd_file->title_devs[0], 0);
+    dvd_file->filesize = dvd_file->title_sizes[ 0 ];
+
+  } else {
+    for( i = 0; i < TITLES_MAX; ++i ) {
+
+      sprintf( filename, "VTS_%02i_%i.VOB", title, i + 1 );
+      if( !findDVDFile( dvd, filename, full_path ) ) {
+        break;
+      }
+
+      if( stat( full_path, &fileinfo ) < 0 ) {
+        fprintf( stderr, "libdvdread: Can't stat() %s.\n", filename );
+        break;
+      }
+
+      dvd_file->title_sizes[ i ] = fileinfo.st_size / DVD_VIDEO_LB_LEN;
+      dvd_file->title_devs[ i ] = dvdinput_open( full_path );
+      dvdinput_title( dvd_file->title_devs[ i ], 0 );
+      dvd_file->filesize += dvd_file->title_sizes[ i ];
+    }
+    if( !dvd_file->title_devs[ 0 ] ) {
+      free( dvd_file );
+      return NULL;
+    }
+  }
+
+  return dvd_file;
 }
 
 dvd_file_t *DVDOpenFile( dvd_reader_t *dvd, int titlenum,
                          dvd_read_domain_t domain )
 {
-    char filename[ MAX_UDF_FILE_NAME_LEN ];
+  char filename[ MAX_UDF_FILE_NAME_LEN ];
 
-    /* Check arguments. */
-    if( dvd == NULL || titlenum < 0 )
-      return NULL;
+  /* Check arguments. */
+  if( dvd == NULL || titlenum < 0 )
+    return NULL;
 
-    switch( domain ) {
-    case DVD_READ_INFO_FILE:
-        if( titlenum == 0 ) {
-            sprintf( filename, "/VIDEO_TS/VIDEO_TS.IFO" );
-        } else {
-            sprintf( filename, "/VIDEO_TS/VTS_%02i_0.IFO", titlenum );
-        }
-        break;
-    case DVD_READ_INFO_BACKUP_FILE:
-        if( titlenum == 0 ) {
-            sprintf( filename, "/VIDEO_TS/VIDEO_TS.BUP" );
-        } else {
-            sprintf( filename, "/VIDEO_TS/VTS_%02i_0.BUP", titlenum );
-        }
-        break;
-    case DVD_READ_MENU_VOBS:
-        if( dvd->isImageFile ) {
-            return DVDOpenVOBUDF( dvd, titlenum, 1 );
-        } else {
-            return DVDOpenVOBPath( dvd, titlenum, 1 );
-        }
-        break;
-    case DVD_READ_TITLE_VOBS:
-        if( titlenum == 0 ) return 0;
-        if( dvd->isImageFile ) {
-            return DVDOpenVOBUDF( dvd, titlenum, 0 );
-        } else {
-            return DVDOpenVOBPath( dvd, titlenum, 0 );
-        }
-        break;
-    default:
-        fprintf( stderr, "libdvdread: Invalid domain for file open.\n" );
-        return NULL;
+  switch( domain ) {
+  case DVD_READ_INFO_FILE:
+    if( titlenum == 0 ) {
+      sprintf( filename, "/VIDEO_TS/VIDEO_TS.IFO" );
+    } else {
+      sprintf( filename, "/VIDEO_TS/VTS_%02i_0.IFO", titlenum );
+    }
+    break;
+  case DVD_READ_INFO_BACKUP_FILE:
+    if( titlenum == 0 ) {
+      sprintf( filename, "/VIDEO_TS/VIDEO_TS.BUP" );
+    } else {
+      sprintf( filename, "/VIDEO_TS/VTS_%02i_0.BUP", titlenum );
     }
-
+    break;
+  case DVD_READ_MENU_VOBS:
+    if( dvd->isImageFile ) {
+      return DVDOpenVOBUDF( dvd, titlenum, 1 );
+    } else {
+      return DVDOpenVOBPath( dvd, titlenum, 1 );
+    }
+    break;
+  case DVD_READ_TITLE_VOBS:
+    if( titlenum == 0 ) return 0;
     if( dvd->isImageFile ) {
-        return DVDOpenFileUDF( dvd, filename );
+      return DVDOpenVOBUDF( dvd, titlenum, 0 );
     } else {
-        return DVDOpenFilePath( dvd, filename );
+      return DVDOpenVOBPath( dvd, titlenum, 0 );
     }
+    break;
+  default:
+    fprintf( stderr, "libdvdread: Invalid domain for file open.\n" );
+    return NULL;
+  }
+
+  if( dvd->isImageFile ) {
+    return DVDOpenFileUDF( dvd, filename );
+  } else {
+    return DVDOpenFilePath( dvd, filename );
+  }
 }
 
 void DVDCloseFile( dvd_file_t *dvd_file )
 {
-    int i;
+  int i;
 
-    if( dvd_file ) {
-        if( dvd_file->dvd->isImageFile ) {
-            ;
-        } else {
-            for( i = 0; i < TITLES_MAX; ++i ) {
-                if( dvd_file->title_devs[ i ] ) {
-                    dvdinput_close( dvd_file->title_devs[i] );
-                }
-            }
+  if( dvd_file ) {
+    if( dvd_file->dvd->isImageFile ) {
+      ;
+    } else {
+      for( i = 0; i < TITLES_MAX; ++i ) {
+        if( dvd_file->title_devs[ i ] ) {
+          dvdinput_close( dvd_file->title_devs[i] );
         }
+      }
+    }
 
-        free( dvd_file );
-        dvd_file = 0;
-    }
+    free( dvd_file );
+    dvd_file = 0;
+  }
 }
 
 /* Internal, but used from dvd_udf.c */
 int UDFReadBlocksRaw( dvd_reader_t *device, uint32_t lb_number,
-                         size_t block_count, unsigned char *data,
-                         int encrypted )
+                      size_t block_count, unsigned char *data,
+                      int encrypted )
 {
-   int ret;
-   if( !device->dev ) {
-        fprintf( stderr, "libdvdread: Fatal error in block read.\n" );
-        return 0;
-   }
+  int ret;
+
+  if( !device->dev ) {
+    fprintf( stderr, "libdvdread: Fatal error in block read.\n" );
+    return 0;
+  }
 
-   ret = dvdinput_seek( device->dev, (int) lb_number );
-   if( ret != (int) lb_number ) {
-        fprintf( stderr, "libdvdread: Can't seek to block %u\n", lb_number );
-        return 0;
-   }
+  ret = dvdinput_seek( device->dev, (int) lb_number );
+  if( ret != (int) lb_number ) {
+    fprintf( stderr, "libdvdread: Can't seek to block %u\n", lb_number );
+    return 0;
+  }
 
-   ret = dvdinput_read( device->dev, (char *) data,
-                         (int) block_count, encrypted );
-   return ret;
+  ret = dvdinput_read( device->dev, (char *) data,
+                       (int) block_count, encrypted );
+  return ret;
 }
 
 /* This is using a single input and starting from 'dvd_file->lb_start' offset.
@@ -923,8 +922,8 @@
                              size_t block_count, unsigned char *data,
                              int encrypted )
 {
-    return UDFReadBlocksRaw( dvd_file->dvd, dvd_file->lb_start + offset,
-                             block_count, data, encrypted );
+  return UDFReadBlocksRaw( dvd_file->dvd, dvd_file->lb_start + offset,
+                           block_count, data, encrypted );
 }
 
 /* This is using possibly several inputs and starting from an offset of '0'.
@@ -937,238 +936,240 @@
                               size_t block_count, unsigned char *data,
                               int encrypted )
 {
-    int i;
-    int ret, ret2, off;
+  int i;
+  int ret, ret2, off;
 
-    ret = 0;
-    ret2 = 0;
-    for( i = 0; i < TITLES_MAX; ++i ) {
-      if( !dvd_file->title_sizes[ i ] ) return 0; /* Past end of file */
+  ret = 0;
+  ret2 = 0;
+  for( i = 0; i < TITLES_MAX; ++i ) {
+    if( !dvd_file->title_sizes[ i ] ) return 0; /* Past end of file */
 
-        if( offset < dvd_file->title_sizes[ i ] ) {
-            if( ( offset + block_count ) <= dvd_file->title_sizes[ i ] ) {
-                off = dvdinput_seek( dvd_file->title_devs[ i ], (int)offset );
-                if( off < 0 || off != (int)offset ) {
-                    fprintf( stderr, "libdvdread: Can't seek to block %d\n",
-                             offset );
-                    return off < 0 ? off : 0;
-                }
-                ret = dvdinput_read( dvd_file->title_devs[ i ], data,
-                                     (int)block_count, encrypted );
-                break;
-            } else {
-                size_t part1_size = dvd_file->title_sizes[ i ] - offset;
-                /* FIXME: Really needs to be a while loop.
-                 * (This is only true if you try and read >1GB at a time) */
+    if( offset < dvd_file->title_sizes[ i ] ) {
+      if( ( offset + block_count ) <= dvd_file->title_sizes[ i ] ) {
+        off = dvdinput_seek( dvd_file->title_devs[ i ], (int)offset );
+        if( off < 0 || off != (int)offset ) {
+          fprintf( stderr, "libdvdread: Can't seek to block %d\n",
+                   offset );
+          return off < 0 ? off : 0;
+        }
+        ret = dvdinput_read( dvd_file->title_devs[ i ], data,
+                             (int)block_count, encrypted );
+        break;
+      } else {
+        size_t part1_size = dvd_file->title_sizes[ i ] - offset;
+        /* FIXME: Really needs to be a while loop.
+         * (This is only true if you try and read >1GB at a time) */
 
-                /* Read part 1 */
-                off = dvdinput_seek( dvd_file->title_devs[ i ], (int)offset );
-                if( off < 0 || off != (int)offset ) {
-                    fprintf( stderr, "libdvdread: Can't seek to block %d\n",
-                             offset );
-                    return off < 0 ? off : 0;
-                }
-                ret = dvdinput_read( dvd_file->title_devs[ i ], data,
-                                     (int)part1_size, encrypted );
-                if( ret < 0 ) return ret;
-                /* FIXME: This is wrong if i is the last file in the set.
-                 * also error from this read will not show in ret. */
+        /* Read part 1 */
+        off = dvdinput_seek( dvd_file->title_devs[ i ], (int)offset );
+        if( off < 0 || off != (int)offset ) {
+          fprintf( stderr, "libdvdread: Can't seek to block %d\n",
+                   offset );
+          return off < 0 ? off : 0;
+        }
+        ret = dvdinput_read( dvd_file->title_devs[ i ], data,
+                             (int)part1_size, encrypted );
+        if( ret < 0 ) return ret;
+        /* FIXME: This is wrong if i is the last file in the set.
+         * also error from this read will not show in ret. */
 
-                /* Does the next part exist? If not then return now. */
-                if( i + 1 >= TITLES_MAX || !dvd_file->title_devs[ i + 1 ] )
-                    return ret;
+        /* Does the next part exist? If not then return now. */
+        if( i + 1 >= TITLES_MAX || !dvd_file->title_devs[ i + 1 ] )
+          return ret;
 
-                /* Read part 2 */
-                off = dvdinput_seek( dvd_file->title_devs[ i + 1 ], 0 );
-                if( off < 0 || off != 0 ) {
-                    fprintf( stderr, "libdvdread: Can't seek to block %d\n",
-                             0 );
-                    return off < 0 ? off : 0;
-                }
-                ret2 = dvdinput_read( dvd_file->title_devs[ i + 1 ],
-                                      data + ( part1_size
-                                               * (int64_t)DVD_VIDEO_LB_LEN ),
-                                      (int)(block_count - part1_size),
-                                      encrypted );
-                if( ret2 < 0 ) return ret2;
-                break;
-            }
-        } else {
-            offset -= dvd_file->title_sizes[ i ];
+        /* Read part 2 */
+        off = dvdinput_seek( dvd_file->title_devs[ i + 1 ], 0 );
+        if( off < 0 || off != 0 ) {
+          fprintf( stderr, "libdvdread: Can't seek to block %d\n",
+                   0 );
+          return off < 0 ? off : 0;
         }
+        ret2 = dvdinput_read( dvd_file->title_devs[ i + 1 ],
+                              data + ( part1_size
+                                       * (int64_t)DVD_VIDEO_LB_LEN ),
+                              (int)(block_count - part1_size),
+                              encrypted );
+        if( ret2 < 0 ) return ret2;
+        break;
+      }
+    } else {
+      offset -= dvd_file->title_sizes[ i ];
     }
+  }
 
-    return ret + ret2;
+  return ret + ret2;
 }
 
 /* This is broken reading more than 2Gb at a time is ssize_t is 32-bit. */
 ssize_t DVDReadBlocks( dvd_file_t *dvd_file, int offset,
                        size_t block_count, unsigned char *data )
 {
-    int ret;
-    /* Check arguments. */
-    if( dvd_file == NULL || offset < 0 || data == NULL )
-      return -1;
+  int ret;
+
+  /* Check arguments. */
+  if( dvd_file == NULL || offset < 0 || data == NULL )
+    return -1;
 
-    /* Hack, and it will still fail for multiple opens in a threaded app ! */
-    if( dvd_file->dvd->css_title != dvd_file->css_title ) {
-      dvd_file->dvd->css_title = dvd_file->css_title;
-      if( dvd_file->dvd->isImageFile ) {
-        dvdinput_title( dvd_file->dvd->dev, (int)dvd_file->lb_start );
-      }
-      /* Here each vobu has it's own dvdcss handle, so no need to update
-      else {
-        dvdinput_title( dvd_file->title_devs[ 0 ], (int)dvd_file->lb_start );
-      }*/
+  /* Hack, and it will still fail for multiple opens in a threaded app ! */
+  if( dvd_file->dvd->css_title != dvd_file->css_title ) {
+    dvd_file->dvd->css_title = dvd_file->css_title;
+    if( dvd_file->dvd->isImageFile ) {
+      dvdinput_title( dvd_file->dvd->dev, (int)dvd_file->lb_start );
     }
+    /* Here each vobu has it's own dvdcss handle, so no need to update
+    else {
+      dvdinput_title( dvd_file->title_devs[ 0 ], (int)dvd_file->lb_start );
+    }*/
+  }
 
-    if( dvd_file->dvd->isImageFile ) {
-        ret = DVDReadBlocksUDF( dvd_file, (uint32_t)offset,
-                                block_count, data, DVDINPUT_READ_DECRYPT );
-    } else {
-        ret = DVDReadBlocksPath( dvd_file, (unsigned int)offset,
-                                 block_count, data, DVDINPUT_READ_DECRYPT );
-    }
+  if( dvd_file->dvd->isImageFile ) {
+    ret = DVDReadBlocksUDF( dvd_file, (uint32_t)offset,
+                            block_count, data, DVDINPUT_READ_DECRYPT );
+  } else {
+    ret = DVDReadBlocksPath( dvd_file, (unsigned int)offset,
+                             block_count, data, DVDINPUT_READ_DECRYPT );
+  }
 
-    return (ssize_t)ret;
+  return (ssize_t)ret;
 }
 
 int32_t DVDFileSeek( dvd_file_t *dvd_file, int32_t offset )
 {
-    /* Check arguments. */
-    if( dvd_file == NULL || offset < 0 )
-       return -1;
+  /* Check arguments. */
+  if( dvd_file == NULL || offset < 0 )
+    return -1;
 
-    if( offset > dvd_file->filesize * DVD_VIDEO_LB_LEN ) {
-       return -1;
-    }
-    dvd_file->seek_pos = (uint32_t) offset;
-    return offset;
+  if( offset > dvd_file->filesize * DVD_VIDEO_LB_LEN ) {
+    return -1;
+  }
+  dvd_file->seek_pos = (uint32_t) offset;
+  return offset;
 }
 
 int DVDFileSeekForce(dvd_file_t *dvd_file, int offset, int force_size)
 {
-    /* Check arguments. */
-    if( dvd_file == NULL || offset <= 0 )
-        return -1;
+  /* Check arguments. */
+  if( dvd_file == NULL || offset <= 0 )
+      return -1;
 
-    if( dvd_file->dvd->isImageFile ) {
-        if( force_size < 0 )
-            force_size = (offset - 1) / DVD_VIDEO_LB_LEN + 1;
-        if( dvd_file->filesize < force_size ) {
-            dvd_file->filesize = force_size;
-            fprintf(stderr, "libdvdread: Ignored size of file indicated in UDF.\n");
-        }
+  if( dvd_file->dvd->isImageFile ) {
+    if( force_size < 0 )
+      force_size = (offset - 1) / DVD_VIDEO_LB_LEN + 1;
+    if( dvd_file->filesize < force_size ) {
+      dvd_file->filesize = force_size;
+      fprintf(stderr, "libdvdread: Ignored size of file indicated in UDF.\n");
     }
+  }
 
-    if( offset > dvd_file->filesize * DVD_VIDEO_LB_LEN )
-        return -1;
+  if( offset > dvd_file->filesize * DVD_VIDEO_LB_LEN )
+    return -1;
 
-    dvd_file->seek_pos = (uint32_t) offset;
-    return offset;
+  dvd_file->seek_pos = (uint32_t) offset;
+  return offset;
 }
 
 ssize_t DVDReadBytes( dvd_file_t *dvd_file, void *data, size_t byte_size )
 {
-    unsigned char *secbuf_base, *secbuf;
-    unsigned int numsec, seek_sector, seek_byte;
-    int ret;
+  unsigned char *secbuf_base, *secbuf;
+  unsigned int numsec, seek_sector, seek_byte;
+  int ret;
 
-    /* Check arguments. */
-    if( dvd_file == NULL || data == NULL )
-      return -1;
+  /* Check arguments. */
+  if( dvd_file == NULL || data == NULL )
+    return -1;
 
-    seek_sector = dvd_file->seek_pos / DVD_VIDEO_LB_LEN;
-    seek_byte   = dvd_file->seek_pos % DVD_VIDEO_LB_LEN;
+  seek_sector = dvd_file->seek_pos / DVD_VIDEO_LB_LEN;
+  seek_byte   = dvd_file->seek_pos % DVD_VIDEO_LB_LEN;
 
-    numsec = ( ( seek_byte + byte_size ) / DVD_VIDEO_LB_LEN ) +
-      ( ( ( seek_byte + byte_size ) % DVD_VIDEO_LB_LEN ) ? 1 : 0 );
+  numsec = ( ( seek_byte + byte_size ) / DVD_VIDEO_LB_LEN ) +
+    ( ( ( seek_byte + byte_size ) % DVD_VIDEO_LB_LEN ) ? 1 : 0 );
 
-    secbuf_base = (unsigned char *) malloc( numsec * DVD_VIDEO_LB_LEN + 2048 );
-    secbuf = (unsigned char *)(((uintptr_t)secbuf_base & ~((uintptr_t)2047)) + 2048);
-    if( !secbuf_base ) {
-        fprintf( stderr, "libdvdread: Can't allocate memory "
-                 "for file read!\n" );
-        return 0;
-    }
+  secbuf_base = (unsigned char *) malloc( numsec * DVD_VIDEO_LB_LEN + 2048 );
+  secbuf = (unsigned char *)(((uintptr_t)secbuf_base & ~((uintptr_t)2047)) + 2048);
+  if( !secbuf_base ) {
+    fprintf( stderr, "libdvdread: Can't allocate memory "
+             "for file read!\n" );
+    return 0;
+  }
 
-    if( dvd_file->dvd->isImageFile ) {
-        ret = DVDReadBlocksUDF( dvd_file, (uint32_t) seek_sector,
-                                (size_t) numsec, secbuf, DVDINPUT_NOFLAGS );
-    } else {
-        ret = DVDReadBlocksPath( dvd_file, seek_sector,
-                                 (size_t) numsec, secbuf, DVDINPUT_NOFLAGS );
-    }
+  if( dvd_file->dvd->isImageFile ) {
+    ret = DVDReadBlocksUDF( dvd_file, (uint32_t) seek_sector,
+                            (size_t) numsec, secbuf, DVDINPUT_NOFLAGS );
+  } else {
+    ret = DVDReadBlocksPath( dvd_file, seek_sector,
+                             (size_t) numsec, secbuf, DVDINPUT_NOFLAGS );
+  }
 
-    if( ret != (int) numsec ) {
-        free( secbuf_base );
-        return ret < 0 ? ret : 0;
-    }
+  if( ret != (int) numsec ) {
+    free( secbuf_base );
+    return ret < 0 ? ret : 0;
+  }
 
-    memcpy( data, &(secbuf[ seek_byte ]), byte_size );
-    free( secbuf_base );
+  memcpy( data, &(secbuf[ seek_byte ]), byte_size );
+  free( secbuf_base );
 
-    DVDFileSeekForce(dvd_file, dvd_file->seek_pos + byte_size, -1);
-    return byte_size;
+  DVDFileSeekForce(dvd_file, dvd_file->seek_pos + byte_size, -1);
+  return byte_size;
 }
 
 ssize_t DVDFileSize( dvd_file_t *dvd_file )
 {
-    /* Check arguments. */
-    if( dvd_file == NULL )
-      return -1;
+  /* Check arguments. */
+  if( dvd_file == NULL )
+    return -1;
 
-    return dvd_file->filesize;
+  return dvd_file->filesize;
 }
 
 int DVDDiscID( dvd_reader_t *dvd, unsigned char *discid )
 {
-    struct md5_ctx ctx;
-    int title;
-    int nr_of_files = 0;
+  struct md5_ctx ctx;
+  int title;
+  int nr_of_files = 0;
 
-    /* Check arguments. */
-    if( dvd == NULL || discid == NULL )
-      return 0;
+  /* Check arguments. */
+  if( dvd == NULL || discid == NULL )
+    return 0;
 
-    /* Go through the first 10 IFO:s, in order,
-     * and md5sum them, i.e  VIDEO_TS.IFO and VTS_0?_0.IFO */
-    md5_init_ctx( &ctx );
-    for( title = 0; title < 10; title++ ) {
-        dvd_file_t *dvd_file = DVDOpenFile( dvd, title, DVD_READ_INFO_FILE );
-        if( dvd_file != NULL ) {
-            ssize_t bytes_read;
-            size_t file_size = dvd_file->filesize * DVD_VIDEO_LB_LEN;
-            char *buffer_base = malloc( file_size + 2048 );
-            char *buffer = (char *)(((uintptr_t)buffer_base & ~((uintptr_t)2047)) + 2048);
+  /* Go through the first 10 IFO:s, in order,
+   * and md5sum them, i.e  VIDEO_TS.IFO and VTS_0?_0.IFO */
+  md5_init_ctx( &ctx );
+  for( title = 0; title < 10; title++ ) {
+    dvd_file_t *dvd_file = DVDOpenFile( dvd, title, DVD_READ_INFO_FILE );
+    if( dvd_file != NULL ) {
+      ssize_t bytes_read;
+      size_t file_size = dvd_file->filesize * DVD_VIDEO_LB_LEN;
+      char *buffer_base = malloc( file_size + 2048 );
+      char *buffer = (char *)(((uintptr_t)buffer_base & ~((uintptr_t)2047)) + 2048);
 
-            if( buffer_base == NULL ) {
-                DVDCloseFile( dvd_file );
-                fprintf( stderr, "libdvdread: DVDDiscId, failed to "
-                         "allocate memory for file read!\n" );
-                return -1;
-            }
-            bytes_read = DVDReadBytes( dvd_file, buffer, file_size );
-            if( bytes_read != file_size ) {
-                fprintf( stderr, "libdvdread: DVDDiscId read returned %zd bytes"
-                         ", wanted %zd\n", bytes_read, file_size );
-                DVDCloseFile( dvd_file );
-                free( buffer_base );
-                return -1;
-            }
+      if( buffer_base == NULL ) {
+          DVDCloseFile( dvd_file );
+          fprintf( stderr, "libdvdread: DVDDiscId, failed to "
+                   "allocate memory for file read!\n" );
+          return -1;
+      }
 
-            md5_process_bytes( buffer, file_size,  &ctx );
+      bytes_read = DVDReadBytes( dvd_file, buffer, file_size );
+      if( bytes_read != file_size ) {
+          fprintf( stderr, "libdvdread: DVDDiscId read returned %zd bytes"
+                   ", wanted %zd\n", bytes_read, file_size );
+          DVDCloseFile( dvd_file );
+          free( buffer_base );
+          return -1;
+      }
+
+      md5_process_bytes( buffer, file_size,  &ctx );
 
-            DVDCloseFile( dvd_file );
-            free( buffer_base );
-            nr_of_files++;
-        }
+      DVDCloseFile( dvd_file );
+      free( buffer_base );
+      nr_of_files++;
     }
-    md5_finish_ctx( &ctx, discid );
-    if(!nr_of_files)
-      return -1;
+  }
+  md5_finish_ctx( &ctx, discid );
+  if(!nr_of_files)
+    return -1;
 
-    return 0;
+  return 0;
 }
 
 
--- a/dvd_udf.c	Tue Sep 23 09:14:45 2008 +0000
+++ b/dvd_udf.c	Thu Sep 25 09:17:42 2008 +0000
@@ -44,8 +44,8 @@
 
 /* Private but located in/shared with dvd_reader.c */
 extern int UDFReadBlocksRaw( dvd_reader_t *device, uint32_t lb_number,
-                                size_t block_count, unsigned char *data,
-                                int encrypted );
+                             size_t block_count, unsigned char *data,
+                             int encrypted );
 
 /* It's required to either fail or deliver all the blocks asked for. */
 static int DVDReadLBUDF( dvd_reader_t *device, uint32_t lb_number,
@@ -56,6 +56,7 @@
   size_t count = block_count;
 
   while(count > 0) {
+
     ret = UDFReadBlocksRaw(device, lb_number, count, data, encrypted);
 
     if(ret <= 0) {
@@ -201,16 +202,16 @@
   case LBUDFCache:
     for(n = 0; n < c->lb_num; n++) {
       if(c->lbs[n].lb == nr) {
-      *(uint8_t **)data = c->lbs[n].data;
-      return 1;
+        *(uint8_t **)data = c->lbs[n].data;
+        return 1;
       }
     }
     break;
   case MapCache:
     for(n = 0; n < c->map_num; n++) {
       if(c->maps[n].lbn == nr) {
-       *(struct icbmap *)data = c->maps[n];
-       return 1;
+        *(struct icbmap *)data = c->maps[n];
+        return 1;
       }
     }
     break;
@@ -262,19 +263,19 @@
   case LBUDFCache:
     for(n = 0; n < c->lb_num; n++) {
       if(c->lbs[n].lb == nr) {
-       /* replace with new data */
-       c->lbs[n].data_base = ((uint8_t **)data)[0];
-       c->lbs[n].data = ((uint8_t **)data)[1];
-       c->lbs[n].lb = nr;
-       return 1;
+        /* replace with new data */
+        c->lbs[n].data_base = ((uint8_t **)data)[0];
+        c->lbs[n].data = ((uint8_t **)data)[1];
+        c->lbs[n].lb = nr;
+        return 1;
       }
     }
     c->lb_num++;
     tmp = realloc(c->lbs, c->lb_num * sizeof(struct lbudf));
     /*
     fprintf(stderr, "realloc lb: %d * %d = %d\n",
-      c->lb_num, sizeof(struct lbudf),
-      c->lb_num * sizeof(struct lbudf));
+    c->lb_num, sizeof(struct lbudf),
+    c->lb_num * sizeof(struct lbudf));
     */
     if(tmp == NULL) {
       if(c->lbs) free(c->lbs);
@@ -289,10 +290,10 @@
   case MapCache:
     for(n = 0; n < c->map_num; n++) {
       if(c->maps[n].lbn == nr) {
-       /* replace with new data */
-       c->maps[n] = *(struct icbmap *)data;
-       c->maps[n].lbn = nr;
-       return 1;
+        /* replace with new data */
+        c->maps[n] = *(struct icbmap *)data;
+        c->maps[n].lbn = nr;
+        return 1;
       }
     }
     c->map_num++;
@@ -322,94 +323,94 @@
 /* For direct data access, LSB first */
 #define GETN1(p) ((uint8_t)data[p])
 #define GETN2(p) ((uint16_t)data[p] | ((uint16_t)data[(p) + 1] << 8))
-#define GETN3(p) ((uint32_t)data[p] | ((uint32_t)data[(p) + 1] << 8) \
+#define GETN3(p) ((uint32_t)data[p] | ((uint32_t)data[(p) + 1] << 8)    \
                   | ((uint32_t)data[(p) + 2] << 16))
-#define GETN4(p) ((uint32_t)data[p] \
-                  | ((uint32_t)data[(p) + 1] << 8) \
-                  | ((uint32_t)data[(p) + 2] << 16) \
+#define GETN4(p) ((uint32_t)data[p]                     \
+                  | ((uint32_t)data[(p) + 1] << 8)      \
+                  | ((uint32_t)data[(p) + 2] << 16)     \
                   | ((uint32_t)data[(p) + 3] << 24))
 /* This is wrong with regard to endianess */
 #define GETN(p, n, target) memcpy(target, &data[p], n)
 
 static int Unicodedecode( uint8_t *data, int len, char *target )
 {
-    int p = 1, i = 0;
+  int p = 1, i = 0;
 
-    if( ( data[ 0 ] == 8 ) || ( data[ 0 ] == 16 ) ) do {
-        if( data[ 0 ] == 16 ) p++;  /* Ignore MSB of unicode16 */
-        if( p < len ) {
-            target[ i++ ] = data[ p++ ];
-        }
-    } while( p < len );
+  if( ( data[ 0 ] == 8 ) || ( data[ 0 ] == 16 ) ) do {
+    if( data[ 0 ] == 16 ) p++;  /* Ignore MSB of unicode16 */
+    if( p < len ) {
+      target[ i++ ] = data[ p++ ];
+    }
+  } while( p < len );
 
-    target[ i ] = '\0';
-    return 0;
+  target[ i ] = '\0';
+  return 0;
 }
 
 static int UDFDescriptor( uint8_t *data, uint16_t *TagID )
 {
-    *TagID = GETN2(0);
-    /* TODO: check CRC 'n stuff */
-    return 0;
+  *TagID = GETN2(0);
+  /* TODO: check CRC 'n stuff */
+  return 0;
 }
 
 static int UDFExtentAD( uint8_t *data, uint32_t *Length, uint32_t *Location )
 {
-    *Length   = GETN4(0);
-    *Location = GETN4(4);
-    return 0;
+  *Length   = GETN4(0);
+  *Location = GETN4(4);
+  return 0;
 }
 
 static int UDFShortAD( uint8_t *data, struct AD *ad,
                        struct Partition *partition )
 {
-    ad->Length = GETN4(0);
-    ad->Flags = ad->Length >> 30;
-    ad->Length &= 0x3FFFFFFF;
-    ad->Location = GETN4(4);
-    ad->Partition = partition->Number; /* use number of current partition */
-    return 0;
+  ad->Length = GETN4(0);
+  ad->Flags = ad->Length >> 30;
+  ad->Length &= 0x3FFFFFFF;
+  ad->Location = GETN4(4);
+  ad->Partition = partition->Number; /* use number of current partition */
+  return 0;
 }
 
 static int UDFLongAD( uint8_t *data, struct AD *ad )
 {
-    ad->Length = GETN4(0);
-    ad->Flags = ad->Length >> 30;
-    ad->Length &= 0x3FFFFFFF;
-    ad->Location = GETN4(4);
-    ad->Partition = GETN2(8);
-    /* GETN(10, 6, Use); */
-    return 0;
+  ad->Length = GETN4(0);
+  ad->Flags = ad->Length >> 30;
+  ad->Length &= 0x3FFFFFFF;
+  ad->Location = GETN4(4);
+  ad->Partition = GETN2(8);
+  /* GETN(10, 6, Use); */
+  return 0;
 }
 
 static int UDFExtAD( uint8_t *data, struct AD *ad )
 {
-    ad->Length = GETN4(0);
-    ad->Flags = ad->Length >> 30;
-    ad->Length &= 0x3FFFFFFF;
-    ad->Location = GETN4(12);
-    ad->Partition = GETN2(16);
-    /* GETN(10, 6, Use); */
-    return 0;
+  ad->Length = GETN4(0);
+  ad->Flags = ad->Length >> 30;
+  ad->Length &= 0x3FFFFFFF;
+  ad->Location = GETN4(12);
+  ad->Partition = GETN2(16);
+  /* GETN(10, 6, Use); */
+  return 0;
 }
 
 static int UDFICB( uint8_t *data, uint8_t *FileType, uint16_t *Flags )
 {
-    *FileType = GETN1(11);
-    *Flags = GETN2(18);
-    return 0;
+  *FileType = GETN1(11);
+  *Flags = GETN2(18);
+  return 0;
 }
 
 
 static int UDFPartition( uint8_t *data, uint16_t *Flags, uint16_t *Number,
                          char *Contents, uint32_t *Start, uint32_t *Length )
 {
-    *Flags = GETN2(20);
-    *Number = GETN2(22);
-    GETN(24, 32, Contents);
-    *Start = GETN4(188);
-    *Length = GETN4(192);
-    return 0;
+  *Flags = GETN2(20);
+  *Number = GETN2(22);
+  GETN(24, 32, Contents);
+  *Start = GETN4(188);
+  *Length = GETN4(192);
+  return 0;
 }
 
 /**
@@ -418,66 +419,66 @@
  */
 static int UDFLogVolume( uint8_t *data, char *VolumeDescriptor )
 {
-    uint32_t lbsize, MT_L, N_PM;
-    Unicodedecode(&data[84], 128, VolumeDescriptor);
-    lbsize = GETN4(212);  /* should be 2048 */
-    MT_L = GETN4(264);    /* should be 6 */
-    N_PM = GETN4(268);    /* should be 1 */
-    if (lbsize != DVD_VIDEO_LB_LEN) return 1;
-    return 0;
+  uint32_t lbsize, MT_L, N_PM;
+  Unicodedecode(&data[84], 128, VolumeDescriptor);
+  lbsize = GETN4(212);  /* should be 2048 */
+  MT_L = GETN4(264);    /* should be 6 */
+  N_PM = GETN4(268);    /* should be 1 */
+  if (lbsize != DVD_VIDEO_LB_LEN) return 1;
+  return 0;
 }
 
 static int UDFFileEntry( uint8_t *data, uint8_t *FileType,
                          struct Partition *partition, struct AD *ad )
 {
-    uint16_t flags;
-    uint32_t L_EA, L_AD;
-    unsigned int p;
+  uint16_t flags;
+  uint32_t L_EA, L_AD;
+  unsigned int p;
 
-    UDFICB( &data[ 16 ], FileType, &flags );
+  UDFICB( &data[ 16 ], FileType, &flags );
 
-    /* Init ad for an empty file (i.e. there isn't a AD, L_AD == 0 ) */
-    ad->Length = GETN4( 60 ); /* Really 8 bytes a 56 */
-    ad->Flags = 0;
-    ad->Location = 0; /* what should we put here?  */
-    ad->Partition = partition->Number; /* use number of current partition */
+  /* Init ad for an empty file (i.e. there isn't a AD, L_AD == 0 ) */
+  ad->Length = GETN4( 60 ); /* Really 8 bytes a 56 */
+  ad->Flags = 0;
+  ad->Location = 0; /* what should we put here?  */
+  ad->Partition = partition->Number; /* use number of current partition */
 
-    L_EA = GETN4( 168 );
-    L_AD = GETN4( 172 );
-    p = 176 + L_EA;
-    while( p < 176 + L_EA + L_AD ) {
-        switch( flags & 0x0007 ) {
-            case 0: UDFShortAD( &data[ p ], ad, partition ); p += 8;  break;
-            case 1: UDFLongAD( &data[ p ], ad );  p += 16; break;
-            case 2: UDFExtAD( &data[ p ], ad );   p += 20; break;
-            case 3:
-                switch( L_AD ) {
-                    case 8:  UDFShortAD( &data[ p ], ad, partition ); break;
-                    case 16: UDFLongAD( &data[ p ], ad );  break;
-                    case 20: UDFExtAD( &data[ p ], ad );   break;
-                }
-                p += L_AD;
-                break;
-            default:
-                p += L_AD; break;
-        }
+  L_EA = GETN4( 168 );
+  L_AD = GETN4( 172 );
+  p = 176 + L_EA;
+  while( p < 176 + L_EA + L_AD ) {
+    switch( flags & 0x0007 ) {
+    case 0: UDFShortAD( &data[ p ], ad, partition ); p += 8;  break;
+    case 1: UDFLongAD( &data[ p ], ad );  p += 16; break;
+    case 2: UDFExtAD( &data[ p ], ad );   p += 20; break;
+    case 3:
+      switch( L_AD ) {
+      case 8:  UDFShortAD( &data[ p ], ad, partition ); break;
+      case 16: UDFLongAD( &data[ p ], ad );  break;
+      case 20: UDFExtAD( &data[ p ], ad );   break;
+      }
+      p += L_AD;
+      break;
+    default:
+      p += L_AD; break;
     }
-    return 0;
+  }
+  return 0;
 }
 
 static int UDFFileIdentifier( uint8_t *data, uint8_t *FileCharacteristics,
                               char *FileName, struct AD *FileICB )
 {
-    uint8_t L_FI;
-    uint16_t L_IU;
+  uint8_t L_FI;
+  uint16_t L_IU;
 
-    *FileCharacteristics = GETN1(18);
-    L_FI = GETN1(19);
-    UDFLongAD(&data[20], FileICB);
-    L_IU = GETN2(36);
-    if (L_FI) Unicodedecode(&data[38 + L_IU], L_FI, FileName);
-    else FileName[0] = '\0';
-    return 4 * ((38 + L_FI + L_IU + 3) / 4);
+  *FileCharacteristics = GETN1(18);
+  L_FI = GETN1(19);
+  UDFLongAD(&data[20], FileICB);
+  L_IU = GETN2(36);
+  if (L_FI) Unicodedecode(&data[38 + L_IU], L_FI, FileName);
+  else FileName[0] = '\0';
+  return 4 * ((38 + L_FI + L_IU + 3) / 4);
 }
 
 /**
@@ -490,37 +491,37 @@
 static int UDFMapICB( dvd_reader_t *device, struct AD ICB, uint8_t *FileType,
                       struct Partition *partition, struct AD *File )
 {
-    uint8_t LogBlock_base[DVD_VIDEO_LB_LEN + 2048];
-    uint8_t *LogBlock = (uint8_t *)(((uintptr_t)LogBlock_base & ~((uintptr_t)2047)) + 2048);
-    uint32_t lbnum;
-    uint16_t TagID;
-    struct icbmap tmpmap;
+  uint8_t LogBlock_base[DVD_VIDEO_LB_LEN + 2048];
+  uint8_t *LogBlock = (uint8_t *)(((uintptr_t)LogBlock_base & ~((uintptr_t)2047)) + 2048);
+  uint32_t lbnum;
+  uint16_t TagID;
+  struct icbmap tmpmap;
 
-    lbnum = partition->Start + ICB.Location;
-    tmpmap.lbn = lbnum;
-    if(GetUDFCache(device, MapCache, lbnum, &tmpmap)) {
-      *FileType = tmpmap.filetype;
-      memcpy(File, &tmpmap.file, sizeof(tmpmap.file));
-      return 1;
-    }
+  lbnum = partition->Start + ICB.Location;
+  tmpmap.lbn = lbnum;
+  if(GetUDFCache(device, MapCache, lbnum, &tmpmap)) {
+    *FileType = tmpmap.filetype;
+    memcpy(File, &tmpmap.file, sizeof(tmpmap.file));
+    return 1;
+  }
 
-    do {
-        if( DVDReadLBUDF( device, lbnum++, 1, LogBlock, 0 ) <= 0 )
-            TagID = 0;
-        else
-            UDFDescriptor( LogBlock, &TagID );
+  do {
+    if( DVDReadLBUDF( device, lbnum++, 1, LogBlock, 0 ) <= 0 )
+      TagID = 0;
+    else
+      UDFDescriptor( LogBlock, &TagID );
 
-        if( TagID == 261 ) {
-            UDFFileEntry( LogBlock, FileType, partition, File );
-           memcpy(&tmpmap.file, File, sizeof(tmpmap.file));
-           tmpmap.filetype = *FileType;
-           SetUDFCache(device, MapCache, tmpmap.lbn, &tmpmap);
-            return 1;
-        };
-    } while( ( lbnum <= partition->Start + ICB.Location + ( ICB.Length - 1 )
+    if( TagID == 261 ) {
+      UDFFileEntry( LogBlock, FileType, partition, File );
+      memcpy(&tmpmap.file, File, sizeof(tmpmap.file));
+      tmpmap.filetype = *FileType;
+      SetUDFCache(device, MapCache, tmpmap.lbn, &tmpmap);
+      return 1;
+    };
+  } while( ( lbnum <= partition->Start + ICB.Location + ( ICB.Length - 1 )
              / DVD_VIDEO_LB_LEN ) && ( TagID != 261 ) );
 
-    return 0;
+  return 0;
 }
 
 /**
@@ -533,110 +534,110 @@
                        struct Partition *partition, struct AD *FileICB,
                        int cache_file_info)
 {
-    char filename[ MAX_UDF_FILE_NAME_LEN ];
-    uint8_t directory_base[ 2 * DVD_VIDEO_LB_LEN + 2048];
-    uint8_t *directory = (uint8_t *)(((uintptr_t)directory_base & ~((uintptr_t)2047)) + 2048);
-    uint32_t lbnum;
-    uint16_t TagID;
-    uint8_t filechar;
-    unsigned int p;
-    uint8_t *cached_dir_base = NULL, *cached_dir;
-    uint32_t dir_lba;
-    struct AD tmpICB;
-    int found = 0;
-    int in_cache = 0;
+  char filename[ MAX_UDF_FILE_NAME_LEN ];
+  uint8_t directory_base[ 2 * DVD_VIDEO_LB_LEN + 2048];
+  uint8_t *directory = (uint8_t *)(((uintptr_t)directory_base & ~((uintptr_t)2047)) + 2048);
+  uint32_t lbnum;
+  uint16_t TagID;
+  uint8_t filechar;
+  unsigned int p;
+  uint8_t *cached_dir_base = NULL, *cached_dir;
+  uint32_t dir_lba;
+  struct AD tmpICB;
+  int found = 0;
+  int in_cache = 0;
 
-    /* Scan dir for ICB of file */
-    lbnum = partition->Start + Dir.Location;
+  /* Scan dir for ICB of file */
+  lbnum = partition->Start + Dir.Location;
 
-    if(DVDUDFCacheLevel(device, -1) > 0) {
-      /* caching */
-
-      if(!GetUDFCache(device, LBUDFCache, lbnum, &cached_dir)) {
-          dir_lba = (Dir.Length + DVD_VIDEO_LB_LEN) / DVD_VIDEO_LB_LEN;
-          if((cached_dir_base = malloc(dir_lba * DVD_VIDEO_LB_LEN + 2048)) == NULL)
-            return 0;
+  if(DVDUDFCacheLevel(device, -1) > 0) {
+    /* caching */
 
-          cached_dir = (uint8_t *)(((uintptr_t)cached_dir_base & ~((uintptr_t)2047)) + 2048);
-          if( DVDReadLBUDF( device, lbnum, dir_lba, cached_dir, 0) <= 0 ) {
-            free(cached_dir_base);
-            cached_dir_base = NULL;
-            cached_dir = NULL;
-          }
-          /*
-          if(cached_dir) {
-            fprintf(stderr, "malloc dir: %d\n",  dir_lba * DVD_VIDEO_LB_LEN);
-          }
-          */
-          {
-            uint8_t *data[2];
-            data[0] = cached_dir_base;
-            data[1] = cached_dir;
-            SetUDFCache(device, LBUDFCache, lbnum, data);
-          }
-      } else
-        in_cache = 1;
-
-      if(cached_dir == NULL)
+    if(!GetUDFCache(device, LBUDFCache, lbnum, &cached_dir)) {
+      dir_lba = (Dir.Length + DVD_VIDEO_LB_LEN) / DVD_VIDEO_LB_LEN;
+      if((cached_dir_base = malloc(dir_lba * DVD_VIDEO_LB_LEN + 2048)) == NULL)
         return 0;
-
-      p = 0;
+      cached_dir = (uint8_t *)(((uintptr_t)cached_dir_base & ~((uintptr_t)2047)) + 2048);
+      if( DVDReadLBUDF( device, lbnum, dir_lba, cached_dir, 0) <= 0 ) {
+        free(cached_dir_base);
+        cached_dir_base = NULL;
+        cached_dir = NULL;
+      }
+      /*
+      if(cached_dir) {
+        fprintf(stderr, "malloc dir: %d\n",  dir_lba * DVD_VIDEO_LB_LEN);
+      }
+      */
+      {
+        uint8_t *data[2];
+        data[0] = cached_dir_base;
+        data[1] = cached_dir;
+        SetUDFCache(device, LBUDFCache, lbnum, data);
+      }
+    } else
+      in_cache = 1;
 
-      while( p < Dir.Length ) {
-        UDFDescriptor( &cached_dir[ p ], &TagID );
-        if( TagID == 257 ) {
-          p += UDFFileIdentifier( &cached_dir[ p ], &filechar, filename, &tmpICB );
-          if(cache_file_info && !in_cache) {
-            uint8_t tmpFiletype;
-            struct AD tmpFile;
-
-            if( !strcasecmp( FileName, filename ) ) {
-                memcpy(FileICB, &tmpICB, sizeof(tmpICB));
-                found = 1;
-            }
-            UDFMapICB(device, tmpICB, &tmpFiletype, partition, &tmpFile);
-          } else {
-            if( !strcasecmp( FileName, filename ) ) {
-                memcpy(FileICB, &tmpICB, sizeof(tmpICB));
-                return 1;
-            }
-          }
-        } else {
-          if(cache_file_info && (!in_cache) && found)
-            return 1;
-          return 0;
-        }
-      }
-      if(cache_file_info && (!in_cache) && found)
-        return 1;
-      return 0;
-    }
-
-    if( DVDReadLBUDF( device, lbnum, 2, directory, 0 ) <= 0 )
+    if(cached_dir == NULL)
       return 0;
 
     p = 0;
+
     while( p < Dir.Length ) {
-      if( p > DVD_VIDEO_LB_LEN ) {
-        ++lbnum;
-        p -= DVD_VIDEO_LB_LEN;
-        Dir.Length -= DVD_VIDEO_LB_LEN;
-        if( DVDReadLBUDF( device, lbnum, 2, directory, 0 ) <= 0 ) {
-            return 0;
-        }
-      }
-      UDFDescriptor( &directory[ p ], &TagID );
+      UDFDescriptor( &cached_dir[ p ], &TagID );
       if( TagID == 257 ) {
-        p += UDFFileIdentifier( &directory[ p ], &filechar,
-                                filename, FileICB );
-        if( !strcasecmp( FileName, filename ) ) {
+        p += UDFFileIdentifier( &cached_dir[ p ], &filechar,
+                                filename, &tmpICB );
+        if(cache_file_info && !in_cache) {
+          uint8_t tmpFiletype;
+          struct AD tmpFile;
+
+          if( !strcasecmp( FileName, filename ) ) {
+            memcpy(FileICB, &tmpICB, sizeof(tmpICB));
+            found = 1;
+          }
+          UDFMapICB(device, tmpICB, &tmpFiletype, partition, &tmpFile);
+        } else {
+          if( !strcasecmp( FileName, filename ) ) {
+            memcpy(FileICB, &tmpICB, sizeof(tmpICB));
             return 1;
+          }
         }
-      } else
-          return 0;
+      } else {
+        if(cache_file_info && (!in_cache) && found)
+          return 1;
+        return 0;
+      }
     }
+    if(cache_file_info && (!in_cache) && found)
+      return 1;
+    return 0;
+  }
 
+  if( DVDReadLBUDF( device, lbnum, 2, directory, 0 ) <= 0 )
     return 0;
+
+  p = 0;
+  while( p < Dir.Length ) {
+    if( p > DVD_VIDEO_LB_LEN ) {
+      ++lbnum;
+      p -= DVD_VIDEO_LB_LEN;
+      Dir.Length -= DVD_VIDEO_LB_LEN;
+      if( DVDReadLBUDF( device, lbnum, 2, directory, 0 ) <= 0 ) {
+        return 0;
+      }
+    }
+    UDFDescriptor( &directory[ p ], &TagID );
+    if( TagID == 257 ) {
+      p += UDFFileIdentifier( &directory[ p ], &filechar,
+                              filename, FileICB );
+      if( !strcasecmp( FileName, filename ) ) {
+        return 1;
+      }
+    } else
+      return 0;
+  }
+
+  return 0;
 }
 
 
@@ -670,10 +671,9 @@
       if( terminate ) return 0; /* Final try failed */
 
       if( lastsector ) {
-        /*
-         * We already found the last sector.  Try #3, alternative
+        /* We already found the last sector.  Try #3, alternative
          * backup anchor.  If that fails, don't try again.
-        */
+         */
         lbnum = lastsector;
         terminate = 1;
       } else {
@@ -712,134 +712,139 @@
 static int UDFFindPartition( dvd_reader_t *device, int partnum,
                              struct Partition *part )
 {
-    uint8_t LogBlock_base[ DVD_VIDEO_LB_LEN + 2048 ];
-    uint8_t *LogBlock = (uint8_t *)(((uintptr_t)LogBlock_base & ~((uintptr_t)2047)) + 2048);
-    uint32_t lbnum, MVDS_location, MVDS_length;
-    uint16_t TagID;
-    int i, volvalid;
-    struct avdp_t avdp;
+  uint8_t LogBlock_base[ DVD_VIDEO_LB_LEN + 2048 ];
+  uint8_t *LogBlock = (uint8_t *)(((uintptr_t)LogBlock_base & ~((uintptr_t)2047)) + 2048);
+  uint32_t lbnum, MVDS_location, MVDS_length;
+  uint16_t TagID;
+  int i, volvalid;
+  struct avdp_t avdp;
 
-    if(!UDFGetAVDP(device, &avdp))
-      return 0;
+  if(!UDFGetAVDP(device, &avdp))
+    return 0;
 
-    /* Main volume descriptor */
-    MVDS_location = avdp.mvds.location;
-    MVDS_length = avdp.mvds.length;
+  /* Main volume descriptor */
+  MVDS_location = avdp.mvds.location;
+  MVDS_length = avdp.mvds.length;
 
-    part->valid = 0;
-    volvalid = 0;
-    part->VolumeDesc[ 0 ] = '\0';
-    i = 1;
+  part->valid = 0;
+  volvalid = 0;
+  part->VolumeDesc[ 0 ] = '\0';
+  i = 1;
+  do {
+    /* Find Volume Descriptor */
+    lbnum = MVDS_location;
     do {
-        /* Find Volume Descriptor */
-        lbnum = MVDS_location;
-        do {
 
-            if( DVDReadLBUDF( device, lbnum++, 1, LogBlock, 0 ) <= 0 )
-                TagID = 0;
-            else
-                UDFDescriptor( LogBlock, &TagID );
+      if( DVDReadLBUDF( device, lbnum++, 1, LogBlock, 0 ) <= 0 )
+        TagID = 0;
+      else
+        UDFDescriptor( LogBlock, &TagID );
 
-            if( ( TagID == 5 ) && ( !part->valid ) ) {
-                /* Partition Descriptor */
-                UDFPartition( LogBlock, &part->Flags, &part->Number,
-                              part->Contents, &part->Start, &part->Length );
-                part->valid = ( partnum == part->Number );
-            } else if( ( TagID == 6 ) && ( !volvalid ) ) {
-                /* Logical Volume Descriptor */
-                if( UDFLogVolume( LogBlock, part->VolumeDesc ) ) {
-                    /* TODO: sector size wrong! */
-                } else
-                    volvalid = 1;
-            }
+      if( ( TagID == 5 ) && ( !part->valid ) ) {
+        /* Partition Descriptor */
+        UDFPartition( LogBlock, &part->Flags, &part->Number,
+                      part->Contents, &part->Start, &part->Length );
+        part->valid = ( partnum == part->Number );
+      } else if( ( TagID == 6 ) && ( !volvalid ) ) {
+        /* Logical Volume Descriptor */
+        if( UDFLogVolume( LogBlock, part->VolumeDesc ) ) {
+          /* TODO: sector size wrong! */
+        } else
+          volvalid = 1;
+      }
 
-        } while( ( lbnum <= MVDS_location + ( MVDS_length - 1 )
-                 / DVD_VIDEO_LB_LEN ) && ( TagID != 8 )
-                 && ( ( !part->valid ) || ( !volvalid ) ) );
+    } while( ( lbnum <= MVDS_location + ( MVDS_length - 1 )
+               / DVD_VIDEO_LB_LEN ) && ( TagID != 8 )
+             && ( ( !part->valid ) || ( !volvalid ) ) );
 
-        if( ( !part->valid) || ( !volvalid ) ) {
-            /* Backup volume descriptor */
-            MVDS_location = avdp.mvds.location;
-            MVDS_length = avdp.mvds.length;
-        }
-    } while( i-- && ( ( !part->valid ) || ( !volvalid ) ) );
+    if( ( !part->valid) || ( !volvalid ) ) {
+      /* Backup volume descriptor */
+      MVDS_location = avdp.mvds.location;
+      MVDS_length = avdp.mvds.length;
+    }
+  } while( i-- && ( ( !part->valid ) || ( !volvalid ) ) );
 
-    /* We only care for the partition, not the volume */
-    return part->valid;
+  /* We only care for the partition, not the volume */
+  return part->valid;
 }
 
 uint32_t UDFFindFile( dvd_reader_t *device, char *filename,
                       uint32_t *filesize )
 {
-    uint8_t LogBlock_base[ DVD_VIDEO_LB_LEN + 2048 ];
-    uint8_t *LogBlock = (uint8_t *)(((uintptr_t)LogBlock_base & ~((uintptr_t)2047)) + 2048);
-    uint32_t lbnum;
-    uint16_t TagID;
-    struct Partition partition;
-    struct AD RootICB, File, ICB;
-    char tokenline[ MAX_UDF_FILE_NAME_LEN ];
-    char *token;
-    uint8_t filetype;
+  uint8_t LogBlock_base[ DVD_VIDEO_LB_LEN + 2048 ];
+  uint8_t *LogBlock = (uint8_t *)(((uintptr_t)LogBlock_base & ~((uintptr_t)2047)) + 2048);
+  uint32_t lbnum;
+  uint16_t TagID;
+  struct Partition partition;
+  struct AD RootICB, File, ICB;
+  char tokenline[ MAX_UDF_FILE_NAME_LEN ];
+  char *token;
+  uint8_t filetype;
 
-    *filesize = 0;
-    tokenline[0] = '\0';
-    strncat(tokenline, filename, MAX_UDF_FILE_NAME_LEN - 1);
-    memset(&ICB, 0, sizeof(ICB));
+  *filesize = 0;
+  tokenline[0] = '\0';
+  strncat(tokenline, filename, MAX_UDF_FILE_NAME_LEN - 1);
+  memset(&ICB, 0, sizeof(ICB));
 
-    if(!(GetUDFCache(device, PartitionCache, 0, &partition) &&
-        GetUDFCache(device, RootICBCache, 0, &RootICB))) {
-      /* Find partition, 0 is the standard location for DVD Video.*/
-      if( !UDFFindPartition( device, 0, &partition ) ) return 0;
-      SetUDFCache(device, PartitionCache, 0, &partition);
+  if(!(GetUDFCache(device, PartitionCache, 0, &partition) &&
+       GetUDFCache(device, RootICBCache, 0, &RootICB))) {
+    /* Find partition, 0 is the standard location for DVD Video.*/
+    if( !UDFFindPartition( device, 0, &partition ) ) return 0;
+    SetUDFCache(device, PartitionCache, 0, &partition);
 
-      /* Find root dir ICB */
-      lbnum = partition.Start;
-      do {
-        if( DVDReadLBUDF( device, lbnum++, 1, LogBlock, 0 ) <= 0 )
-            TagID = 0;
-        else
-            UDFDescriptor( LogBlock, &TagID );
+    /* Find root dir ICB */
+    lbnum = partition.Start;
+    do {
+      if( DVDReadLBUDF( device, lbnum++, 1, LogBlock, 0 ) <= 0 )
+        TagID = 0;
+      else
+        UDFDescriptor( LogBlock, &TagID );
 
-        /* File Set Descriptor */
-        if( TagID == 256 )  /* File Set Descriptor */
-            UDFLongAD( &LogBlock[ 400 ], &RootICB );
+      /* File Set Descriptor */
+      if( TagID == 256 )  /* File Set Descriptor */
+        UDFLongAD( &LogBlock[ 400 ], &RootICB );
     } while( ( lbnum < partition.Start + partition.Length )
              && ( TagID != 8 ) && ( TagID != 256 ) );
 
     /* Sanity checks. */
-    if( TagID != 256 ) return 0;
-    if( RootICB.Partition != 0 ) return 0;
+    if( TagID != 256 )
+      return 0;
+    if( RootICB.Partition != 0 )
+      return 0;
     SetUDFCache(device, RootICBCache, 0, &RootICB);
-    }
+  }
 
-    /* Find root dir */
-    if( !UDFMapICB( device, RootICB, &filetype, &partition, &File ) ) return 0;
-    if( filetype != 4 ) return 0;  /* Root dir should be dir */
+  /* Find root dir */
+  if( !UDFMapICB( device, RootICB, &filetype, &partition, &File ) )
+    return 0;
+  if( filetype != 4 )
+    return 0;  /* Root dir should be dir */
+  {
+    int cache_file_info = 0;
+    /* Tokenize filepath */
+    token = strtok(tokenline, "/");
 
-    {
-      int cache_file_info = 0;
-      /* Tokenize filepath */
-      token = strtok(tokenline, "/");
-      while( token != NULL ) {
-        if( !UDFScanDir( device, File, token, &partition, &ICB,
-                        cache_file_info))
-          return 0;
-        if( !UDFMapICB( device, ICB, &filetype, &partition, &File ) )
-          return 0;
-       if(!strcmp(token, "VIDEO_TS"))
-         cache_file_info = 1;
-         token = strtok( NULL, "/" );
-      }
+    while( token != NULL ) {
+      if( !UDFScanDir( device, File, token, &partition, &ICB,
+                       cache_file_info))
+        return 0;
+      if( !UDFMapICB( device, ICB, &filetype, &partition, &File ) )
+        return 0;
+      if(!strcmp(token, "VIDEO_TS"))
+        cache_file_info = 1;
+      token = strtok( NULL, "/" );
     }
+  }
 
-    /* Sanity check. */
-    if( File.Partition != 0 ) return 0;
-    *filesize = File.Length;
-    /* Hack to not return partition.Start for empty files. */
-    if( !File.Location )
-      return 0;
-    else
-      return partition.Start + File.Location;
+  /* Sanity check. */
+  if( File.Partition != 0 )
+    return 0;
+  *filesize = File.Length;
+  /* Hack to not return partition.Start for empty files. */
+  if( !File.Location )
+    return 0;
+  else
+    return partition.Start + File.Location;
 }
 
 
@@ -872,6 +877,7 @@
   /* Main volume descriptor */
   MVDS_location = avdp.mvds.location;
   MVDS_length = avdp.mvds.length;
+
   i = 1;
   do {
     /* Find  Descriptor */
@@ -938,6 +944,7 @@
   if(volid_size > volid_len)
     volid_size = volid_len;
   Unicodedecode(pvd.VolumeIdentifier, volid_size, volid);
+
   return volid_len;
 }
 
@@ -964,5 +971,6 @@
     volsetid_size = 128;
 
   memcpy(volsetid, pvd.VolumeSetIdentifier, volsetid_size);
+
   return 128;
 }
--- a/dvdread_internal.h	Tue Sep 23 09:14:45 2008 +0000
+++ b/dvdread_internal.h	Thu Sep 25 09:17:42 2008 +0000
@@ -23,11 +23,11 @@
 #include <unistd.h>
 #endif /* _MSC_VER */
 
-#define CHECK_VALUE(arg) \
- if(!(arg)) { \
-   fprintf(stderr, "\n*** libdvdread: CHECK_VALUE failed in %s:%i ***" \
-                   "\n*** for %s ***\n\n", \
-                   __FILE__, __LINE__, # arg ); \
- }
+#define CHECK_VALUE(arg)                                                \
+  if(!(arg)) {                                                          \
+    fprintf(stderr, "\n*** libdvdread: CHECK_VALUE failed in %s:%i ***" \
+                    "\n*** for %s ***\n\n",                             \
+            __FILE__, __LINE__, # arg );                                \
+  }
 
 #endif /* LIBDVDREAD_DVDREAD_INTERNAL_H */
--- a/ifo_print.c	Tue Sep 23 09:14:45 2008 +0000
+++ b/ifo_print.c	Thu Sep 25 09:17:42 2008 +0000
@@ -222,31 +222,31 @@
   case 3:
     printf("mpeg2ext ");
     switch(attr->quantization) {
-      case 0:
-        printf("no drc ");
-        break;
-      case 1:
-        printf("drc ");
-        break;
-      default:
-        printf("(please send a bug report) mpeg reserved quant/drc  (%d)", attr->quantization);
+    case 0:
+      printf("no drc ");
+      break;
+    case 1:
+      printf("drc ");
+      break;
+    default:
+      printf("(please send a bug report) mpeg reserved quant/drc  (%d)", attr->quantization);
     }
     break;
   case 4:
     printf("lpcm ");
     switch(attr->quantization) {
-      case 0:
-        printf("16bit ");
-        break;
-      case 1:
-        printf("20bit ");
-        break;
-      case 2:
-        printf("24bit ");
-        break;
-      case 3:
-        printf("(please send a bug report) lpcm reserved quant/drc  (%d)", attr->quantization);
+    case 0:
+      printf("16bit ");
+      break;
+    case 1:
+      printf("20bit ");
       break;
+    case 2:
+      printf("24bit ");
+      break;
+    case 3:
+      printf("(please send a bug report) lpcm reserved quant/drc  (%d)", attr->quantization);
+    break;
     }
     break;
   case 5:
@@ -806,7 +806,7 @@
     printf("\tTitle playback type: (%02x)\n",
            *(uint8_t *)&(tt_srpt->title[i].pb_ty));
     printf("\t\t%s\n",
-       tt_srpt->title[i].pb_ty.multi_or_random_pgc_title ? "Random or Shuffle" : "Sequencial");
+           tt_srpt->title[i].pb_ty.multi_or_random_pgc_title ? "Random or Shuffle" : "Sequencial");
     if (tt_srpt->title[i].pb_ty.jlc_exists_in_cell_cmd) printf("\t\tJump/Link/Call exists in cell cmd\n");
     if (tt_srpt->title[i].pb_ty.jlc_exists_in_prepost_cmd) printf("\t\tJump/Link/Call exists in pre/post cmd\n");
     if (tt_srpt->title[i].pb_ty.jlc_exists_in_button_cmd) printf("\t\tJump/Link/Call exists in button cmd\n");
@@ -960,15 +960,15 @@
     printf("\nProgram (PGC): %3i\n", i + 1);
     if (pgc_type) {
        printf("PGC Category: Entry PGC %d, Menu Type=0x%02x:%s (Entry id 0x%02x), ",
-            pgcit->pgci_srp[i].entry_id >> 7,
-            pgcit->pgci_srp[i].entry_id & 0xf,
-            ifo_print_menu_name(pgcit->pgci_srp[i].entry_id & 0xf),
-            pgcit->pgci_srp[i].entry_id);
+              pgcit->pgci_srp[i].entry_id >> 7,
+              pgcit->pgci_srp[i].entry_id & 0xf,
+              ifo_print_menu_name(pgcit->pgci_srp[i].entry_id & 0xf),
+              pgcit->pgci_srp[i].entry_id);
     } else {
        printf("PGC Category: %s VTS_TTN:0x%02x (Entry id 0x%02x), ",
-            pgcit->pgci_srp[i].entry_id >> 7 ? "At Start of" : "During",
-            pgcit->pgci_srp[i].entry_id & 0xf,
-            pgcit->pgci_srp[i].entry_id);
+              pgcit->pgci_srp[i].entry_id >> 7 ? "At Start of" : "During",
+              pgcit->pgci_srp[i].entry_id & 0xf,
+              pgcit->pgci_srp[i].entry_id);
     }
     printf("Parental ID mask 0x%04x\n", pgcit->pgci_srp[i].ptl_id_mask);
     ifo_print_PGC(pgcit->pgci_srp[i].pgc);
--- a/ifo_read.c	Tue Sep 23 09:14:45 2008 +0000
+++ b/ifo_read.c	Thu Sep 25 09:17:42 2008 +0000
@@ -39,19 +39,19 @@
 #endif
 
 #ifndef NDEBUG
-#define CHECK_ZERO0(arg) \
-  if(arg != 0) { \
+#define CHECK_ZERO0(arg)                                                \
+  if(arg != 0) {                                                        \
     fprintf(stderr, "*** Zero check failed in %s:%i\n    for %s = 0x%x\n", \
-            __FILE__, __LINE__, # arg, arg); \
+            __FILE__, __LINE__, # arg, arg);                            \
   }
-#define CHECK_ZERO(arg) \
-  if(memcmp(my_friendly_zeros, &arg, sizeof(arg))) { \
-    unsigned int i_CZ; \
-    fprintf(stderr, "*** Zero check failed in %s:%i\n    for %s = 0x", \
-            __FILE__, __LINE__, # arg ); \
-    for(i_CZ = 0; i_CZ < sizeof(arg); i_CZ++) \
-      fprintf(stderr, "%02x", *((uint8_t *)&arg + i_CZ)); \
-    fprintf(stderr, "\n"); \
+#define CHECK_ZERO(arg)                                                 \
+  if(memcmp(my_friendly_zeros, &arg, sizeof(arg))) {                    \
+    unsigned int i_CZ;                                                  \
+    fprintf(stderr, "*** Zero check failed in %s:%i\n    for %s = 0x",  \
+            __FILE__, __LINE__, # arg );                                \
+    for(i_CZ = 0; i_CZ < sizeof(arg); i_CZ++)                           \
+      fprintf(stderr, "%02x", *((uint8_t *)&arg + i_CZ));               \
+    fprintf(stderr, "\n");                                              \
   }
 static const uint8_t my_friendly_zeros[2048];
 #else
@@ -345,7 +345,6 @@
       return NULL;
     }
 
-
     ifoRead_PGCI_UT(ifofile);
     ifoRead_VTS_TMAPT(ifofile);
     ifoRead_C_ADT(ifofile);
@@ -535,12 +534,12 @@
   CHECK_VALUE(vmgi_mat->vmg_nr_of_title_sets != 0);
   CHECK_VALUE(vmgi_mat->vmgi_last_byte >= 341);
   CHECK_VALUE(vmgi_mat->vmgi_last_byte / DVD_BLOCK_LEN <=
-         vmgi_mat->vmgi_last_sector);
+              vmgi_mat->vmgi_last_sector);
   /* It seems that first_play_pgc is optional. */
   CHECK_VALUE(vmgi_mat->first_play_pgc < vmgi_mat->vmgi_last_byte);
   CHECK_VALUE(vmgi_mat->vmgm_vobs == 0 ||
-        (vmgi_mat->vmgm_vobs > vmgi_mat->vmgi_last_sector &&
-         vmgi_mat->vmgm_vobs < vmgi_mat->vmg_last_sector));
+              (vmgi_mat->vmgm_vobs > vmgi_mat->vmgi_last_sector &&
+               vmgi_mat->vmgm_vobs < vmgi_mat->vmg_last_sector));
   CHECK_VALUE(vmgi_mat->tt_srpt <= vmgi_mat->vmgi_last_sector);
   CHECK_VALUE(vmgi_mat->vmgm_pgci_ut <= vmgi_mat->vmgi_last_sector);
   CHECK_VALUE(vmgi_mat->ptl_mait <= vmgi_mat->vmgi_last_sector);
@@ -632,11 +631,11 @@
   CHECK_VALUE(vtsi_mat->vtsi_last_sector*2 <= vtsi_mat->vts_last_sector);
   CHECK_VALUE(vtsi_mat->vtsi_last_byte/DVD_BLOCK_LEN <= vtsi_mat->vtsi_last_sector);
   CHECK_VALUE(vtsi_mat->vtsm_vobs == 0 ||
-       (vtsi_mat->vtsm_vobs > vtsi_mat->vtsi_last_sector &&
-         vtsi_mat->vtsm_vobs < vtsi_mat->vts_last_sector));
+              (vtsi_mat->vtsm_vobs > vtsi_mat->vtsi_last_sector &&
+               vtsi_mat->vtsm_vobs < vtsi_mat->vts_last_sector));
   CHECK_VALUE(vtsi_mat->vtstt_vobs == 0 ||
-        (vtsi_mat->vtstt_vobs > vtsi_mat->vtsi_last_sector &&
-         vtsi_mat->vtstt_vobs < vtsi_mat->vts_last_sector));
+              (vtsi_mat->vtstt_vobs > vtsi_mat->vtsi_last_sector &&
+               vtsi_mat->vtstt_vobs < vtsi_mat->vts_last_sector));
   CHECK_VALUE(vtsi_mat->vts_ptt_srpt <= vtsi_mat->vtsi_last_sector);
   CHECK_VALUE(vtsi_mat->vts_pgcit <= vtsi_mat->vtsi_last_sector);
   CHECK_VALUE(vtsi_mat->vtsm_pgci_ut <= vtsi_mat->vtsi_last_sector);
@@ -786,9 +785,9 @@
     read_cell_playback(&cell_playback[i]);
     /* Changed < to <= because this was false in the movie 'Pi'. */
     CHECK_VALUE(cell_playback[i].last_vobu_start_sector <=
-           cell_playback[i].last_sector);
+                cell_playback[i].last_sector);
     CHECK_VALUE(cell_playback[i].first_sector <=
-           cell_playback[i].last_vobu_start_sector);
+                cell_playback[i].last_vobu_start_sector);
   }
 
   return 1;
@@ -1314,13 +1313,13 @@
       return 0;
     }
     if(!(DVDReadBytes(ifofile->file, pf_temp, info_length))) {
-       fprintf(stderr, "libdvdread: Unable to read PTL_MAIT table.\n");
-       free(pf_temp);
-       free_ptl_mait(ptl_mait, i);
-       return 0;
+      fprintf(stderr, "libdvdread: Unable to read PTL_MAIT table.\n");
+      free(pf_temp);
+      free_ptl_mait(ptl_mait, i);
+      return 0;
     }
     for (j = 0; j < ((ptl_mait->nr_of_vtss + 1) * 8); j++) {
-        B2N_16(pf_temp[j]);
+      B2N_16(pf_temp[j]);
     }
     ptl_mait->countries[i].pf_ptl_mai = (pf_level_t *)malloc(info_length);
     if(!ptl_mait->countries[i].pf_ptl_mai) {
@@ -1350,7 +1349,7 @@
 
   if(ifofile->ptl_mait) {
     for(i = 0; i < ifofile->ptl_mait->nr_of_countries; i++) {
-       free(ifofile->ptl_mait->countries[i].pf_ptl_mai);
+      free(ifofile->ptl_mait->countries[i].pf_ptl_mai);
     }
     free(ifofile->ptl_mait->countries);
     free(ifofile->ptl_mait);
@@ -1420,7 +1419,7 @@
   }
 
   for (i = 0; i < vts_tmapt->nr_of_tmaps; i++) {
-     B2N_32(vts_tmap_srp[i]);
+    B2N_32(vts_tmap_srp[i]);
   }
 
 
@@ -1600,7 +1599,7 @@
     CHECK_VALUE(c_adt->cell_adr_table[i].vob_id <= c_adt->nr_of_vobs);
     CHECK_VALUE(c_adt->cell_adr_table[i].cell_id > 0);
     CHECK_VALUE(c_adt->cell_adr_table[i].start_sector <
-           c_adt->cell_adr_table[i].last_sector);
+                c_adt->cell_adr_table[i].last_sector);
   }
 
   return 1;
@@ -1934,7 +1933,7 @@
     free(data);
     free(pgci_ut);
     ifofile->pgci_ut = 0;
-   return 0;
+    return 0;
   }
   ptr = data;
   for(i = 0; i < pgci_ut->nr_of_lus; i++) {
@@ -1948,7 +1947,7 @@
   for(i = 0; i < pgci_ut->nr_of_lus; i++) {
     /* Maybe this is only defined for v1.1 and later titles? */
     /* If the bits in 'lu[i].exists' are enumerated abcd efgh then:
-            VTS_x_yy.IFO        VIDEO_TS.IFO
+       VTS_x_yy.IFO        VIDEO_TS.IFO
        a == 0x83 "Root"         0x82 "Title"
        b == 0x84 "Subpicture"
        c == 0x85 "Audio"
@@ -1985,10 +1984,8 @@
       ifofile->pgci_ut = 0;
       return 0;
     }
-    /*
-                 * FIXME: Iterate and verify that all menus that should exists accordingly
-                 * to pgci_ut->lu[i].exists really do?
-                 */
+    /* FIXME: Iterate and verify that all menus that should exists accordingly
+     * to pgci_ut->lu[i].exists really do? */
   }
 
   return 1;
@@ -2102,7 +2099,7 @@
   CHECK_VALUE(vts_atrt->nr_of_vtss != 0);
   CHECK_VALUE(vts_atrt->nr_of_vtss < 100); /* ?? */
   CHECK_VALUE((uint32_t)vts_atrt->nr_of_vtss * (4 + VTS_ATTRIBUTES_MIN_SIZE) +
-         VTS_ATRT_SIZE < vts_atrt->last_byte + 1);
+              VTS_ATRT_SIZE < vts_atrt->last_byte + 1);
 
   info_length = vts_atrt->nr_of_vtss * sizeof(uint32_t);
   data = (uint32_t *)malloc(info_length);
@@ -2209,4 +2206,3 @@
     ifofile->txtdt_mgi = 0;
   }
 }
-
--- a/ifo_types.h	Tue Sep 23 09:14:45 2008 +0000
+++ b/ifo_types.h	Thu Sep 25 09:17:42 2008 +0000
@@ -211,6 +211,7 @@
   unsigned int interleaved      : 1;
   unsigned int stc_discontinuity: 1;
   unsigned int seamless_angle   : 1;
+
   unsigned int playback_mode    : 1;  /**< When set, enter StillMode after each VOBU */
   unsigned int restricted       : 1;  /**< ?? drop out of fastforward? */
   unsigned int unknown2         : 6;
--- a/md5.c	Tue Sep 23 09:14:45 2008 +0000
+++ b/md5.c	Thu Sep 25 09:17:42 2008 +0000
@@ -41,7 +41,7 @@
 
 #ifdef WORDS_BIGENDIAN
 # define SWAP(n)                                                        \
-    (((n) << 24) | (((n) & 0xff00) << 8) | (((n) >> 8) & 0xff00) | ((n) >> 24))
+  (((n) << 24) | (((n) & 0xff00) << 8) | (((n) >> 8) & 0xff00) | ((n) >> 24))
 #else
 # define SWAP(n) (n)
 #endif
@@ -160,7 +160,7 @@
         break;
 
       /* Process buffer with BLOCKSIZE bytes.  Note that
-                        BLOCKSIZE % 64 == 0
+         BLOCKSIZE % 64 == 0
        */
       md5_process_block (buffer, BLOCKSIZE, &ctx);
     }
@@ -294,14 +294,14 @@
          before the computation.  To reduce the work for the next steps
          we store the swapped words in the array CORRECT_WORDS.  */
 
-#define OP(a, b, c, d, s, T)                                            \
-      do                                                                \
-        {                                                               \
-          a += FF (b, c, d) + (*cwp++ = SWAP (*words)) + T;             \
-          ++words;                                                      \
-          a = rol (a, s);                                               \
-          a += b;                                                       \
-        }                                                               \
+#define OP(a, b, c, d, s, T)                                    \
+      do                                                        \
+        {                                                       \
+          a += FF (b, c, d) + (*cwp++ = SWAP (*words)) + T;     \
+          ++words;                                              \
+          a = rol (a, s);                                       \
+          a += b;                                               \
+        }                                                       \
       while (0)
 
       /* Before we start, one word to the strange constants.
@@ -333,13 +333,13 @@
          in CORRECT_WORDS.  Redefine the macro to take an additional first
          argument specifying the function to use.  */
 #undef OP
-#define OP(f, a, b, c, d, k, s, T)                                      \
-      do                                                                \
-        {                                                               \
-          a += f (b, c, d) + correct_words[k] + T;                      \
-          a = rol (a, s);                                               \
-          a += b;                                                       \
-        }                                                               \
+#define OP(f, a, b, c, d, k, s, T)                      \
+      do                                                \
+        {                                               \
+          a += f (b, c, d) + correct_words[k] + T;      \
+          a = rol (a, s);                               \
+          a += b;                                       \
+        }                                               \
       while (0)
 
       /* Round 2.  */
--- a/md5.h	Tue Sep 23 09:14:45 2008 +0000
+++ b/md5.h	Thu Sep 25 09:17:42 2008 +0000
@@ -54,17 +54,17 @@
 # endif
 
 # if UINT_MAX == UINT_MAX_32_BITS
-   typedef unsigned int md5_uint32;
+typedef unsigned int md5_uint32;
 # else
 #  if USHRT_MAX == UINT_MAX_32_BITS
-    typedef unsigned short md5_uint32;
+typedef unsigned short md5_uint32;
 #  else
 #   if ULONG_MAX == UINT_MAX_32_BITS
-     typedef unsigned long md5_uint32;
+typedef unsigned long md5_uint32;
 #   else
-     /* The following line is intended to evoke an error.
-        Using #error is not portable enough.  */
-     "Cannot determine unsigned 32-bit data type."
+/* The following line is intended to evoke an error.
+   Using #error is not portable enough.  */
+"Cannot determine unsigned 32-bit data type."
 #   endif
 #  endif
 # endif
--- a/nav_print.c	Tue Sep 23 09:14:45 2008 +0000
+++ b/nav_print.c	Thu Sep 25 09:17:42 2008 +0000
@@ -248,5 +248,3 @@
   navPrint_VOBU_SRI(&dsi->vobu_sri);
   navPrint_SYNCI(&dsi->synci);
 }
-
-
--- a/nav_read.c	Tue Sep 23 09:14:45 2008 +0000
+++ b/nav_read.c	Thu Sep 25 09:17:42 2008 +0000
@@ -140,7 +140,6 @@
   }
 
 
-
 #ifndef NDEBUG
   /* Asserts */
 
@@ -160,7 +159,7 @@
     CHECK_VALUE(pci->hli.hl_gi.btngr_ns != 0);
   } else {
     CHECK_VALUE((pci->hli.hl_gi.btn_ns != 0 && pci->hli.hl_gi.btngr_ns != 0)
-           || (pci->hli.hl_gi.btn_ns == 0 && pci->hli.hl_gi.btngr_ns == 0));
+                || (pci->hli.hl_gi.btn_ns == 0 && pci->hli.hl_gi.btngr_ns == 0));
   }
 
   /* pci hli btnit */
@@ -264,4 +263,3 @@
   /* dsi dsi gi */
   CHECK_VALUE(dsi->dsi_gi.zero1 == 0);
 }
-
--- a/nav_types.h	Tue Sep 23 09:14:45 2008 +0000
+++ b/nav_types.h	Thu Sep 25 09:17:42 2008 +0000
@@ -195,8 +195,8 @@
  * Seamless Angle Infromation for one angle
  */
 typedef struct {
-    uint32_t address; /**< offset to next ILVU, high bit is before/after */
-    uint16_t size;    /**< byte size of the ILVU pointed to by address */
+  uint32_t address; /**< offset to next ILVU, high bit is before/after */
+  uint16_t size;    /**< byte size of the ILVU pointed to by address */
 } ATTRIBUTE_PACKED sml_agl_data_t;
 
 /**