Fixed compiler warnings and linking errors in MSVC.

Changed tabs to spaces in tng_compression functions.

1 files changed, 622 insertions, 622 deletions

diff --git a/src/compression/tng_compress.c b/src/compression/tng_compress.c
index a63e7a1..62c6326 100644
--- a/src/compression/tng_compress.c
+++ b/src/compression/tng_compress.c
@@ -24,7 +24,7 @@
 #define MAGIC_INT_VEL 0x56474E54
 
 #define SPEED_DEFAULT 2 /* Default to relatively fast compression. For very good compression it makes sense to
-			   choose speed=4 or speed=5 */
+                           choose speed=4 or speed=5 */
 
 #define PRECISION(hi,lo) (Ptngc_i32x2_to_d(hi,lo))
 
@@ -36,16 +36,16 @@ static int verify_input_data(double *x, int natoms, int nframes, double precisio
   for (iframe=0; iframe<nframes; iframe++)
     for (i=0; i<natoms; i++)
       for (j=0; j<3; j++)
-	if (fabs(x[iframe*natoms*3+i*3+j]/precision+0.5)>=MAX_FVAL)
-	  goto error;
+        if (fabs(x[iframe*natoms*3+i*3+j]/precision+0.5)>=MAX_FVAL)
+          goto error;
   return 0;
  error:
 #if 0
   for (iframe=0; iframe<nframes; iframe++)
     for (i=0; i<natoms; i++)
       for (j=0; j<3; j++)
-	if (fabs(x[iframe*natoms*3+i*3+j]/precision+0.5)>=MAX_FVAL)
-	  printf("ERROR. Too large value: %d %d %d: %g %g %g\n",iframe,i,j,x[iframe*natoms*3+i*3+j],precision,x[iframe*natoms*3+i*3+j]/precision/MAX_FVAL);
+        if (fabs(x[iframe*natoms*3+i*3+j]/precision+0.5)>=MAX_FVAL)
+          printf("ERROR. Too large value: %d %d %d: %g %g %g\n",iframe,i,j,x[iframe*natoms*3+i*3+j],precision,x[iframe*natoms*3+i*3+j]/precision/MAX_FVAL);
 #endif
   return 1;
 }
@@ -56,46 +56,46 @@ static int verify_input_data_float(float *x, int natoms, int nframes, float prec
   for (iframe=0; iframe<nframes; iframe++)
     for (i=0; i<natoms; i++)
       for (j=0; j<3; j++)
-	if (fabs(x[iframe*natoms*3+i*3+j]/precision+0.5)>=MAX_FVAL)
-	  goto error;
+        if (fabs(x[iframe*natoms*3+i*3+j]/precision+0.5)>=MAX_FVAL)
+          goto error;
   return 0;
  error:
 #if 0
   for (iframe=0; iframe<nframes; iframe++)
     for (i=0; i<natoms; i++)
       for (j=0; j<3; j++)
-	if (fabs(x[iframe*natoms*3+i*3+j]/precision+0.5)>=MAX_FVAL)
-	  printf("ERROR. Too large value: %d %d %d: %g %g %g\n",iframe,i,j,x[iframe*natoms*3+i*3+j],precision,x[iframe*natoms*3+i*3+j]/precision/MAX_FVAL);
+        if (fabs(x[iframe*natoms*3+i*3+j]/precision+0.5)>=MAX_FVAL)
+          printf("ERROR. Too large value: %d %d %d: %g %g %g\n",iframe,i,j,x[iframe*natoms*3+i*3+j],precision,x[iframe*natoms*3+i*3+j]/precision/MAX_FVAL);
 #endif
   return 1;
 }
 
 static int quantize(double *x, int natoms, int nframes,
-		     double precision,
-		     int *quant)
+                     double precision,
+                     int *quant)
 {
   int iframe, i, j;
   for (iframe=0; iframe<nframes; iframe++)
     for (i=0; i<natoms; i++)
       for (j=0; j<3; j++)
-	quant[iframe*natoms*3+i*3+j]=(int)floor((x[iframe*natoms*3+i*3+j]/precision)+0.5);
+        quant[iframe*natoms*3+i*3+j]=(int)floor((x[iframe*natoms*3+i*3+j]/precision)+0.5);
   return verify_input_data(x,natoms,nframes,precision);
 }
 
 static int quantize_float(float *x, int natoms, int nframes,
-			   float precision,
-			   int *quant)
+                           float precision,
+                           int *quant)
 {
   int iframe, i, j;
   for (iframe=0; iframe<nframes; iframe++)
     for (i=0; i<natoms; i++)
       for (j=0; j<3; j++)
-	quant[iframe*natoms*3+i*3+j]=(int)floor((x[iframe*natoms*3+i*3+j]/precision)+0.5);
+        quant[iframe*natoms*3+i*3+j]=(int)floor((x[iframe*natoms*3+i*3+j]/precision)+0.5);
   return verify_input_data_float(x,natoms,nframes,precision);
 }
 
 static void quant_inter_differences(int *quant, int natoms, int nframes,
-				    int *quant_inter)
+                                    int *quant_inter)
 {
   int iframe, i, j;
   /* The first frame is used for absolute positions. */
@@ -106,97 +106,97 @@ static void quant_inter_differences(int *quant, int natoms, int nframes,
   for (iframe=1; iframe<nframes; iframe++)
     for (i=0; i<natoms; i++)
       for (j=0; j<3; j++)
-	quant_inter[iframe*natoms*3+i*3+j]=quant[iframe*natoms*3+i*3+j]-quant[(iframe-1)*natoms*3+i*3+j];
+        quant_inter[iframe*natoms*3+i*3+j]=quant[iframe*natoms*3+i*3+j]-quant[(iframe-1)*natoms*3+i*3+j];
 }
 
 static void quant_intra_differences(int *quant, int natoms, int nframes,
-				    int *quant_intra)
+                                    int *quant_intra)
 {
   int iframe, i, j;
   for (iframe=0; iframe<nframes; iframe++)
     {
       /* The first atom is used with its absolute position. */
       for (j=0; j<3; j++)
-	quant_intra[iframe*natoms*3+j]=quant[iframe*natoms*3+j];
+        quant_intra[iframe*natoms*3+j]=quant[iframe*natoms*3+j];
       /* For all other atoms the intraframe differences are computed. */
       for (i=1; i<natoms; i++)
-	for (j=0; j<3; j++)
-	  quant_intra[iframe*natoms*3+i*3+j]=quant[iframe*natoms*3+i*3+j]-quant[iframe*natoms*3+(i-1)*3+j];
+        for (j=0; j<3; j++)
+          quant_intra[iframe*natoms*3+i*3+j]=quant[iframe*natoms*3+i*3+j]-quant[iframe*natoms*3+(i-1)*3+j];
     }
 }
 
 static void unquantize(double *x, int natoms, int nframes,
-		       double precision,
-		       int *quant)
+                       double precision,
+                       int *quant)
 {
   int iframe, i, j;
   for (iframe=0; iframe<nframes; iframe++)
     for (i=0; i<natoms; i++)
       for (j=0; j<3; j++)
-	x[iframe*natoms*3+i*3+j]=(double)quant[iframe*natoms*3+i*3+j]*precision;
+        x[iframe*natoms*3+i*3+j]=(double)quant[iframe*natoms*3+i*3+j]*precision;
 }
 
 static void unquantize_float(float *x, int natoms, int nframes,
-			     float precision,
-			     int *quant)
+                             float precision,
+                             int *quant)
 {
   int iframe, i, j;
   for (iframe=0; iframe<nframes; iframe++)
     for (i=0; i<natoms; i++)
       for (j=0; j<3; j++)
-	x[iframe*natoms*3+i*3+j]=(float)quant[iframe*natoms*3+i*3+j]*precision;
+        x[iframe*natoms*3+i*3+j]=(float)quant[iframe*natoms*3+i*3+j]*precision;
 }
 
 static void unquantize_inter_differences(double *x, int natoms, int nframes,
-					 double precision,
-					 int *quant)
+                                         double precision,
+                                         int *quant)
 {
   int iframe, i, j;
   for (i=0; i<natoms; i++)
     for (j=0; j<3; j++)
       {
-	int q=quant[i*3+j]; /* First value. */
-	x[i*3+j]=(double)q*precision;
-	for (iframe=1; iframe<nframes; iframe++)
-	  {
-	    q+=quant[iframe*natoms*3+i*3+j];
-	    x[iframe*natoms*3+i*3+j]=(double)q*precision;
-	  }
+        int q=quant[i*3+j]; /* First value. */
+        x[i*3+j]=(double)q*precision;
+        for (iframe=1; iframe<nframes; iframe++)
+          {
+            q+=quant[iframe*natoms*3+i*3+j];
+            x[iframe*natoms*3+i*3+j]=(double)q*precision;
+          }
       }
 }
 
 static void unquantize_inter_differences_float(float *x, int natoms, int nframes,
-					       float precision,
-					       int *quant)
+                                               float precision,
+                                               int *quant)
 {
   int iframe, i, j;
   for (i=0; i<natoms; i++)
     for (j=0; j<3; j++)
       {
-	int q=quant[i*3+j]; /* First value. */
-	x[i*3+j]=(float)q*precision;
-	for (iframe=1; iframe<nframes; iframe++)
-	  {
-	    q+=quant[iframe*natoms*3+i*3+j];
-	    x[iframe*natoms*3+i*3+j]=(float)q*precision;
-	  }
+        int q=quant[i*3+j]; /* First value. */
+        x[i*3+j]=(float)q*precision;
+        for (iframe=1; iframe<nframes; iframe++)
+          {
+            q+=quant[iframe*natoms*3+i*3+j];
+            x[iframe*natoms*3+i*3+j]=(float)q*precision;
+          }
       }
 }
 
 static void unquantize_inter_differences_int(int *x, int natoms, int nframes,
-					     int *quant)
+                                             int *quant)
 {
   int iframe, i, j;
   for (i=0; i<natoms; i++)
     for (j=0; j<3; j++)
       {
-	int q=quant[i*3+j]; /* First value. */
-	x[i*3+j]=q;
-	for (iframe=1; iframe<nframes; iframe++)
-	  {
-	    q+=quant[iframe*natoms*3+i*3+j];
-	    x[iframe*natoms*3+i*3+j]=q;
-	  }
+        int q=quant[i*3+j]; /* First value. */
+        x[i*3+j]=q;
+        for (iframe=1; iframe<nframes; iframe++)
+          {
+            q+=quant[iframe*natoms*3+i*3+j];
+            x[iframe*natoms*3+i*3+j]=q;
+          }
       }
 }
 
@@ -209,23 +209,23 @@ static void unquant_intra_differences_first_frame(int *quant, int natoms)
     {
       int q=quant[j];
       for (i=1; i<natoms; i++)
-	{
-	  q+=quant[i*3+j];
-	  quant[i*3+j]=q;
-	}
+        {
+          q+=quant[i*3+j];
+          quant[i*3+j]=q;
+        }
     }
 #if 0
   for (j=0; j<3; j++)
     for (i=0; i<natoms; i++)
       {
-	printf("UQ: %d %d %d: %d\n",0,j,i,quant[i*3+j]);
+        printf("UQ: %d %d %d: %d\n",0,j,i,quant[i*3+j]);
       }
 #endif
 }
 
 static void unquantize_intra_differences(double *x, int natoms, int nframes,
-					 double precision,
-					 int *quant)
+                                         double precision,
+                                         int *quant)
 {
   int iframe, i, j;
 #if 0
@@ -234,48 +234,48 @@ static void unquantize_intra_differences(double *x, int natoms, int nframes,
   for (iframe=0; iframe<nframes; iframe++)
     for (j=0; j<3; j++)
       {
-	int q=quant[iframe*natoms*3+j];
-	x[iframe*natoms*3+j]=(double)q*precision;
-	for (i=1; i<natoms; i++)
-	  {
-	    q+=quant[iframe*natoms*3+i*3+j];
-	    x[iframe*natoms*3+i*3+j]=(double)q*precision;
-	  }
+        int q=quant[iframe*natoms*3+j];
+        x[iframe*natoms*3+j]=(double)q*precision;
+        for (i=1; i<natoms; i++)
+          {
+            q+=quant[iframe*natoms*3+i*3+j];
+            x[iframe*natoms*3+i*3+j]=(double)q*precision;
+          }
       }
 }
 
 static void unquantize_intra_differences_float(float *x, int natoms, int nframes,
-					       float precision,
-					       int *quant)
+                                               float precision,
+                                               int *quant)
 {
   int iframe, i, j;
   for (iframe=0; iframe<nframes; iframe++)
     for (j=0; j<3; j++)
       {
-	int q=quant[iframe*natoms*3+j];
-	x[iframe*natoms*3+j]=(float)q*precision;
-	for (i=1; i<natoms; i++)
-	  {
-	    q+=quant[iframe*natoms*3+i*3+j];
-	    x[iframe*natoms*3+i*3+j]=(float)q*precision;
-	  }
+        int q=quant[iframe*natoms*3+j];
+        x[iframe*natoms*3+j]=(float)q*precision;
+        for (i=1; i<natoms; i++)
+          {
+            q+=quant[iframe*natoms*3+i*3+j];
+            x[iframe*natoms*3+i*3+j]=(float)q*precision;
+          }
       }
 }
 
 static void unquantize_intra_differences_int(int *x, int natoms, int nframes,
-					     int *quant)
+                                             int *quant)
 {
   int iframe, i, j;
   for (iframe=0; iframe<nframes; iframe++)
     for (j=0; j<3; j++)
       {
-	int q=quant[iframe*natoms*3+j];
-	x[iframe*natoms*3+j]=q;
-	for (i=1; i<natoms; i++)
-	  {
-	    q+=quant[iframe*natoms*3+i*3+j];
-	    x[iframe*natoms*3+i*3+j]=q;
-	  }
+        int q=quant[iframe*natoms*3+j];
+        x[iframe*natoms*3+j]=q;
+        for (i=1; i<natoms; i++)
+          {
+            q+=quant[iframe*natoms*3+i*3+j];
+            x[iframe*natoms*3+i*3+j]=q;
+          }
       }
 }
 
@@ -310,13 +310,13 @@ static fix_t readbufferfix(unsigned char *buf, int num)
 
 /* Perform position compression from the quantized data. */
 static void compress_quantized_pos(int *quant, int *quant_inter, int *quant_intra,
-				   int natoms, int nframes,
-				   int speed,
-				   int initial_coding, int initial_coding_parameter,
-				   int coding, int coding_parameter,
-				   fix_t prec_hi, fix_t prec_lo,
-				   int *nitems,
-				   char *data)
+                                   int natoms, int nframes,
+                                   int speed,
+                                   int initial_coding, int initial_coding_parameter,
+                                   int coding, int coding_parameter,
+                                   fix_t prec_hi, fix_t prec_lo,
+                                   int *nitems,
+                                   char *data)
 {
   int bufloc=0;
   char *datablock=NULL;
@@ -364,16 +364,16 @@ static void compress_quantized_pos(int *quant, int *quant_inter, int *quant_intr
       struct coder *coder=Ptngc_coder_init();
       length=natoms*3;
       datablock=(char*)Ptngc_pack_array(coder,quant,&length,
-					    initial_coding,initial_coding_parameter,natoms,speed);
+                                            initial_coding,initial_coding_parameter,natoms,speed);
       Ptngc_coder_deinit(coder);
     }
   else if ((initial_coding==TNG_COMPRESS_ALGO_POS_TRIPLET_INTRA) ||
-	   (initial_coding==TNG_COMPRESS_ALGO_POS_BWLZH_INTRA))
+           (initial_coding==TNG_COMPRESS_ALGO_POS_BWLZH_INTRA))
     {
       struct coder *coder=Ptngc_coder_init();
       length=natoms*3;
       datablock=(char*)Ptngc_pack_array(coder,quant_intra,&length,
-					    initial_coding,initial_coding_parameter,natoms,speed);
+                                            initial_coding,initial_coding_parameter,natoms,speed);
       Ptngc_coder_deinit(coder);
     }
   /* Block length. */
@@ -391,42 +391,42 @@ static void compress_quantized_pos(int *quant, int *quant_inter, int *quant_intr
       datablock=NULL;
       /* Inter-frame compression? */
       if ((coding==TNG_COMPRESS_ALGO_POS_STOPBIT_INTER) ||
-	  (coding==TNG_COMPRESS_ALGO_POS_TRIPLET_INTER) ||
-	  (coding==TNG_COMPRESS_ALGO_POS_BWLZH_INTER))
-	{
-	  struct coder *coder=Ptngc_coder_init();
-	  length=natoms*3*(nframes-1);
-	  datablock=(char*)Ptngc_pack_array(coder,quant_inter+natoms*3,&length,
-						coding,coding_parameter,natoms,speed);
-	  Ptngc_coder_deinit(coder);
-	}
+          (coding==TNG_COMPRESS_ALGO_POS_TRIPLET_INTER) ||
+          (coding==TNG_COMPRESS_ALGO_POS_BWLZH_INTER))
+        {
+          struct coder *coder=Ptngc_coder_init();
+          length=natoms*3*(nframes-1);
+          datablock=(char*)Ptngc_pack_array(coder,quant_inter+natoms*3,&length,
+                                                coding,coding_parameter,natoms,speed);
+          Ptngc_coder_deinit(coder);
+        }
       /* One-to-one compression? */
       else if ((coding==TNG_COMPRESS_ALGO_POS_XTC2) ||
-	       (coding==TNG_COMPRESS_ALGO_POS_XTC3) ||
-	       (coding==TNG_COMPRESS_ALGO_POS_TRIPLET_ONETOONE))
-	{
-	  struct coder *coder=Ptngc_coder_init();
-	  length=natoms*3*(nframes-1);
-	  datablock=(char*)Ptngc_pack_array(coder,quant+natoms*3,&length,
-						coding,coding_parameter,natoms,speed);
-	  Ptngc_coder_deinit(coder);
-	}
+               (coding==TNG_COMPRESS_ALGO_POS_XTC3) ||
+               (coding==TNG_COMPRESS_ALGO_POS_TRIPLET_ONETOONE))
+        {
+          struct coder *coder=Ptngc_coder_init();
+          length=natoms*3*(nframes-1);
+          datablock=(char*)Ptngc_pack_array(coder,quant+natoms*3,&length,
+                                                coding,coding_parameter,natoms,speed);
+          Ptngc_coder_deinit(coder);
+        }
       /* Intra-frame compression? */
       else if ((coding==TNG_COMPRESS_ALGO_POS_TRIPLET_INTRA) ||
-	       (coding==TNG_COMPRESS_ALGO_POS_BWLZH_INTRA))
-	{
-	  struct coder *coder=Ptngc_coder_init();
-	  length=natoms*3*(nframes-1);
-	  datablock=(char*)Ptngc_pack_array(coder,quant_intra+natoms*3,&length,
-						coding,coding_parameter,natoms,speed);
-	  Ptngc_coder_deinit(coder);
-	}
+               (coding==TNG_COMPRESS_ALGO_POS_BWLZH_INTRA))
+        {
+          struct coder *coder=Ptngc_coder_init();
+          length=natoms*3*(nframes-1);
+          datablock=(char*)Ptngc_pack_array(coder,quant_intra+natoms*3,&length,
+                                                coding,coding_parameter,natoms,speed);
+          Ptngc_coder_deinit(coder);
+        }
       /* Block length. */
       if (data)
-	bufferfix((unsigned char*)data+bufloc,(fix_t)length,4);
+        bufferfix((unsigned char*)data+bufloc,(fix_t)length,4);
       bufloc+=4;
       if (data)
-	memcpy(data+bufloc,datablock,length);
+        memcpy(data+bufloc,datablock,length);
       free(datablock);
       bufloc+=length;
     }
@@ -435,13 +435,13 @@ static void compress_quantized_pos(int *quant, int *quant_inter, int *quant_intr
 
 /* Perform velocity compression from vel into the data block */
 static void compress_quantized_vel(int *quant, int *quant_inter,
-				   int natoms, int nframes,
-				   int speed,
-				   int initial_coding, int initial_coding_parameter,
-				   int coding, int coding_parameter,
-				   fix_t prec_hi, fix_t prec_lo,
-				   int *nitems,
-				   char *data)
+                                   int natoms, int nframes,
+                                   int speed,
+                                   int initial_coding, int initial_coding_parameter,
+                                   int coding, int coding_parameter,
+                                   fix_t prec_hi, fix_t prec_lo,
+                                   int *nitems,
+                                   char *data)
 {
   int bufloc=0;
   char *datablock=NULL;
@@ -490,7 +490,7 @@ static void compress_quantized_vel(int *quant, int *quant_inter,
     {
       struct coder *coder=Ptngc_coder_init();
       datablock=(char*)Ptngc_pack_array(coder,quant,&length,
-					    initial_coding,initial_coding_parameter,natoms,speed);
+                                            initial_coding,initial_coding_parameter,natoms,speed);
       Ptngc_coder_deinit(coder);
     }
   /* Block length. */
@@ -510,32 +510,32 @@ static void compress_quantized_vel(int *quant, int *quant_inter,
       datablock=NULL;
       /* Inter-frame compression? */
       if ((coding==TNG_COMPRESS_ALGO_VEL_TRIPLET_INTER) ||
-	  (coding==TNG_COMPRESS_ALGO_VEL_STOPBIT_INTER) ||
-	  (coding==TNG_COMPRESS_ALGO_VEL_BWLZH_INTER))
-	{
-	  struct coder *coder=Ptngc_coder_init();
-	  length=natoms*3*(nframes-1);
-	  datablock=(char*)Ptngc_pack_array(coder,quant_inter+natoms*3,&length,
-						coding,coding_parameter,natoms,speed);
-	  Ptngc_coder_deinit(coder);
-	}
+          (coding==TNG_COMPRESS_ALGO_VEL_STOPBIT_INTER) ||
+          (coding==TNG_COMPRESS_ALGO_VEL_BWLZH_INTER))
+        {
+          struct coder *coder=Ptngc_coder_init();
+          length=natoms*3*(nframes-1);
+          datablock=(char*)Ptngc_pack_array(coder,quant_inter+natoms*3,&length,
+                                                coding,coding_parameter,natoms,speed);
+          Ptngc_coder_deinit(coder);
+        }
       /* One-to-one compression? */
       else if ((coding==TNG_COMPRESS_ALGO_VEL_STOPBIT_ONETOONE) ||
-	       (coding==TNG_COMPRESS_ALGO_VEL_TRIPLET_ONETOONE) ||
-	       (coding==TNG_COMPRESS_ALGO_VEL_BWLZH_ONETOONE))
-	{
-	  struct coder *coder=Ptngc_coder_init();
-	  length=natoms*3*(nframes-1);
-	  datablock=(char*)Ptngc_pack_array(coder,quant+natoms*3,&length,
-						coding,coding_parameter,natoms,speed);
-	  Ptngc_coder_deinit(coder);
-	}
+               (coding==TNG_COMPRESS_ALGO_VEL_TRIPLET_ONETOONE) ||
+               (coding==TNG_COMPRESS_ALGO_VEL_BWLZH_ONETOONE))
+        {
+          struct coder *coder=Ptngc_coder_init();
+          length=natoms*3*(nframes-1);
+          datablock=(char*)Ptngc_pack_array(coder,quant+natoms*3,&length,
+                                                coding,coding_parameter,natoms,speed);
+          Ptngc_coder_deinit(coder);
+        }
       /* Block length. */
       if (data)
-	bufferfix((unsigned char*)data+bufloc,(fix_t)length,4);
+        bufferfix((unsigned char*)data+bufloc,(fix_t)length,4);
       bufloc+=4;
       if (data)
-	memcpy(data+bufloc,datablock,length);
+        memcpy(data+bufloc,datablock,length);
       free(datablock);
       bufloc+=length;
     }
@@ -543,7 +543,7 @@ static void compress_quantized_vel(int *quant, int *quant_inter,
 }
 
 static int determine_best_coding_stop_bits(struct coder *coder,int *input, int *length,
-					   int *coding_parameter, int natoms)
+                                           int *coding_parameter, int natoms)
 {
   int bits;
   unsigned char *packed;
@@ -554,16 +554,16 @@ static int determine_best_coding_stop_bits(struct coder *coder,int *input, int *
     {
       io_length=*length;
       packed=Ptngc_pack_array(coder,input,&io_length,
-				  TNG_COMPRESS_ALGO_STOPBIT,bits,natoms,0);
+                                  TNG_COMPRESS_ALGO_STOPBIT,bits,natoms,0);
       if (packed)
-	{
-	  if ((new_parameter==-1) || (io_length<best_length))
-	    {
-	      new_parameter=bits;
-	      best_length=io_length;
-	    }
-	  free(packed);
-	}
+        {
+          if ((new_parameter==-1) || (io_length<best_length))
+            {
+              new_parameter=bits;
+              best_length=io_length;
+            }
+          free(packed);
+        }
     }
   if (new_parameter==-1)
     return 1;
@@ -574,7 +574,7 @@ static int determine_best_coding_stop_bits(struct coder *coder,int *input, int *
 }
 
 static int determine_best_coding_triple(struct coder *coder,int *input, int *length,
-					int *coding_parameter, int natoms)
+                                        int *coding_parameter, int natoms)
 {
   int bits;
   unsigned char *packed;
@@ -585,16 +585,16 @@ static int determine_best_coding_triple(struct coder *coder,int *input, int *len
     {
       io_length=*length;
       packed=Ptngc_pack_array(coder,input,&io_length,
-				  TNG_COMPRESS_ALGO_TRIPLET,bits,natoms,0);
+                                  TNG_COMPRESS_ALGO_TRIPLET,bits,natoms,0);
       if (packed)
-	{
-	  if ((new_parameter==-1) || (io_length<best_length))
-	    {
-	      new_parameter=bits;
-	      best_length=io_length;
-	    }
-	  free(packed);
-	}
+        {
+          if ((new_parameter==-1) || (io_length<best_length))
+            {
+              new_parameter=bits;
+              best_length=io_length;
+            }
+          free(packed);
+        }
     }
   if (new_parameter==-1)
     return 1;
@@ -605,8 +605,8 @@ static int determine_best_coding_triple(struct coder *coder,int *input, int *len
 }
 
 static void determine_best_pos_initial_coding(int *quant, int *quant_intra, int natoms, int speed,
-					      fix_t prec_hi, fix_t prec_lo,
-					      int *initial_coding, int *initial_coding_parameter)
+                                              fix_t prec_hi, fix_t prec_lo,
+                                              int *initial_coding, int *initial_coding_parameter)
 {
   if (*initial_coding==-1)
     {
@@ -622,8 +622,8 @@ static void determine_best_pos_initial_coding(int *quant, int *quant_intra, int
       current_coding=TNG_COMPRESS_ALGO_POS_XTC2;
       current_coding_parameter=0;
       compress_quantized_pos(quant,NULL,quant_intra,natoms,1,speed,
-			     current_coding,current_coding_parameter,
-			     0,0,prec_hi,prec_lo,&current_code_size,NULL);
+                             current_coding,current_coding_parameter,
+                             0,0,prec_hi,prec_lo,&current_code_size,NULL);
       best_coding=current_coding;
       best_coding_parameter=current_coding_parameter;
       best_code_size=current_code_size;
@@ -634,14 +634,14 @@ static void determine_best_pos_initial_coding(int *quant, int *quant_intra, int
       current_code_size=natoms*3;
       current_coding_parameter=0;
       if (!determine_best_coding_triple(coder,quant_intra,&current_code_size,&current_coding_parameter,natoms))
-	{
-	  if (current_code_size<best_code_size)
-	    {
-	      best_coding=current_coding;
-	      best_coding_parameter=current_coding_parameter;
-	      best_code_size=current_code_size;
-	    }
-	}
+        {
+          if (current_code_size<best_code_size)
+            {
+              best_coding=current_coding;
+              best_coding_parameter=current_coding_parameter;
+              best_code_size=current_code_size;
+            }
+        }
       Ptngc_coder_deinit(coder);
 
       /* Determine best parameter for triplet one-to-one. */
@@ -650,76 +650,76 @@ static void determine_best_pos_initial_coding(int *quant, int *quant_intra, int
       current_code_size=natoms*3;
       current_coding_parameter=0;
       if (!determine_best_coding_triple(coder,quant,&current_code_size,&current_coding_parameter,natoms))
-	{
-	  if (current_code_size<best_code_size)
-	    {
-	      best_coding=current_coding;
-	      best_coding_parameter=current_coding_parameter;
-	      best_code_size=current_code_size;
-	    }
-	}
+        {
+          if (current_code_size<best_code_size)
+            {
+              best_coding=current_coding;
+              best_coding_parameter=current_coding_parameter;
+              best_code_size=current_code_size;
+            }
+        }
       Ptngc_coder_deinit(coder);
 
       if (speed>=2)
-	{
-	  current_coding=TNG_COMPRESS_ALGO_POS_XTC3;
-	  current_coding_parameter=0;
-	  compress_quantized_pos(quant,NULL,quant_intra,natoms,1,speed,
-				 current_coding,current_coding_parameter,
-				 0,0,prec_hi,prec_lo,&current_code_size,NULL);
-	  if (current_code_size<best_code_size)
-	    {
-	      best_coding=current_coding;
-	      best_coding_parameter=current_coding_parameter;
-	      best_code_size=current_code_size;
-	    }
-	}
+        {
+          current_coding=TNG_COMPRESS_ALGO_POS_XTC3;
+          current_coding_parameter=0;
+          compress_quantized_pos(quant,NULL,quant_intra,natoms,1,speed,
+                                 current_coding,current_coding_parameter,
+                                 0,0,prec_hi,prec_lo,&current_code_size,NULL);
+          if (current_code_size<best_code_size)
+            {
+              best_coding=current_coding;
+              best_coding_parameter=current_coding_parameter;
+              best_code_size=current_code_size;
+            }
+        }
       /* Test BWLZH intra */
       if (speed>=6)
-	{
-	  current_coding=TNG_COMPRESS_ALGO_POS_BWLZH_INTRA;
-	  current_coding_parameter=0;
-	  compress_quantized_pos(quant,NULL,quant_intra,natoms,1,speed,
-				 current_coding,current_coding_parameter,
-				 0,0,prec_hi,prec_lo,&current_code_size,NULL);
-	  if (current_code_size<best_code_size)
-	    {
-	      best_coding=current_coding;
-	      best_coding_parameter=current_coding_parameter;
-	    }
-	}
+        {
+          current_coding=TNG_COMPRESS_ALGO_POS_BWLZH_INTRA;
+          current_coding_parameter=0;
+          compress_quantized_pos(quant,NULL,quant_intra,natoms,1,speed,
+                                 current_coding,current_coding_parameter,
+                                 0,0,prec_hi,prec_lo,&current_code_size,NULL);
+          if (current_code_size<best_code_size)
+            {
+              best_coding=current_coding;
+              best_coding_parameter=current_coding_parameter;
+            }
+        }
       *initial_coding=best_coding;
       *initial_coding_parameter=best_coding_parameter;
     }
   else
     {
       if (*initial_coding_parameter==-1)
-	{
-	  if ((*initial_coding==TNG_COMPRESS_ALGO_POS_XTC2) ||
-	      (*initial_coding==TNG_COMPRESS_ALGO_POS_XTC3) ||
-	      (*initial_coding==TNG_COMPRESS_ALGO_POS_BWLZH_INTRA))
-	    *initial_coding_parameter=0;
-	  else if (*initial_coding==TNG_COMPRESS_ALGO_POS_TRIPLET_INTRA)
-	    {
-	      struct coder *coder=Ptngc_coder_init();
-	      int current_code_size=natoms*3;
-	      determine_best_coding_triple(coder,quant_intra,&current_code_size,initial_coding_parameter,natoms);
-	      Ptngc_coder_deinit(coder);
-	    }
-	  else if (*initial_coding==TNG_COMPRESS_ALGO_POS_TRIPLET_ONETOONE)
-	    {
-	      struct coder *coder=Ptngc_coder_init();
-	      int current_code_size=natoms*3;
-	      determine_best_coding_triple(coder,quant,&current_code_size,initial_coding_parameter,natoms);
-	      Ptngc_coder_deinit(coder);
-	    }
-	}
+        {
+          if ((*initial_coding==TNG_COMPRESS_ALGO_POS_XTC2) ||
+              (*initial_coding==TNG_COMPRESS_ALGO_POS_XTC3) ||
+              (*initial_coding==TNG_COMPRESS_ALGO_POS_BWLZH_INTRA))
+            *initial_coding_parameter=0;
+          else if (*initial_coding==TNG_COMPRESS_ALGO_POS_TRIPLET_INTRA)
+            {
+              struct coder *coder=Ptngc_coder_init();
+              int current_code_size=natoms*3;
+              determine_best_coding_triple(coder,quant_intra,&current_code_size,initial_coding_parameter,natoms);
+              Ptngc_coder_deinit(coder);
+            }
+          else if (*initial_coding==TNG_COMPRESS_ALGO_POS_TRIPLET_ONETOONE)
+            {
+              struct coder *coder=Ptngc_coder_init();
+              int current_code_size=natoms*3;
+              determine_best_coding_triple(coder,quant,&current_code_size,initial_coding_parameter,natoms);
+              Ptngc_coder_deinit(coder);
+            }
+        }
     }
 }
 
 static void determine_best_pos_coding(int *quant, int *quant_inter, int *quant_intra, int natoms, int nframes, int speed,
-				      fix_t prec_hi, fix_t prec_lo,
-				      int *coding, int *coding_parameter)
+                                      fix_t prec_hi, fix_t prec_lo,
+                                      int *coding, int *coding_parameter)
 {
   if (*coding==-1)
     {
@@ -734,16 +734,16 @@ static void determine_best_pos_coding(int *quant, int *quant_inter, int *quant_i
       struct coder *coder;
       /* Always use XTC2 for the initial coding. */
       compress_quantized_pos(quant,quant_inter,quant_intra,natoms,1,speed,
-			     TNG_COMPRESS_ALGO_POS_XTC2,0,
-			     0,0,
-			     prec_hi,prec_lo,&initial_code_size,NULL);
+                             TNG_COMPRESS_ALGO_POS_XTC2,0,
+                             0,0,
+                             prec_hi,prec_lo,&initial_code_size,NULL);
       /* Start with XTC2, it should always work. */
       current_coding=TNG_COMPRESS_ALGO_POS_XTC2;
       current_coding_parameter=0;
       compress_quantized_pos(quant,quant_inter,quant_intra,natoms,nframes,speed,
-			     TNG_COMPRESS_ALGO_POS_XTC2,0,
-			     current_coding,current_coding_parameter,
-			     prec_hi,prec_lo,&current_code_size,NULL);
+                             TNG_COMPRESS_ALGO_POS_XTC2,0,
+                             current_coding,current_coding_parameter,
+                             prec_hi,prec_lo,&current_code_size,NULL);
       best_coding=current_coding;
       best_coding_parameter=current_coding_parameter;
       best_code_size=current_code_size-initial_code_size; /* Correct for the use of XTC2 for the first frame. */
@@ -754,15 +754,15 @@ static void determine_best_pos_coding(int *quant, int *quant_inter, int *quant_i
       current_code_size=natoms*3*(nframes-1);
       current_coding_parameter=0;
       if (!determine_best_coding_stop_bits(coder,quant_inter+natoms*3,&current_code_size,
-					   &current_coding_parameter,natoms))
-	{
-	  if (current_code_size<best_code_size)
-	    {
-	      best_coding=current_coding;
-	      best_coding_parameter=current_coding_parameter;
-	      best_code_size=current_code_size;
-	    }
-	}
+                                           &current_coding_parameter,natoms))
+        {
+          if (current_code_size<best_code_size)
+            {
+              best_coding=current_coding;
+              best_coding_parameter=current_coding_parameter;
+              best_code_size=current_code_size;
+            }
+        }
       Ptngc_coder_deinit(coder);
 
       /* Determine best parameter for triplet interframe coding. */
@@ -771,15 +771,15 @@ static void determine_best_pos_coding(int *quant, int *quant_inter, int *quant_i
       current_code_size=natoms*3*(nframes-1);
       current_coding_parameter=0;
       if (!determine_best_coding_triple(coder,quant_inter+natoms*3,&current_code_size,
-					&current_coding_parameter,natoms))
-	{
-	  if (current_code_size<best_code_size)
-	    {
-	      best_coding=current_coding;
-	      best_coding_parameter=current_coding_parameter;
-	      best_code_size=current_code_size;
-	    }
-	}
+                                        &current_coding_parameter,natoms))
+        {
+          if (current_code_size<best_code_size)
+            {
+              best_coding=current_coding;
+              best_coding_parameter=current_coding_parameter;
+              best_code_size=current_code_size;
+            }
+        }
       Ptngc_coder_deinit(coder);
 
       /* Determine best parameter for triplet intraframe coding. */
@@ -788,15 +788,15 @@ static void determine_best_pos_coding(int *quant, int *quant_inter, int *quant_i
       current_code_size=natoms*3*(nframes-1);
       current_coding_parameter=0;
       if (!determine_best_coding_triple(coder,quant_intra+natoms*3,&current_code_size,
-					&current_coding_parameter,natoms))
-	{
-	  if (current_code_size<best_code_size)
-	    {
-	      best_coding=current_coding;
-	      best_coding_parameter=current_coding_parameter;
-	      best_code_size=current_code_size;
-	    }
-	}
+                                        &current_coding_parameter,natoms))
+        {
+          if (current_code_size<best_code_size)
+            {
+              best_coding=current_coding;
+              best_coding_parameter=current_coding_parameter;
+              best_code_size=current_code_size;
+            }
+        }
       Ptngc_coder_deinit(coder);
 
       /* Determine best parameter for triplet one-to-one coding. */
@@ -805,99 +805,99 @@ static void determine_best_pos_coding(int *quant, int *quant_inter, int *quant_i
       current_code_size=natoms*3*(nframes-1);
       current_coding_parameter=0;
       if (!determine_best_coding_triple(coder,quant+natoms*3,&current_code_size,
-					&current_coding_parameter,natoms))
-	{
-	  if (current_code_size<best_code_size)
-	    {
-	      best_coding=current_coding;
-	      best_coding_parameter=current_coding_parameter;
-	      best_code_size=current_code_size;
-	    }
-	}
+                                        &current_coding_parameter,natoms))
+        {
+          if (current_code_size<best_code_size)
+            {
+              best_coding=current_coding;
+              best_coding_parameter=current_coding_parameter;
+              best_code_size=current_code_size;
+            }
+        }
       Ptngc_coder_deinit(coder);
 
       /* Test BWLZH inter */
       if (speed>=4)
-	{
-	  current_coding=TNG_COMPRESS_ALGO_POS_BWLZH_INTER;
-	  current_coding_parameter=0;
-	  compress_quantized_pos(quant,quant_inter,quant_intra,natoms,nframes,speed,
-				 TNG_COMPRESS_ALGO_POS_XTC2,0,
-				 current_coding,current_coding_parameter,
-				 prec_hi,prec_lo,&current_code_size,NULL);
-	  current_code_size-=initial_code_size; /* Correct for the use of XTC2 for the first frame. */
-	  if (current_code_size<best_code_size)
-	    {
-	      best_coding=current_coding;
-	      best_coding_parameter=current_coding_parameter;
-	      best_code_size=current_code_size;
-	    }
-	}
+        {
+          current_coding=TNG_COMPRESS_ALGO_POS_BWLZH_INTER;
+          current_coding_parameter=0;
+          compress_quantized_pos(quant,quant_inter,quant_intra,natoms,nframes,speed,
+                                 TNG_COMPRESS_ALGO_POS_XTC2,0,
+                                 current_coding,current_coding_parameter,
+                                 prec_hi,prec_lo,&current_code_size,NULL);
+          current_code_size-=initial_code_size; /* Correct for the use of XTC2 for the first frame. */
+          if (current_code_size<best_code_size)
+            {
+              best_coding=current_coding;
+              best_coding_parameter=current_coding_parameter;
+              best_code_size=current_code_size;
+            }
+        }
 
       /* Test BWLZH intra */
       if (speed>=6)
-	{
-	  current_coding=TNG_COMPRESS_ALGO_POS_BWLZH_INTRA;
-	  current_coding_parameter=0;
-	  compress_quantized_pos(quant,quant_inter,quant_intra,natoms,nframes,speed,
-				 TNG_COMPRESS_ALGO_POS_XTC2,0,
-				 current_coding,current_coding_parameter,
-				 prec_hi,prec_lo,&current_code_size,NULL);
-	  current_code_size-=initial_code_size; /* Correct for the use of XTC2 for the first frame. */
-	  if (current_code_size<best_code_size)
-	    {
-	      best_coding=current_coding;
-	      best_coding_parameter=current_coding_parameter;
-	    }
-	}
+        {
+          current_coding=TNG_COMPRESS_ALGO_POS_BWLZH_INTRA;
+          current_coding_parameter=0;
+          compress_quantized_pos(quant,quant_inter,quant_intra,natoms,nframes,speed,
+                                 TNG_COMPRESS_ALGO_POS_XTC2,0,
+                                 current_coding,current_coding_parameter,
+                                 prec_hi,prec_lo,&current_code_size,NULL);
+          current_code_size-=initial_code_size; /* Correct for the use of XTC2 for the first frame. */
+          if (current_code_size<best_code_size)
+            {
+              best_coding=current_coding;
+              best_coding_parameter=current_coding_parameter;
+            }
+        }
       *coding=best_coding;
       *coding_parameter=best_coding_parameter;
     }
   else if (*coding_parameter==-1)
     {
       if ((*coding==TNG_COMPRESS_ALGO_POS_XTC2) ||
-	  (*coding==TNG_COMPRESS_ALGO_POS_XTC3) ||
-	  (*coding==TNG_COMPRESS_ALGO_POS_BWLZH_INTER) ||
-	  (*coding==TNG_COMPRESS_ALGO_POS_BWLZH_INTRA))
-	*coding_parameter=0;
+          (*coding==TNG_COMPRESS_ALGO_POS_XTC3) ||
+          (*coding==TNG_COMPRESS_ALGO_POS_BWLZH_INTER) ||
+          (*coding==TNG_COMPRESS_ALGO_POS_BWLZH_INTRA))
+        *coding_parameter=0;
       else if (*coding==TNG_COMPRESS_ALGO_POS_STOPBIT_INTER)
-	{
-	  struct coder *coder=Ptngc_coder_init();
-	  int current_code_size=natoms*3*(nframes-1);
-	  determine_best_coding_stop_bits(coder,quant_inter+natoms*3,&current_code_size,
-					  coding_parameter,natoms);
-	  Ptngc_coder_deinit(coder);
-	}
+        {
+          struct coder *coder=Ptngc_coder_init();
+          int current_code_size=natoms*3*(nframes-1);
+          determine_best_coding_stop_bits(coder,quant_inter+natoms*3,&current_code_size,
+                                          coding_parameter,natoms);
+          Ptngc_coder_deinit(coder);
+        }
       else if (*coding==TNG_COMPRESS_ALGO_POS_TRIPLET_INTER)
-	{
-	  struct coder *coder=Ptngc_coder_init();
-	  int current_code_size=natoms*3*(nframes-1);
-	  determine_best_coding_triple(coder,quant_inter+natoms*3,&current_code_size,
-				       coding_parameter,natoms);
-	  Ptngc_coder_deinit(coder);
-	}
+        {
+          struct coder *coder=Ptngc_coder_init();
+          int current_code_size=natoms*3*(nframes-1);
+          determine_best_coding_triple(coder,quant_inter+natoms*3,&current_code_size,
+                                       coding_parameter,natoms);
+          Ptngc_coder_deinit(coder);
+        }
       else if (*coding==TNG_COMPRESS_ALGO_POS_TRIPLET_INTRA)
-	{
-	  struct coder *coder=Ptngc_coder_init();
-	  int current_code_size=natoms*3*(nframes-1);
-	  determine_best_coding_triple(coder,quant_intra+natoms*3,&current_code_size,
-				       coding_parameter,natoms);
-	  Ptngc_coder_deinit(coder);
-	}
+        {
+          struct coder *coder=Ptngc_coder_init();
+          int current_code_size=natoms*3*(nframes-1);
+          determine_best_coding_triple(coder,quant_intra+natoms*3,&current_code_size,
+                                       coding_parameter,natoms);
+          Ptngc_coder_deinit(coder);
+        }
       else if (*coding==TNG_COMPRESS_ALGO_POS_TRIPLET_ONETOONE)
-	{
-	  struct coder *coder=Ptngc_coder_init();
-	  int current_code_size=natoms*3*(nframes-1);
-	  determine_best_coding_triple(coder,quant+natoms*3,&current_code_size,
-				       coding_parameter,natoms);
-	  Ptngc_coder_deinit(coder);
-	}
+        {
+          struct coder *coder=Ptngc_coder_init();
+          int current_code_size=natoms*3*(nframes-1);
+          determine_best_coding_triple(coder,quant+natoms*3,&current_code_size,
+                                       coding_parameter,natoms);
+          Ptngc_coder_deinit(coder);
+        }
     }
 }
 
 static void determine_best_vel_initial_coding(int *quant, int natoms, int speed,
-					      fix_t prec_hi, fix_t prec_lo,
-					      int *initial_coding, int *initial_coding_parameter)
+                                              fix_t prec_hi, fix_t prec_lo,
+                                              int *initial_coding, int *initial_coding_parameter)
 {
   if (*initial_coding==-1)
     {
@@ -915,12 +915,12 @@ static void determine_best_vel_initial_coding(int *quant, int natoms, int speed,
       current_coding_parameter=0;
       coder=Ptngc_coder_init();
       if (!determine_best_coding_stop_bits(coder,quant,&current_code_size,
-					   &current_coding_parameter,natoms))
-	{
-	  best_coding=current_coding;
-	  best_coding_parameter=current_coding_parameter;
-	  best_code_size=current_code_size;
-	}
+                                           &current_coding_parameter,natoms))
+        {
+          best_coding=current_coding;
+          best_coding_parameter=current_coding_parameter;
+          best_code_size=current_code_size;
+        }
       Ptngc_coder_deinit(coder);
 
       /* Determine best parameter for triplet one-to-one. */
@@ -929,58 +929,58 @@ static void determine_best_vel_initial_coding(int *quant, int natoms, int speed,
       current_code_size=natoms*3;
       current_coding_parameter=0;
       if (!determine_best_coding_triple(coder,quant,&current_code_size,&current_coding_parameter,natoms))
-	{
-	  if ((best_coding==-1) || (current_code_size<best_code_size))
-	    {
-	      best_coding=current_coding;
-	      best_coding_parameter=current_coding_parameter;
-	      best_code_size=current_code_size;
-	    }
-	}
+        {
+          if ((best_coding==-1) || (current_code_size<best_code_size))
+            {
+              best_coding=current_coding;
+              best_coding_parameter=current_coding_parameter;
+              best_code_size=current_code_size;
+            }
+        }
       Ptngc_coder_deinit(coder);
 
       /* Test BWLZH one-to-one */
       if (speed>=4)
-	{
-	  current_coding=TNG_COMPRESS_ALGO_VEL_BWLZH_ONETOONE;
-	  current_coding_parameter=0;
-	  compress_quantized_vel(quant,NULL,natoms,1,speed,
-				 current_coding,current_coding_parameter,
-				 0,0,prec_hi,prec_lo,&current_code_size,NULL);
-	  if ((best_coding==-1) || (current_code_size<best_code_size))
-	    {
-	      best_coding=current_coding;
-	      best_coding_parameter=current_coding_parameter;
-	    }
-	}
+        {
+          current_coding=TNG_COMPRESS_ALGO_VEL_BWLZH_ONETOONE;
+          current_coding_parameter=0;
+          compress_quantized_vel(quant,NULL,natoms,1,speed,
+                                 current_coding,current_coding_parameter,
+                                 0,0,prec_hi,prec_lo,&current_code_size,NULL);
+          if ((best_coding==-1) || (current_code_size<best_code_size))
+            {
+              best_coding=current_coding;
+              best_coding_parameter=current_coding_parameter;
+            }
+        }
       *initial_coding=best_coding;
       *initial_coding_parameter=best_coding_parameter;
     }
   else if (*initial_coding_parameter==-1)
     {
       if (*initial_coding==TNG_COMPRESS_ALGO_VEL_BWLZH_ONETOONE)
-	*initial_coding_parameter=0;
+        *initial_coding_parameter=0;
       else if (*initial_coding==TNG_COMPRESS_ALGO_VEL_STOPBIT_ONETOONE)
-	{
-	  struct coder *coder=Ptngc_coder_init();
-	  int current_code_size=natoms*3;
-	  determine_best_coding_stop_bits(coder,quant,&current_code_size,
-					  initial_coding_parameter,natoms);
-	  Ptngc_coder_deinit(coder);
-	}
+        {
+          struct coder *coder=Ptngc_coder_init();
+          int current_code_size=natoms*3;
+          determine_best_coding_stop_bits(coder,quant,&current_code_size,
+                                          initial_coding_parameter,natoms);
+          Ptngc_coder_deinit(coder);
+        }
       else if (*initial_coding==TNG_COMPRESS_ALGO_VEL_TRIPLET_ONETOONE)
-	{
-	  struct coder *coder=Ptngc_coder_init();
-	  int current_code_size=natoms*3;
-	  determine_best_coding_triple(coder,quant,&current_code_size,initial_coding_parameter,natoms);
-	  Ptngc_coder_deinit(coder);
-	}
+        {
+          struct coder *coder=Ptngc_coder_init();
+          int current_code_size=natoms*3;
+          determine_best_coding_triple(coder,quant,&current_code_size,initial_coding_parameter,natoms);
+          Ptngc_coder_deinit(coder);
+        }
     }
 }
 
 static void determine_best_vel_coding(int *quant, int *quant_inter, int natoms, int nframes, int speed,
-				      fix_t prec_hi, fix_t prec_lo,
-				      int *coding, int *coding_parameter)
+                                      fix_t prec_hi, fix_t prec_lo,
+                                      int *coding, int *coding_parameter)
 {
   if (*coding==-1)
     {
@@ -996,8 +996,8 @@ static void determine_best_vel_coding(int *quant, int *quant_inter, int natoms,
       struct coder *coder;
       /* Use stopbits one-to-one coding for the initial coding. */
       compress_quantized_vel(quant,NULL,natoms,1,speed,
-			     TNG_COMPRESS_ALGO_VEL_STOPBIT_ONETOONE,initial_numbits,
-			     0,0,prec_hi,prec_lo,&initial_code_size,NULL);
+                             TNG_COMPRESS_ALGO_VEL_STOPBIT_ONETOONE,initial_numbits,
+                             0,0,prec_hi,prec_lo,&initial_code_size,NULL);
 
       /* Test stopbit one-to-one */
       current_coding=TNG_COMPRESS_ALGO_VEL_STOPBIT_ONETOONE;
@@ -1005,7 +1005,7 @@ static void determine_best_vel_coding(int *quant, int *quant_inter, int natoms,
       current_coding_parameter=0;
       coder=Ptngc_coder_init();
       determine_best_coding_stop_bits(coder,quant+natoms*3,&current_code_size,
-				      &current_coding_parameter,natoms);
+                                      &current_coding_parameter,natoms);
       Ptngc_coder_deinit(coder);
       best_coding=current_coding;
       best_code_size=current_code_size;
@@ -1017,15 +1017,15 @@ static void determine_best_vel_coding(int *quant, int *quant_inter, int natoms,
       current_coding_parameter=0;
       coder=Ptngc_coder_init();
       if (!determine_best_coding_triple(coder,quant_inter+natoms*3,&current_code_size,
-					&current_coding_parameter,natoms))
-	{
-	  if (current_code_size<best_code_size)
-	    {
-	      best_coding=current_coding;
-	      best_code_size=current_code_size;
-	      best_coding_parameter=current_coding_parameter;
-	    }
-	}
+                                        &current_coding_parameter,natoms))
+        {
+          if (current_code_size<best_code_size)
+            {
+              best_coding=current_coding;
+              best_code_size=current_code_size;
+              best_coding_parameter=current_coding_parameter;
+            }
+        }
       Ptngc_coder_deinit(coder);
 
       /* Test triplet one-to-one */
@@ -1034,15 +1034,15 @@ static void determine_best_vel_coding(int *quant, int *quant_inter, int natoms,
       current_coding_parameter=0;
       coder=Ptngc_coder_init();
       if (!determine_best_coding_triple(coder,quant+natoms*3,&current_code_size,
-					&current_coding_parameter,natoms))
-	{
-	  if (current_code_size<best_code_size)
-	    {
-	      best_coding=current_coding;
-	      best_code_size=current_code_size;
-	      best_coding_parameter=current_coding_parameter;
-	    }
-	}
+                                        &current_coding_parameter,natoms))
+        {
+          if (current_code_size<best_code_size)
+            {
+              best_coding=current_coding;
+              best_code_size=current_code_size;
+              best_coding_parameter=current_coding_parameter;
+            }
+        }
       Ptngc_coder_deinit(coder);
 
       /* Test stopbit interframe */
@@ -1051,99 +1051,99 @@ static void determine_best_vel_coding(int *quant, int *quant_inter, int natoms,
       current_coding_parameter=0;
       coder=Ptngc_coder_init();
       if (!determine_best_coding_stop_bits(coder,quant_inter+natoms*3,&current_code_size,
-					   &current_coding_parameter,natoms))
-	{
-	  if (current_code_size<best_code_size)
-	    {
-	      best_coding=current_coding;
-	      best_code_size=current_code_size;
-	      best_coding_parameter=current_coding_parameter;
-	    }
-	}
+                                           &current_coding_parameter,natoms))
+        {
+          if (current_code_size<best_code_size)
+            {
+              best_coding=current_coding;
+              best_code_size=current_code_size;
+              best_coding_parameter=current_coding_parameter;
+            }
+        }
       Ptngc_coder_deinit(coder);
 
       if (speed>=4)
-	{
-	  /* Test BWLZH inter */
-	  current_coding=TNG_COMPRESS_ALGO_VEL_BWLZH_INTER;
-	  current_coding_parameter=0;
-	  compress_quantized_vel(quant,quant_inter,natoms,nframes,speed,
-				 TNG_COMPRESS_ALGO_VEL_STOPBIT_ONETOONE,initial_numbits,
-				 current_coding,current_coding_parameter,
-				 prec_hi,prec_lo,&current_code_size,NULL);
-	  current_code_size-=initial_code_size; /* Correct for the initial frame */
-	  if (current_code_size<best_code_size)
-	    {
-	      best_coding=current_coding;
-	      best_code_size=current_code_size;
-	      best_coding_parameter=current_coding_parameter;
-	    }
-
-	  /* Test BWLZH one-to-one */
-	  current_coding=TNG_COMPRESS_ALGO_VEL_BWLZH_ONETOONE;
-	  current_coding_parameter=0;
-	  compress_quantized_vel(quant,quant_inter,natoms,nframes,speed,
-				 TNG_COMPRESS_ALGO_VEL_STOPBIT_ONETOONE,initial_numbits,
-				 current_coding,current_coding_parameter,
-				 prec_hi,prec_lo,&current_code_size,NULL);
-	  current_code_size-=initial_code_size; /* Correct for the initial frame */
-	  if (current_code_size<best_code_size)
-	    {
-	      best_coding=current_coding;
-	      best_coding_parameter=current_coding_parameter;
-	    }
-	}
+        {
+          /* Test BWLZH inter */
+          current_coding=TNG_COMPRESS_ALGO_VEL_BWLZH_INTER;
+          current_coding_parameter=0;
+          compress_quantized_vel(quant,quant_inter,natoms,nframes,speed,
+                                 TNG_COMPRESS_ALGO_VEL_STOPBIT_ONETOONE,initial_numbits,
+                                 current_coding,current_coding_parameter,
+                                 prec_hi,prec_lo,&current_code_size,NULL);
+          current_code_size-=initial_code_size; /* Correct for the initial frame */
+          if (current_code_size<best_code_size)
+            {
+              best_coding=current_coding;
+              best_code_size=current_code_size;
+              best_coding_parameter=current_coding_parameter;
+            }
+
+          /* Test BWLZH one-to-one */
+          current_coding=TNG_COMPRESS_ALGO_VEL_BWLZH_ONETOONE;
+          current_coding_parameter=0;
+          compress_quantized_vel(quant,quant_inter,natoms,nframes,speed,
+                                 TNG_COMPRESS_ALGO_VEL_STOPBIT_ONETOONE,initial_numbits,
+                                 current_coding,current_coding_parameter,
+                                 prec_hi,prec_lo,&current_code_size,NULL);
+          current_code_size-=initial_code_size; /* Correct for the initial frame */
+          if (current_code_size<best_code_size)
+            {
+              best_coding=current_coding;
+              best_coding_parameter=current_coding_parameter;
+            }
+        }
       *coding=best_coding;
       *coding_parameter=best_coding_parameter;
     }
   else if (*coding_parameter==-1)
     {
       if ((*coding==TNG_COMPRESS_ALGO_VEL_BWLZH_INTER) ||
-	  (*coding==TNG_COMPRESS_ALGO_VEL_BWLZH_ONETOONE))
-	*coding_parameter=0;
+          (*coding==TNG_COMPRESS_ALGO_VEL_BWLZH_ONETOONE))
+        *coding_parameter=0;
       else if (*coding==TNG_COMPRESS_ALGO_VEL_STOPBIT_ONETOONE)
-	{
-	  struct coder *coder=Ptngc_coder_init();
-	  int current_code_size=natoms*3*(nframes-1);
-	  determine_best_coding_stop_bits(coder,quant+natoms*3,&current_code_size,
-					  coding_parameter,natoms);
-	  Ptngc_coder_deinit(coder);
-	}
+        {
+          struct coder *coder=Ptngc_coder_init();
+          int current_code_size=natoms*3*(nframes-1);
+          determine_best_coding_stop_bits(coder,quant+natoms*3,&current_code_size,
+                                          coding_parameter,natoms);
+          Ptngc_coder_deinit(coder);
+        }
       else if (*coding==TNG_COMPRESS_ALGO_VEL_TRIPLET_INTER)
-	{
-	  struct coder *coder=Ptngc_coder_init();
-	  int current_code_size=natoms*3*(nframes-1);
-	  determine_best_coding_triple(coder,quant_inter+natoms*3,&current_code_size,
-				       coding_parameter,natoms);
-	  Ptngc_coder_deinit(coder);
-	}
+        {
+          struct coder *coder=Ptngc_coder_init();
+          int current_code_size=natoms*3*(nframes-1);
+          determine_best_coding_triple(coder,quant_inter+natoms*3,&current_code_size,
+                                       coding_parameter,natoms);
+          Ptngc_coder_deinit(coder);
+        }
       else if (*coding==TNG_COMPRESS_ALGO_VEL_TRIPLET_ONETOONE)
-	{
-	  struct coder *coder=Ptngc_coder_init();
-	  int current_code_size=natoms*3*(nframes-1);
-	  determine_best_coding_triple(coder,quant+natoms*3,&current_code_size,
-				       coding_parameter,natoms);
-	  Ptngc_coder_deinit(coder);
-	}
+        {
+          struct coder *coder=Ptngc_coder_init();
+          int current_code_size=natoms*3*(nframes-1);
+          determine_best_coding_triple(coder,quant+natoms*3,&current_code_size,
+                                       coding_parameter,natoms);
+          Ptngc_coder_deinit(coder);
+        }
       else if (*coding==TNG_COMPRESS_ALGO_VEL_STOPBIT_INTER)
-	{
-	  struct coder *coder=Ptngc_coder_init();
-	  int current_code_size=natoms*3*(nframes-1);
-	  determine_best_coding_stop_bits(coder,quant_inter+natoms*3,&current_code_size,
-					  coding_parameter,natoms);
-	  Ptngc_coder_deinit(coder);
-	}
+        {
+          struct coder *coder=Ptngc_coder_init();
+          int current_code_size=natoms*3*(nframes-1);
+          determine_best_coding_stop_bits(coder,quant_inter+natoms*3,&current_code_size,
+                                          coding_parameter,natoms);
+          Ptngc_coder_deinit(coder);
+        }
     }
 }
 
 char DECLSPECDLLEXPORT *tng_compress_pos_int(int *pos, int natoms, int nframes,
-					     unsigned long prec_hi, unsigned long prec_lo,
-					     int speed,int *algo,
-					     int *nitems)
+                                             unsigned long prec_hi, unsigned long prec_lo,
+                                             int speed,int *algo,
+                                             int *nitems)
 {
   char *data=malloc(natoms*nframes*14+11*4); /* 12 bytes are required to store 4 32 bit integers
-					       This is 17% extra. The final 11*4 is to store information
-					       needed for decompression. */
+                                               This is 17% extra. The final 11*4 is to store information
+                                               needed for decompression. */
   int *quant=pos; /* Already quantized positions. */
   int *quant_intra=malloc(natoms*nframes*3*sizeof *quant_intra);
   int *quant_inter=malloc(natoms*nframes*3*sizeof *quant_inter);
@@ -1170,12 +1170,12 @@ char DECLSPECDLLEXPORT *tng_compress_pos_int(int *pos, int natoms, int nframes,
     {
       initial_coding_parameter=-1;
       determine_best_pos_initial_coding(quant,quant_intra,natoms,speed,prec_hi,prec_lo,
-					&initial_coding,&initial_coding_parameter);
+                                        &initial_coding,&initial_coding_parameter);
     }
   else if (initial_coding_parameter==-1)
     {
       determine_best_pos_initial_coding(quant,quant_intra,natoms,speed,prec_hi,prec_lo,
-					&initial_coding,&initial_coding_parameter);
+                                        &initial_coding,&initial_coding_parameter);
     }
 
   if (nframes==1)
@@ -1187,22 +1187,22 @@ char DECLSPECDLLEXPORT *tng_compress_pos_int(int *pos, int natoms, int nframes,
   if (nframes>1)
     {
       if (coding==-1)
-	{
-	  coding_parameter=-1;
-	  determine_best_pos_coding(quant,quant_inter,quant_intra,natoms,nframes,speed,prec_hi,prec_lo,
-				    &coding,&coding_parameter);
-	}
+        {
+          coding_parameter=-1;
+          determine_best_pos_coding(quant,quant_inter,quant_intra,natoms,nframes,speed,prec_hi,prec_lo,
+                                    &coding,&coding_parameter);
+        }
       else if (coding_parameter==-1)
-	{
-	  determine_best_pos_coding(quant,quant_inter,quant_intra,natoms,nframes,speed,prec_hi,prec_lo,
-				    &coding,&coding_parameter);
-	}
+        {
+          determine_best_pos_coding(quant,quant_inter,quant_intra,natoms,nframes,speed,prec_hi,prec_lo,
+                                    &coding,&coding_parameter);
+        }
     }
 
   compress_quantized_pos(quant,quant_inter,quant_intra,natoms,nframes,speed,
-			 initial_coding,initial_coding_parameter,
-			 coding,coding_parameter,
-			 prec_hi,prec_lo,nitems,data);
+                         initial_coding,initial_coding_parameter,
+                         coding,coding_parameter,
+                         prec_hi,prec_lo,nitems,data);
   free(quant_inter);
   free(quant_intra);
   if (algo[0]==-1)
@@ -1217,9 +1217,9 @@ char DECLSPECDLLEXPORT *tng_compress_pos_int(int *pos, int natoms, int nframes,
 }
 
 char DECLSPECDLLEXPORT *tng_compress_pos(double *pos, int natoms, int nframes,
-					 double desired_precision,
-					 int speed,int *algo,
-					 int *nitems)
+                                         double desired_precision,
+                                         int speed,int *algo,
+                                         int *nitems)
 {
   int *quant=malloc(natoms*nframes*3*sizeof *quant);
   char *data;
@@ -1235,9 +1235,9 @@ char DECLSPECDLLEXPORT *tng_compress_pos(double *pos, int natoms, int nframes,
 }
 
 char DECLSPECDLLEXPORT *tng_compress_pos_float(float *pos, int natoms, int nframes,
-					       float desired_precision,
-					       int speed,int *algo,
-					       int *nitems)
+                                               float desired_precision,
+                                               int speed,int *algo,
+                                               int *nitems)
 {
   int *quant=malloc(natoms*nframes*3*sizeof *quant);
   char *data;
@@ -1253,10 +1253,10 @@ char DECLSPECDLLEXPORT *tng_compress_pos_float(float *pos, int natoms, int nfram
 }
 
 char DECLSPECDLLEXPORT *tng_compress_pos_find_algo(double *pos, int natoms, int nframes,
-						   double desired_precision,
-						   int speed,
-						   int *algo,
-						   int *nitems)
+                                                   double desired_precision,
+                                                   int speed,
+                                                   int *algo,
+                                                   int *nitems)
 {
   algo[0]=-1;
   algo[1]=-1;
@@ -1266,10 +1266,10 @@ char DECLSPECDLLEXPORT *tng_compress_pos_find_algo(double *pos, int natoms, int
 }
 
 char DECLSPECDLLEXPORT *tng_compress_pos_float_find_algo(float *pos, int natoms, int nframes,
-							 float desired_precision,
-							 int speed,
-							 int *algo,
-							 int *nitems)
+                                                         float desired_precision,
+                                                         int speed,
+                                                         int *algo,
+                                                         int *nitems)
 {
   algo[0]=-1;
   algo[1]=-1;
@@ -1279,9 +1279,9 @@ char DECLSPECDLLEXPORT *tng_compress_pos_float_find_algo(float *pos, int natoms,
 }
 
 char DECLSPECDLLEXPORT *tng_compress_pos_int_find_algo(int *pos, int natoms, int nframes,
-						       unsigned long prec_hi, unsigned long prec_lo,
-						       int speed,int *algo,
-						       int *nitems)
+                                                       unsigned long prec_hi, unsigned long prec_lo,
+                                                       int speed,int *algo,
+                                                       int *nitems)
 {
   algo[0]=-1;
   algo[1]=-1;
@@ -1303,13 +1303,13 @@ int DECLSPECDLLEXPORT tng_compress_nalgo(void)
 }
 
 char DECLSPECDLLEXPORT *tng_compress_vel_int(int *vel, int natoms, int nframes,
-					     unsigned long prec_hi, unsigned long prec_lo,
-					     int speed, int *algo,
-					     int *nitems)
+                                             unsigned long prec_hi, unsigned long prec_lo,
+                                             int speed, int *algo,
+                                             int *nitems)
 {
   char *data=malloc(natoms*nframes*14+11*4); /* 12 bytes are required to store 4 32 bit integers
-					       This is 17% extra. The final 11*4 is to store information
-					       needed for decompression. */
+                                               This is 17% extra. The final 11*4 is to store information
+                                               needed for decompression. */
   int *quant=vel;
   int *quant_inter=malloc(natoms*nframes*3*sizeof *quant_inter);
 
@@ -1334,12 +1334,12 @@ char DECLSPECDLLEXPORT *tng_compress_vel_int(int *vel, int natoms, int nframes,
     {
       initial_coding_parameter=-1;
       determine_best_vel_initial_coding(quant,natoms,speed,prec_hi,prec_lo,
-					&initial_coding,&initial_coding_parameter);
+                                        &initial_coding,&initial_coding_parameter);
     }
   else if (initial_coding_parameter==-1)
     {
       determine_best_vel_initial_coding(quant,natoms,speed,prec_hi,prec_lo,
-					&initial_coding,&initial_coding_parameter);
+                                        &initial_coding,&initial_coding_parameter);
     }
 
   if (nframes==1)
@@ -1351,22 +1351,22 @@ char DECLSPECDLLEXPORT *tng_compress_vel_int(int *vel, int natoms, int nframes,
   if (nframes>1)
     {
       if (coding==-1)
-	{
-	  coding_parameter=-1;
-	  determine_best_vel_coding(quant,quant_inter,natoms,nframes,speed,prec_hi,prec_lo,
-				    &coding,&coding_parameter);
-	}
+        {
+          coding_parameter=-1;
+          determine_best_vel_coding(quant,quant_inter,natoms,nframes,speed,prec_hi,prec_lo,
+                                    &coding,&coding_parameter);
+        }
       else if (coding_parameter==-1)
-	{
-	  determine_best_vel_coding(quant,quant_inter,natoms,nframes,speed,prec_hi,prec_lo,
-				    &coding,&coding_parameter);
-	}
+        {
+          determine_best_vel_coding(quant,quant_inter,natoms,nframes,speed,prec_hi,prec_lo,
+                                    &coding,&coding_parameter);
+        }
     }
 
   compress_quantized_vel(quant,quant_inter,natoms,nframes,speed,
-			 initial_coding,initial_coding_parameter,
-			 coding,coding_parameter,
-			 prec_hi,prec_lo,nitems,data);
+                         initial_coding,initial_coding_parameter,
+                         coding,coding_parameter,
+                         prec_hi,prec_lo,nitems,data);
   free(quant_inter);
   if (algo[0]==-1)
     algo[0]=initial_coding;
@@ -1380,9 +1380,9 @@ char DECLSPECDLLEXPORT *tng_compress_vel_int(int *vel, int natoms, int nframes,
 }
 
 char DECLSPECDLLEXPORT *tng_compress_vel(double *vel, int natoms, int nframes,
-					 double desired_precision,
-					 int speed, int *algo,
-					 int *nitems)
+                                         double desired_precision,
+                                         int speed, int *algo,
+                                         int *nitems)
 {
   int *quant=malloc(natoms*nframes*3*sizeof *quant);
   char *data;
@@ -1397,9 +1397,9 @@ char DECLSPECDLLEXPORT *tng_compress_vel(double *vel, int natoms, int nframes,
 }
 
 char DECLSPECDLLEXPORT *tng_compress_vel_float(float *vel, int natoms, int nframes,
-					       float desired_precision,
-					       int speed, int *algo,
-					       int *nitems)
+                                               float desired_precision,
+                                               int speed, int *algo,
+                                               int *nitems)
 {
   int *quant=malloc(natoms*nframes*3*sizeof *quant);
   char *data;
@@ -1414,10 +1414,10 @@ char DECLSPECDLLEXPORT *tng_compress_vel_float(float *vel, int natoms, int nfram
 }
 
 char DECLSPECDLLEXPORT *tng_compress_vel_find_algo(double *vel, int natoms, int nframes,
-						   double desired_precision,
-						   int speed,
-						   int *algo,
-						   int *nitems)
+                                                   double desired_precision,
+                                                   int speed,
+                                                   int *algo,
+                                                   int *nitems)
 {
   algo[0]=-1;
   algo[1]=-1;
@@ -1427,10 +1427,10 @@ char DECLSPECDLLEXPORT *tng_compress_vel_find_algo(double *vel, int natoms, int
 }
 
 char DECLSPECDLLEXPORT *tng_compress_vel_float_find_algo(float *vel, int natoms, int nframes,
-							 float desired_precision,
-							 int speed,
-							 int *algo,
-							 int *nitems)
+                                                         float desired_precision,
+                                                         int speed,
+                                                         int *algo,
+                                                         int *nitems)
 {
   algo[0]=-1;
   algo[1]=-1;
@@ -1440,10 +1440,10 @@ char DECLSPECDLLEXPORT *tng_compress_vel_float_find_algo(float *vel, int natoms,
 }
 
 char DECLSPECDLLEXPORT *tng_compress_vel_int_find_algo(int *vel, int natoms, int nframes,
-						       unsigned long prec_hi, unsigned long prec_lo,
-						       int speed,
-						       int *algo,
-						       int *nitems)
+                                                       unsigned long prec_hi, unsigned long prec_lo,
+                                                       int speed,
+                                                       int *algo,
+                                                       int *nitems)
 {
   algo[0]=-1;
   algo[1]=-1;
@@ -1453,8 +1453,8 @@ char DECLSPECDLLEXPORT *tng_compress_vel_int_find_algo(int *vel, int natoms, int
 }
 
 int DECLSPECDLLEXPORT tng_compress_inquire(char *data,int *vel, int *natoms,
-					    int *nframes, double *precision,
-					    int *algo)
+                                            int *nframes, double *precision,
+                                            int *algo)
 {
   int bufloc=0;
   fix_t prec_hi, prec_lo;
@@ -1549,7 +1549,7 @@ static int tng_compress_uncompress_pos_gen(char *data,double *posd,float *posf,i
   /* The initial frame */
   coder=Ptngc_coder_init();
   rval=Ptngc_unpack_array(coder,(unsigned char*)data+bufloc,quant,natoms*3,
-			 initial_coding,initial_coding_parameter,natoms);
+                         initial_coding,initial_coding_parameter,natoms);
   Ptngc_coder_deinit(coder);
   if (rval)
     goto error;
@@ -1561,21 +1561,21 @@ static int tng_compress_uncompress_pos_gen(char *data,double *posd,float *posf,i
       (initial_coding==TNG_COMPRESS_ALGO_POS_XTC3))
     {
       if (posd)
-	unquantize(posd,natoms,1,PRECISION(*prec_hi,*prec_lo),quant);
+        unquantize(posd,natoms,1,PRECISION(*prec_hi,*prec_lo),quant);
       else if (posf)
-	unquantize_float(posf,natoms,1,(float)PRECISION(*prec_hi,*prec_lo),quant);
+        unquantize_float(posf,natoms,1,(float)PRECISION(*prec_hi,*prec_lo),quant);
       else if (posi)
-	memcpy(posi,quant,natoms*3*sizeof *posi);
+        memcpy(posi,quant,natoms*3*sizeof *posi);
     }
   else if ((initial_coding==TNG_COMPRESS_ALGO_POS_TRIPLET_INTRA) ||
-	   (initial_coding==TNG_COMPRESS_ALGO_POS_BWLZH_INTRA))
+           (initial_coding==TNG_COMPRESS_ALGO_POS_BWLZH_INTRA))
     {
       if (posd)
-	unquantize_intra_differences(posd,natoms,1,PRECISION(*prec_hi,*prec_lo),quant);
+        unquantize_intra_differences(posd,natoms,1,PRECISION(*prec_hi,*prec_lo),quant);
       else if (posf)
-	unquantize_intra_differences_float(posf,natoms,1,(float)PRECISION(*prec_hi,*prec_lo),quant);
+        unquantize_intra_differences_float(posf,natoms,1,(float)PRECISION(*prec_hi,*prec_lo),quant);
       else if (posi)
-	unquantize_intra_differences_int(posi,natoms,1,quant);
+        unquantize_intra_differences_int(posi,natoms,1,quant);
       unquant_intra_differences_first_frame(quant,natoms);
     }
   /* The remaining frames. */
@@ -1584,45 +1584,45 @@ static int tng_compress_uncompress_pos_gen(char *data,double *posd,float *posf,i
       bufloc+=4;
       coder=Ptngc_coder_init();
       rval=Ptngc_unpack_array(coder,(unsigned char *)data+bufloc,quant+natoms*3,(nframes-1)*natoms*3,
-				  coding,coding_parameter,natoms);
+                                  coding,coding_parameter,natoms);
       Ptngc_coder_deinit(coder);
       if (rval)
-	goto error;
+        goto error;
       if ((coding==TNG_COMPRESS_ALGO_POS_STOPBIT_INTER) ||
-	  (coding==TNG_COMPRESS_ALGO_POS_TRIPLET_INTER) ||
-	  (coding==TNG_COMPRESS_ALGO_POS_BWLZH_INTER))
-	{
-	  /* This requires that the first frame is already in one-to-one format, even if intra-frame
-	     compression was done there. Therefore the unquant_intra_differences_first_frame should be called
-	     before to convert it correctly. */
-	  if (posd)
-	    unquantize_inter_differences(posd,natoms,nframes,PRECISION(*prec_hi,*prec_lo),quant);
-	  else if (posf)
-	    unquantize_inter_differences_float(posf,natoms,nframes,(float)PRECISION(*prec_hi,*prec_lo),quant);
-	  else if (posi)
-	    unquantize_inter_differences_int(posi,natoms,nframes,quant);
-	}
+          (coding==TNG_COMPRESS_ALGO_POS_TRIPLET_INTER) ||
+          (coding==TNG_COMPRESS_ALGO_POS_BWLZH_INTER))
+        {
+          /* This requires that the first frame is already in one-to-one format, even if intra-frame
+             compression was done there. Therefore the unquant_intra_differences_first_frame should be called
+             before to convert it correctly. */
+          if (posd)
+            unquantize_inter_differences(posd,natoms,nframes,PRECISION(*prec_hi,*prec_lo),quant);
+          else if (posf)
+            unquantize_inter_differences_float(posf,natoms,nframes,(float)PRECISION(*prec_hi,*prec_lo),quant);
+          else if (posi)
+            unquantize_inter_differences_int(posi,natoms,nframes,quant);
+        }
       else if ((coding==TNG_COMPRESS_ALGO_POS_XTC2) ||
-	       (coding==TNG_COMPRESS_ALGO_POS_XTC3) ||
-	       (coding==TNG_COMPRESS_ALGO_POS_TRIPLET_ONETOONE))
-	{
-	  if (posd)
-	    unquantize(posd+natoms*3,natoms,nframes-1,PRECISION(*prec_hi,*prec_lo),quant+natoms*3);
-	  else if (posf)
-	    unquantize_float(posf+natoms*3,natoms,nframes-1,(float)PRECISION(*prec_hi,*prec_lo),quant+natoms*3);
-	  else if (posi)
-	    memcpy(posi+natoms*3,quant+natoms*3,natoms*3*(nframes-1)*sizeof *posi);
-	}
+               (coding==TNG_COMPRESS_ALGO_POS_XTC3) ||
+               (coding==TNG_COMPRESS_ALGO_POS_TRIPLET_ONETOONE))
+        {
+          if (posd)
+            unquantize(posd+natoms*3,natoms,nframes-1,PRECISION(*prec_hi,*prec_lo),quant+natoms*3);
+          else if (posf)
+            unquantize_float(posf+natoms*3,natoms,nframes-1,(float)PRECISION(*prec_hi,*prec_lo),quant+natoms*3);
+          else if (posi)
+            memcpy(posi+natoms*3,quant+natoms*3,natoms*3*(nframes-1)*sizeof *posi);
+        }
       else if ((coding==TNG_COMPRESS_ALGO_POS_TRIPLET_INTRA) ||
-	       (coding==TNG_COMPRESS_ALGO_POS_BWLZH_INTRA))
-	{
-	  if (posd)
-	    unquantize_intra_differences(posd+natoms*3,natoms,nframes-1,PRECISION(*prec_hi,*prec_lo),quant+natoms*3);
-	  else if (posf)
-	    unquantize_intra_differences_float(posf+natoms*3,natoms,nframes-1,(float)PRECISION(*prec_hi,*prec_lo),quant+natoms*3);
-	  else if (posi)
-	    unquantize_intra_differences_int(posi+natoms*3,natoms,nframes-1,quant+natoms*3);
-	}
+               (coding==TNG_COMPRESS_ALGO_POS_BWLZH_INTRA))
+        {
+          if (posd)
+            unquantize_intra_differences(posd+natoms*3,natoms,nframes-1,PRECISION(*prec_hi,*prec_lo),quant+natoms*3);
+          else if (posf)
+            unquantize_intra_differences_float(posf+natoms*3,natoms,nframes-1,(float)PRECISION(*prec_hi,*prec_lo),quant+natoms*3);
+          else if (posi)
+            unquantize_intra_differences_int(posi+natoms*3,natoms,nframes-1,quant+natoms*3);
+        }
     }
  error:
   free(quant);
@@ -1696,7 +1696,7 @@ static int tng_compress_uncompress_vel_gen(char *data,double *veld,float *velf,i
   /* The initial frame */
   coder=Ptngc_coder_init();
   rval=Ptngc_unpack_array(coder,(unsigned char*)data+bufloc,quant,natoms*3,
-			 initial_coding,initial_coding_parameter,natoms);
+                         initial_coding,initial_coding_parameter,natoms);
   Ptngc_coder_deinit(coder);
   if (rval)
     goto error;
@@ -1708,11 +1708,11 @@ static int tng_compress_uncompress_vel_gen(char *data,double *veld,float *velf,i
       (initial_coding==TNG_COMPRESS_ALGO_VEL_BWLZH_ONETOONE))
     {
       if (veld)
-	unquantize(veld,natoms,1,PRECISION(*prec_hi,*prec_lo),quant);
+        unquantize(veld,natoms,1,PRECISION(*prec_hi,*prec_lo),quant);
       else if (velf)
-	unquantize_float(velf,natoms,1,(float)PRECISION(*prec_hi,*prec_lo),quant);
+        unquantize_float(velf,natoms,1,(float)PRECISION(*prec_hi,*prec_lo),quant);
       else if (veli)
-	memcpy(veli,quant,natoms*3*sizeof *veli);
+        memcpy(veli,quant,natoms*3*sizeof *veli);
     }
   /* The remaining frames. */
   if (nframes>1)
@@ -1720,35 +1720,35 @@ static int tng_compress_uncompress_vel_gen(char *data,double *veld,float *velf,i
       bufloc+=4;
       coder=Ptngc_coder_init();
       rval=Ptngc_unpack_array(coder,(unsigned char *)data+bufloc,quant+natoms*3,(nframes-1)*natoms*3,
-				  coding,coding_parameter,natoms);
+                                  coding,coding_parameter,natoms);
       Ptngc_coder_deinit(coder);
       if (rval)
-	goto error;
+        goto error;
       /* Inter-frame compression? */
       if ((coding==TNG_COMPRESS_ALGO_VEL_TRIPLET_INTER) ||
-	  (coding==TNG_COMPRESS_ALGO_VEL_STOPBIT_INTER) ||
-	  (coding==TNG_COMPRESS_ALGO_VEL_BWLZH_INTER))
-	{
-	  /* This requires that the first frame is already in one-to-one format. */
-	  if (veld)
-	    unquantize_inter_differences(veld,natoms,nframes,PRECISION(*prec_hi,*prec_lo),quant);
-	  else if (velf)
-	    unquantize_inter_differences_float(velf,natoms,nframes,(float)PRECISION(*prec_hi,*prec_lo),quant);
-	  else if (veli)
-	    unquantize_inter_differences_int(veli,natoms,nframes,quant);
-	}
+          (coding==TNG_COMPRESS_ALGO_VEL_STOPBIT_INTER) ||
+          (coding==TNG_COMPRESS_ALGO_VEL_BWLZH_INTER))
+        {
+          /* This requires that the first frame is already in one-to-one format. */
+          if (veld)
+            unquantize_inter_differences(veld,natoms,nframes,PRECISION(*prec_hi,*prec_lo),quant);
+          else if (velf)
+            unquantize_inter_differences_float(velf,natoms,nframes,(float)PRECISION(*prec_hi,*prec_lo),quant);
+          else if (veli)
+            unquantize_inter_differences_int(veli,natoms,nframes,quant);
+        }
       /* One-to-one compression? */
       else if ((coding==TNG_COMPRESS_ALGO_VEL_STOPBIT_ONETOONE) ||
-	       (coding==TNG_COMPRESS_ALGO_VEL_TRIPLET_ONETOONE) ||
-	       (coding==TNG_COMPRESS_ALGO_VEL_BWLZH_ONETOONE))
-	{
-	  if (veld)
-	    unquantize(veld+natoms*3,natoms,nframes-1,PRECISION(*prec_hi,*prec_lo),quant+natoms*3);
-	  else if (velf)
-	    unquantize_float(velf+natoms*3,natoms,nframes-1,(float)PRECISION(*prec_hi,*prec_lo),quant+natoms*3);
-	  else if (veli)
-	    memcpy(veli+natoms*3,quant+natoms*3,natoms*3*(nframes-1)*sizeof *veli);
-	}
+               (coding==TNG_COMPRESS_ALGO_VEL_TRIPLET_ONETOONE) ||
+               (coding==TNG_COMPRESS_ALGO_VEL_BWLZH_ONETOONE))
+        {
+          if (veld)
+            unquantize(veld+natoms*3,natoms,nframes-1,PRECISION(*prec_hi,*prec_lo),quant+natoms*3);
+          else if (velf)
+            unquantize_float(velf+natoms*3,natoms,nframes-1,(float)PRECISION(*prec_hi,*prec_lo),quant+natoms*3);
+          else if (veli)
+            memcpy(veli+natoms*3,quant+natoms*3,natoms*3*(nframes-1)*sizeof *veli);
+        }
     }
  error:
   free(quant);
@@ -1811,15 +1811,15 @@ int DECLSPECDLLEXPORT tng_compress_uncompress_int(char *data,int *posvel, unsign
 }
 
 void DECLSPECDLLEXPORT tng_compress_int_to_double(int *posvel_int,unsigned long prec_hi, unsigned long prec_lo,
-						  int natoms,int nframes,
-						  double *posvel_double)
+                                                  int natoms,int nframes,
+                                                  double *posvel_double)
 {
   unquantize(posvel_double,natoms,nframes,PRECISION(prec_hi,prec_lo),posvel_int);
 }
 
 void DECLSPECDLLEXPORT tng_compress_int_to_float(int *posvel_int,unsigned long prec_hi, unsigned long prec_lo,
-						 int natoms,int nframes,
-						 float *posvel_float)
+                                                 int natoms,int nframes,
+                                                 float *posvel_float)
 {
   unquantize_float(posvel_float,natoms,nframes,(float)PRECISION(prec_hi,prec_lo),posvel_int);
 }