[svn-r23075] I revised the code and test according to Quincey's review. I also added more test cases.

Tested on koala.

8 files changed, 935 insertions, 97 deletions

diff --git a/hl/src/H5DO.c b/hl/src/H5DO.c
index 5b8041e..9cfd8c1 100644
--- a/hl/src/H5DO.c
+++ b/hl/src/H5DO.c
@@ -34,38 +34,53 @@
  *-------------------------------------------------------------------------
  */
 herr_t
-H5DOwrite_chunk(hid_t dset_id, hid_t dxpl_id, uint32_t filters, hsize_t *offset, 
+H5DOwrite_chunk(hid_t dset_id, hid_t dxpl_id, uint32_t filters, const hsize_t *offset, 
          size_t data_size, const void *buf)
 {
-    htri_t created_dxpl = FALSE;
+    hbool_t created_dxpl = FALSE;
+    herr_t  ret_value = SUCCEED;  /* Return value */
+    
+    if(dset_id < 0) {
+        ret_value = FAIL;
+        goto done;
+    }
 
-    if(dset_id < 0)
-        goto error;
+    if(!buf) {
+        ret_value = FAIL;
+        goto done;
+    }
 
-    if(!buf)
-        goto error;
-    
-    if(!offset)
-        goto error;
+    if(!offset) {
+        ret_value = FAIL;
+        goto done;
+    }
 
-    if(!data_size)
-        goto error;
+    if(!data_size) {
+        ret_value = FAIL;
+        goto done;
+    }
 
     if(H5P_DEFAULT == dxpl_id) {
-	dxpl_id = H5Pcreate(H5P_DATASET_XFER);
+	if((dxpl_id = H5Pcreate(H5P_DATASET_XFER)) < 0) {
+            ret_value = FAIL;
+            goto done;
+        }
+
         created_dxpl = TRUE;
     }
 
-    if(H5DO_write_chunk(dset_id, dxpl_id, filters, offset, data_size, buf) < 0)
-        goto error;
+    if(H5DO_write_chunk(dset_id, dxpl_id, filters, offset, data_size, buf) < 0) {
+        ret_value = FAIL;
+        goto done;
+    }
 
+done:
     if(created_dxpl) {
         if(H5Pclose(dxpl_id) < 0)
-            goto error;
+            ret_value = FAIL;
     }
 
-error:
-    return FAIL;
+    return ret_value;
 }
 
 /*-------------------------------------------------------------------------
@@ -82,30 +97,41 @@ error:
  *-------------------------------------------------------------------------
  */
 herr_t
-H5DO_write_chunk(hid_t dset_id, hid_t dxpl_id, uint32_t filters, hsize_t *offset, 
+H5DO_write_chunk(hid_t dset_id, hid_t dxpl_id, uint32_t filters, const hsize_t *offset, 
          size_t data_size, const void *buf)
 {
-    htri_t do_direct_write = TRUE;
+    hbool_t do_direct_write = TRUE;
+    herr_t  ret_value = SUCCEED;  /* Return value */
 
-    if(H5Pset(dxpl_id, H5D_XFER_DIRECT_CHUNK_WRITE_FLAG_NAME, &do_direct_write) < 0)
-        goto error;
+    if(H5Pset(dxpl_id, H5D_XFER_DIRECT_CHUNK_WRITE_FLAG_NAME, &do_direct_write) < 0) {
+        ret_value = FAIL;
+        goto done;
+    }
 
-    if(H5Pset(dxpl_id, H5D_XFER_DIRECT_CHUNK_WRITE_FILTERS_NAME, &filters) < 0)
-        goto error;
+    if(H5Pset(dxpl_id, H5D_XFER_DIRECT_CHUNK_WRITE_FILTERS_NAME, &filters) < 0) {
+        ret_value = FAIL;
+        goto done;
+    }
 
-    if(H5Pset(dxpl_id, H5D_XFER_DIRECT_CHUNK_WRITE_OFFSET_NAME, &offset) < 0)
-        goto error;
+    if(H5Pset(dxpl_id, H5D_XFER_DIRECT_CHUNK_WRITE_OFFSET_NAME, &offset) < 0) {
+        ret_value = FAIL;
+        goto done;
+    }
 
-    if(H5Pset(dxpl_id, H5D_XFER_DIRECT_CHUNK_WRITE_DATASIZE_NAME, &data_size) < 0)
-        goto error;
+    if(H5Pset(dxpl_id, H5D_XFER_DIRECT_CHUNK_WRITE_DATASIZE_NAME, &data_size) < 0) {
+        ret_value = FAIL;
+        goto done;
+    }
 
-    if(H5Dwrite(dset_id, 0, H5S_ALL, H5S_ALL, dxpl_id, buf) < 0)
-        goto error;
+    if(H5Dwrite(dset_id, 0, H5S_ALL, H5S_ALL, dxpl_id, buf) < 0) {
+        ret_value = FAIL;
+        goto done;
+    }
 
+done:
     do_direct_write = FALSE;
     if(H5Pset(dxpl_id, H5D_XFER_DIRECT_CHUNK_WRITE_FLAG_NAME, &do_direct_write) < 0)
-        goto error;
+        ret_value = FAIL;
 
-error:
-    return FAIL;
+    return ret_value;
 }
diff --git a/hl/src/H5DOprivate.h b/hl/src/H5DOprivate.h
index 8617567..fcea585 100644
--- a/hl/src/H5DOprivate.h
+++ b/hl/src/H5DOprivate.h
@@ -30,7 +30,7 @@
 H5_HLDLL herr_t H5DO_write_chunk(hid_t dset_id, 
 			hid_t dxpl_id, 
 			uint32_t filters, 
-			hsize_t *offset, 
+			const hsize_t *offset, 
          		size_t data_size, 
 			const void *buf);
 
diff --git a/hl/src/H5DOpublic.h b/hl/src/H5DOpublic.h
index b20de56..774709e 100644
--- a/hl/src/H5DOpublic.h
+++ b/hl/src/H5DOpublic.h
@@ -30,7 +30,7 @@ extern "C" {
 H5_HLDLL herr_t H5DOwrite_chunk(hid_t dset_id, 
 			hid_t dxpl_id, 
 			uint32_t filters, 
-			hsize_t *offset, 
+			const hsize_t *offset, 
          		size_t data_size, 
 			const void *buf);
 
diff --git a/hl/test/test_dset_opt.c b/hl/test/test_dset_opt.c
index 35dc73c..ebe28cc 100644
--- a/hl/test/test_dset_opt.c
+++ b/hl/test/test_dset_opt.c
@@ -21,9 +21,14 @@
 #include <zlib.h>
 #include <math.h>
 
-#define FILE_NAME5 "test_dectris.h5"
+#define FILE_NAME "test_dectris.h5"
 
-#define DATASETNAME        "Array"
+#define DATASETNAME1        "direct_write"
+#define DATASETNAME2        "skip_one_filter"
+#define DATASETNAME3        "skip_two_filters"
+#define DATASETNAME4        "data_conv"
+#define DATASETNAME5        "contiguous_dset"
+#define DATASETNAME6        "invalid_argue"
 #define RANK         2
 #define NX     16
 #define NY     16
@@ -32,22 +37,65 @@
 
 #define DEFLATE_SIZE_ADJUST(s) (ceil(((double)(s))*1.001)+12)
 
+/* Temporary filter IDs used for testing */
+#define H5Z_FILTER_BOGUS1	305
+#define H5Z_FILTER_BOGUS2	306
+#define ADD_ON			7
+#define FACTOR			3
+
+/* Local prototypes for filter functions */
+static size_t filter_bogus1(unsigned int flags, size_t cd_nelmts,
+    const unsigned int *cd_values, size_t nbytes, size_t *buf_size, void **buf);
+static size_t filter_bogus2(unsigned int flags, size_t cd_nelmts,
+    const unsigned int *cd_values, size_t nbytes, size_t *buf_size, void **buf);
+
+/* This message derives from H5Z */
+const H5Z_class2_t H5Z_BOGUS1[1] = {{
+    H5Z_CLASS_T_VERS,       /* H5Z_class_t version */
+    H5Z_FILTER_BOGUS1,		/* Filter id number		*/
+    1, 1,               /* Encoding and decoding enabled */
+    "bogus1",			/* Filter name for debugging	*/
+    NULL,                       /* The "can apply" callback     */
+    NULL,                       /* The "set local" callback     */
+    filter_bogus1,		/* The actual filter function	*/
+}};
+
+const H5Z_class2_t H5Z_BOGUS2[1] = {{
+    H5Z_CLASS_T_VERS,       /* H5Z_class_t version */
+    H5Z_FILTER_BOGUS2,		/* Filter id number		*/
+    1, 1,               /* Encoding and decoding enabled */
+    "bogus2",			/* Filter name for debugging	*/
+    NULL,                       /* The "can apply" callback     */
+    NULL,                       /* The "set local" callback     */
+    filter_bogus2,		/* The actual filter function	*/
+}};
+
+/*-------------------------------------------------------------------------
+ * Function:	test_direct_chunk_write
+ *
+ * Purpose:	Test the basic functionality of H5DOwrite_chunk
+ *
+ * Return:	Success:	0
+ *
+ *		Failure:	1
+ *
+ * Programmer:  Raymond Lu	
+ *              30 November 2012
+ *
+ *-------------------------------------------------------------------------
+ */
 static int
-test_direct_chunk_write (void)
+test_direct_chunk_write (hid_t file)
 {
-    char        filename[1024];
-    hid_t       file;                          /* handles */
-    hid_t       fapl;
-    hid_t       dataspace, dataset;
-    hid_t       mem_space;
-    hid_t       cparms, dxpl;
+    hid_t       dataspace = -1, dataset = -1;
+    hid_t       mem_space = -1;
+    hid_t       cparms = -1, dxpl = -1;
     hsize_t     dims[2]  = {NX, NY};        
     hsize_t     maxdims[2] = {H5S_UNLIMITED, H5S_UNLIMITED};
     hsize_t     chunk_dims[2] ={CHUNK_NX, CHUNK_NY};
     herr_t      status;
     int         ret;
     int         data[NX][NY];
-    int         check[NX][NY];
     int         i, j, n;
 
     unsigned    filter_mask = 0;
@@ -68,7 +116,7 @@ test_direct_chunk_write (void)
     hsize_t count[2];  /* Block count */
     hsize_t block[2];  /* Block sizes */
 
-    TESTING("H5DOwrite_chunk");
+    TESTING("basic functionality of H5DOwrite_chunk");
 
     /*
      * Create the data space with unlimited dimensions.
@@ -80,12 +128,6 @@ test_direct_chunk_write (void)
         goto error;
 
     /*
-     * Create a new file. If file exists its contents will be overwritten.
-     */
-    if((file = H5Fcreate(FILE_NAME5, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT)) < 0)
-        goto error;
-
-    /*
      * Modify dataset creation properties, i.e. enable chunking and compression
      */
     if((cparms = H5Pcreate(H5P_DATASET_CREATE)) < 0)
@@ -94,14 +136,14 @@ test_direct_chunk_write (void)
     if((status = H5Pset_chunk( cparms, RANK, chunk_dims)) < 0)
         goto error;
 
-    if((status = H5Pset_deflate( cparms, aggression)) < 0)
+    if((status = H5Pset_deflate( cparms, (unsigned) aggression)) < 0)
         goto error;
 
     /*
      * Create a new dataset within the file using cparms
      * creation properties.
      */
-    if((dataset = H5Dcreate2(file, DATASETNAME, H5T_NATIVE_INT, dataspace, H5P_DEFAULT,
+    if((dataset = H5Dcreate2(file, DATASETNAME1, H5T_NATIVE_INT, dataspace, H5P_DEFAULT,
 			cparms, H5P_DEFAULT)) < 0)
         goto error;
 
@@ -159,17 +201,13 @@ test_direct_chunk_write (void)
     if(outbuf)
         free(outbuf);
 
-    if(H5Dclose(dataset) < 0)
-        goto error;
-
-    if(H5Fclose(file) < 0) 
+    if(H5Fflush(dataset, H5F_SCOPE_LOCAL) < 0) 
         goto error;
 
-    /* Reopen the file and dataset */
-    if((file = H5Fopen(FILE_NAME5, H5F_ACC_RDWR, H5P_DEFAULT)) < 0)
+    if(H5Dclose(dataset) < 0)
         goto error;
 
-    if((dataset = H5Dopen(file, DATASETNAME, H5P_DEFAULT)) < 0)
+    if((dataset = H5Dopen(file, DATASETNAME1, H5P_DEFAULT)) < 0)
         goto error;
 
     /*
@@ -237,17 +275,13 @@ test_direct_chunk_write (void)
     if(outbuf)
         free(outbuf);
 
-    if(H5Dclose(dataset) < 0)
+    if(H5Fflush(dataset, H5F_SCOPE_LOCAL) < 0) 
         goto error;
 
-    if(H5Fclose(file) < 0) 
-        goto error;
-
-    /* Reopen the file and dataset */
-    if((file = H5Fopen(FILE_NAME5, H5F_ACC_RDWR, H5P_DEFAULT)) < 0)
+    if(H5Dclose(dataset) < 0)
         goto error;
 
-    if((dataset = H5Dopen(file, DATASETNAME, H5P_DEFAULT)) < 0)
+    if((dataset = H5Dopen(file, DATASETNAME1, H5P_DEFAULT)) < 0)
         goto error;
 
     /* Read the chunk back */
@@ -274,9 +308,7 @@ test_direct_chunk_write (void)
     H5Sclose(dataspace);
     H5Pclose(cparms);
     H5Pclose(dxpl);
-    H5Fclose(file);
     
-    /* h5_cleanup(FILE_NAME5, fapl); */
     PASSED();
     return 0;
 
@@ -287,7 +319,6 @@ error:
         H5Sclose(dataspace);
         H5Pclose(cparms);
         H5Pclose(dxpl);
-        H5Fclose(file);
     } H5E_END_TRY;
 
     if(outbuf)
@@ -297,15 +328,795 @@ error:
 }
 
 /*-------------------------------------------------------------------------
-* the main program
-*-------------------------------------------------------------------------
-*/
+ * Function:	test_skip_compress_write1
+ *
+ * Purpose:	Test skipping compression filter when it is the only filter
+ *              for the dataset
+ *
+ * Return:	Success:	0
+ *
+ *		Failure:	1
+ *
+ * Programmer:  Raymond Lu	
+ *              30 November 2012
+ *
+ *-------------------------------------------------------------------------
+ */
+static int
+test_skip_compress_write1(hid_t file)
+{
+    hid_t       dataspace = -1, dataset = -1;
+    hid_t       mem_space = -1;
+    hid_t       cparms = -1, dxpl = -1;
+    hsize_t     dims[2]  = {NX, NY};        
+    hsize_t     maxdims[2] = {H5S_UNLIMITED, H5S_UNLIMITED};
+    hsize_t     chunk_dims[2] ={CHUNK_NX, CHUNK_NY};
+    herr_t      status;
+    int         i, j, n;
+
+    unsigned    filter_mask = 0;
+    int         direct_buf[CHUNK_NX][CHUNK_NY];
+    int         check_chunk[CHUNK_NX][CHUNK_NY];
+    hsize_t     offset[2] = {0, 0};
+    size_t      buf_size = CHUNK_NX*CHUNK_NY*sizeof(int);
+    int         aggression = 9;     /* Compression aggression setting */
+
+    hsize_t start[2];  /* Start of hyperslab */
+    hsize_t stride[2]; /* Stride of hyperslab */
+    hsize_t count[2];  /* Block count */
+    hsize_t block[2];  /* Block sizes */
+
+    TESTING("skipping compression filter for H5DOwrite_chunk");
+
+    /*
+     * Create the data space with unlimited dimensions.
+     */
+    if((dataspace = H5Screate_simple(RANK, dims, maxdims)) < 0)
+        goto error;
+
+    if((mem_space = H5Screate_simple(RANK, chunk_dims, NULL)) < 0)
+        goto error;
+
+    /*
+     * Modify dataset creation properties, i.e. enable chunking and compression
+     */
+    if((cparms = H5Pcreate(H5P_DATASET_CREATE)) < 0)
+        goto error;
+
+    if((status = H5Pset_chunk( cparms, RANK, chunk_dims)) < 0)
+        goto error;
+
+    if((status = H5Pset_deflate( cparms, (unsigned ) aggression)) < 0)
+        goto error;
+
+    /*
+     * Create a new dataset within the file using cparms
+     * creation properties.
+     */
+    if((dataset = H5Dcreate2(file, DATASETNAME2, H5T_NATIVE_INT, dataspace, H5P_DEFAULT,
+			cparms, H5P_DEFAULT)) < 0)
+        goto error;
+
+    if((dxpl = H5Pcreate(H5P_DATASET_XFER)) < 0)
+        goto error;
+
+    /* Initialize data for one chunk */
+    for(i = n = 0; i < CHUNK_NX; i++)
+        for(j = 0; j < CHUNK_NY; j++) {
+	    direct_buf[i][j] = n++;
+    }
+
+    /* write the uncompressed chunk data repeatedly to dataset, using the direct writing function. 
+     * Indicate skipping the compression filter.     */ 
+    offset[0] = CHUNK_NX;
+    offset[1] = CHUNK_NY;
+
+    filter_mask = 0x00000001;
+
+    if((status = H5DOwrite_chunk(dataset, dxpl, filter_mask, offset, buf_size, direct_buf)) < 0)
+        goto error;
+
+    if(H5Fflush(dataset, H5F_SCOPE_LOCAL) < 0) 
+        goto error;
+
+    if(H5Dclose(dataset) < 0)
+        goto error;
+
+    if((dataset = H5Dopen(file, DATASETNAME2, H5P_DEFAULT)) < 0)
+        goto error;
+
+    /*
+     * Select hyperslab for the chunk just written in the file
+     */
+    start[0]  = CHUNK_NX; start[1]  = CHUNK_NY;
+    stride[0] = 1; stride[1] = 1;
+    count[0]  = 1; count[1]  = 1;
+    block[0]  = CHUNK_NX; block[1]  = CHUNK_NY;
+    if((status = H5Sselect_hyperslab(dataspace, H5S_SELECT_SET, start, stride, count, block)) < 0)
+        goto error;
+
+    /* Read the chunk back */
+    if((status = H5Dread(dataset, H5T_NATIVE_INT, mem_space, dataspace, H5P_DEFAULT, check_chunk)) < 0)
+        goto error;
+
+    /* Check that the values read are the same as the values written */
+    for(i = 0; i < CHUNK_NX; i++) {
+        for(j = 0; j < CHUNK_NY; j++) {
+            if(direct_buf[i][j] != check_chunk[i][j]) {
+                printf("    1. Read different values than written.");
+                printf("    At index %d,%d\n", i, j);
+                printf("    direct_buf=%d, check_chunk=%d\n", direct_buf[i][j], check_chunk[i][j]); 
+                goto error;
+            }
+        }
+    }
+
+    /*
+     * Close/release resources.
+     */
+    H5Dclose(dataset);
+    H5Sclose(mem_space);
+    H5Sclose(dataspace);
+    H5Pclose(cparms);
+    H5Pclose(dxpl);
+    
+    PASSED();
+    return 0;
+
+error:
+    H5E_BEGIN_TRY {
+        H5Dclose(dataset);
+        H5Sclose(mem_space);
+        H5Sclose(dataspace);
+        H5Pclose(cparms);
+        H5Pclose(dxpl);
+    } H5E_END_TRY;
+
+    return 1;
+}
+
+/*-------------------------------------------------------------------------
+ * Function:	filter_bogus1
+ *
+ * Purpose:	A bogus filte that adds ADD_ON to the original value
+ *
+ * Return:	Success:	Data chunk size
+ *
+ * Programmer:  Raymond Lu	
+ *              30 November 2012
+ *
+ *-------------------------------------------------------------------------
+ */
+static size_t
+filter_bogus1(unsigned int flags, size_t UNUSED cd_nelmts,
+      const unsigned int UNUSED *cd_values, size_t nbytes,
+      size_t *buf_size, void **buf)
+{
+    int *int_ptr=(int *)*buf;          /* Pointer to the data values */
+    size_t buf_left=*buf_size;  /* Amount of data buffer left to process */
+
+    if(flags & H5Z_FLAG_REVERSE) { /* read */
+        /* Substract the "add on" value to all the data values */
+        while(buf_left>0) {
+            *int_ptr++ -= (int)ADD_ON;
+            buf_left -= sizeof(int);
+        } /* end while */
+    } /* end if */
+    else { /* write */
+        /* Add the "add on" value to all the data values */
+        while(buf_left>0) {
+            *int_ptr++ += (int)ADD_ON;
+            buf_left -= sizeof(int);
+        } /* end while */
+    } /* end else */
+
+    return nbytes;
+}
+
+/*-------------------------------------------------------------------------
+ * Function:	filter_bogus2
+ *
+ * Purpose:	A bogus filter that multiplies the original value by FACTOR.
+ *
+ * Return:	Success:	Data chunk size
+ *
+ * Programmer:  Raymond Lu	
+ *              30 November 2012
+ *-------------------------------------------------------------------------
+ */
+static size_t
+filter_bogus2(unsigned int flags, size_t UNUSED cd_nelmts,
+      const unsigned int UNUSED *cd_values, size_t nbytes,
+      size_t *buf_size, void **buf)
+{
+    int *int_ptr=(int *)*buf;          /* Pointer to the data values */
+    size_t buf_left=*buf_size;  /* Amount of data buffer left to process */
+
+    if(flags & H5Z_FLAG_REVERSE) { /* read */
+        /* Substract the "add on" value to all the data values */
+        while(buf_left>0) {
+            *int_ptr++ /= (int)FACTOR;
+            buf_left -= sizeof(int);
+        } /* end while */
+    } /* end if */
+    else { /* write */
+        /* Add the "add on" value to all the data values */
+        while(buf_left>0) {
+            *int_ptr++ *= (int)FACTOR;
+            buf_left -= sizeof(int);
+        } /* end while */
+    } /* end else */
+
+    return nbytes;
+}
+
+/*-------------------------------------------------------------------------
+ * Function:	test_skip_compress_write2
+ *
+ * Purpose:	Test skipping compression filter when there are three filters
+ *              for the dataset
+ *
+ * Return:	Success:	0
+ *
+ *		Failure:	1
+ *
+ * Programmer:  Raymond Lu	
+ *              30 November 2012
+ *
+ *-------------------------------------------------------------------------
+ */
+static int
+test_skip_compress_write2(hid_t file)
+{
+    hid_t       dataspace = -1, dataset = -1;
+    hid_t       mem_space = -1;
+    hid_t       cparms = -1, dxpl = -1;
+    hsize_t     dims[2]  = {NX, NY};        
+    hsize_t     maxdims[2] = {H5S_UNLIMITED, H5S_UNLIMITED};
+    hsize_t     chunk_dims[2] ={CHUNK_NX, CHUNK_NY};
+    herr_t      status;
+    int         i, j, n;
+
+    unsigned    filter_mask = 0;
+    int         origin_direct_buf[CHUNK_NX][CHUNK_NY];
+    int         direct_buf[CHUNK_NX][CHUNK_NY];
+    int         check_chunk[CHUNK_NX][CHUNK_NY];
+    hsize_t     offset[2] = {0, 0};
+    size_t      buf_size = CHUNK_NX*CHUNK_NY*sizeof(int);
+    int          aggression = 9;     /* Compression aggression setting */
+
+    hsize_t start[2];  /* Start of hyperslab */
+    hsize_t stride[2]; /* Stride of hyperslab */
+    hsize_t count[2];  /* Block count */
+    hsize_t block[2];  /* Block sizes */
+
+    TESTING("skipping compression filters but keep two other filters");
+
+    /*
+     * Create the data space with unlimited dimensions.
+     */
+    if((dataspace = H5Screate_simple(RANK, dims, maxdims)) < 0)
+        goto error;
+
+    if((mem_space = H5Screate_simple(RANK, chunk_dims, NULL)) < 0)
+        goto error;
+
+    /*
+     * Modify dataset creation properties, i.e. enable chunking and compression.
+     * The order of filters is bogus 1 + deflate + bogus 2.
+     */
+    if((cparms = H5Pcreate(H5P_DATASET_CREATE)) < 0)
+        goto error;
+
+    if((status = H5Pset_chunk( cparms, RANK, chunk_dims)) < 0)
+        goto error;
+
+    /* Register and enable first bogus filter */
+    if(H5Zregister (H5Z_BOGUS1) < 0) 
+	goto error;
+
+    if(H5Pset_filter(cparms, H5Z_FILTER_BOGUS1, 0, (size_t)0, NULL) < 0) 
+	goto error;
+
+    /* Enable compression filter */
+    if((status = H5Pset_deflate( cparms, (unsigned) aggression)) < 0)
+        goto error;
+
+    /* Register and enable second bogus filter */
+    if(H5Zregister (H5Z_BOGUS2) < 0) 
+	goto error;
+
+    if(H5Pset_filter(cparms, H5Z_FILTER_BOGUS2, 0, (size_t)0, NULL) < 0) 
+	goto error;
+
+    /*
+     * Create a new dataset within the file using cparms
+     * creation properties.
+     */
+    if((dataset = H5Dcreate2(file, DATASETNAME3, H5T_NATIVE_INT, dataspace, H5P_DEFAULT,
+			cparms, H5P_DEFAULT)) < 0)
+        goto error;
+
+    if((dxpl = H5Pcreate(H5P_DATASET_XFER)) < 0)
+        goto error;
+
+    /* Initialize data for one chunk. Apply operations of two bogus filters to the chunk */
+    for(i = n = 0; i < CHUNK_NX; i++)
+        for(j = 0; j < CHUNK_NY; j++) {
+	    origin_direct_buf[i][j] = n++;
+	    direct_buf[i][j] = (origin_direct_buf[i][j] + ADD_ON) * FACTOR;
+    }
+
+    /* write the uncompressed chunk data repeatedly to dataset, using the direct writing function. 
+     * Indicate skipping the compression filter but keep the other two bogus filters */ 
+    offset[0] = CHUNK_NX;
+    offset[1] = CHUNK_NY;
+
+    /* compression filter is the middle one to be skipped */
+    filter_mask = 0x00000002;
+
+    if((status = H5DOwrite_chunk(dataset, dxpl, filter_mask, offset, buf_size, direct_buf)) < 0)
+        goto error;
+
+    if(H5Fflush(dataset, H5F_SCOPE_LOCAL) < 0) 
+        goto error;
+
+    if(H5Dclose(dataset) < 0)
+        goto error;
+
+    if((dataset = H5Dopen(file, DATASETNAME3, H5P_DEFAULT)) < 0)
+        goto error;
+
+    /*
+     * Select hyperslab for one chunk in the file
+     */
+    start[0]  = CHUNK_NX; start[1]  = CHUNK_NY;
+    stride[0] = 1; stride[1] = 1;
+    count[0]  = 1; count[1]  = 1;
+    block[0]  = CHUNK_NX; block[1]  = CHUNK_NY;
+    if((status = H5Sselect_hyperslab(dataspace, H5S_SELECT_SET, start, stride, count, block)) < 0)
+        goto error;
+
+    /* Read the chunk back */
+    if((status = H5Dread(dataset, H5T_NATIVE_INT, mem_space, dataspace, H5P_DEFAULT, check_chunk)) < 0)
+        goto error;
+
+    /* Check that the values read are the same as the values written */
+    for(i = 0; i < CHUNK_NX; i++) {
+        for(j = 0; j < CHUNK_NY; j++) {
+            if(origin_direct_buf[i][j] != check_chunk[i][j]) {
+                printf("    1. Read different values than written.");
+                printf("    At index %d,%d\n", i, j);
+                printf("    origin_direct_buf=%d, check_chunk=%d\n", origin_direct_buf[i][j], check_chunk[i][j]); 
+                goto error;
+            }
+        }
+    }
+
+    /*
+     * Close/release resources.
+     */
+    H5Dclose(dataset);
+    H5Sclose(mem_space);
+    H5Sclose(dataspace);
+    H5Pclose(cparms);
+    H5Pclose(dxpl);
+    
+    PASSED();
+    return 0;
+
+error:
+    H5E_BEGIN_TRY {
+        H5Dclose(dataset);
+        H5Sclose(mem_space);
+        H5Sclose(dataspace);
+        H5Pclose(cparms);
+        H5Pclose(dxpl);
+    } H5E_END_TRY;
+
+    return 1;
+}
+
+/*-------------------------------------------------------------------------
+ * Function:	test_data_conv
+ *
+ * Purpose:	Test data conversion
+ *
+ * Return:	Success:	0
+ *
+ *		Failure:	1
+ *
+ * Programmer:  Raymond Lu	
+ *              30 November 2012
+ *
+ *-------------------------------------------------------------------------
+ */
+static int
+test_data_conv(hid_t file)
+{
+    typedef struct {
+	int a, b, c[4], d, e;
+    } src_type_t;
+    typedef struct {
+	int a,    c[4],    e;
+    } dst_type_t;
+
+    hid_t       dataspace = -1, dataset = -1;
+    hid_t       mem_space = -1;
+    hid_t       cparms = -1, dxpl = -1;
+    hsize_t     dims[2]  = {NX, NY};        
+    hsize_t     maxdims[2] = {H5S_UNLIMITED, H5S_UNLIMITED};
+    hsize_t     chunk_dims[2] ={CHUNK_NX, CHUNK_NY};
+    herr_t      status;
+    int         i, j, n;
+    const hsize_t	four = 4;
+    hid_t	st=-1, dt=-1;
+    hid_t       array_dt;
+
+    unsigned    filter_mask = 0;
+    src_type_t  direct_buf[CHUNK_NX][CHUNK_NY];
+    dst_type_t  check_chunk[CHUNK_NX][CHUNK_NY];
+    hsize_t     offset[2] = {0, 0};
+    size_t      buf_size = CHUNK_NX*CHUNK_NY*sizeof(src_type_t);
+
+    hsize_t start[2];  /* Start of hyperslab */
+    hsize_t stride[2]; /* Stride of hyperslab */
+    hsize_t count[2];  /* Block count */
+    hsize_t block[2];  /* Block sizes */
+
+    TESTING("data conversion for H5DOwrite_chunk");
+
+    /*
+     * Create the data space with unlimited dimensions.
+     */
+    if((dataspace = H5Screate_simple(RANK, dims, maxdims)) < 0)
+        goto error;
+
+    if((mem_space = H5Screate_simple(RANK, chunk_dims, NULL)) < 0)
+        goto error;
+
+    /*
+     * Modify dataset creation properties, i.e. enable chunking
+     */
+    if((cparms = H5Pcreate(H5P_DATASET_CREATE)) < 0)
+        goto error;
+
+    if((status = H5Pset_chunk( cparms, RANK, chunk_dims)) < 0)
+        goto error;
+
+    /* Build hdf5 datatypes */
+    array_dt = H5Tarray_create2(H5T_NATIVE_INT, 1, &four);
+    if((st = H5Tcreate(H5T_COMPOUND, sizeof(src_type_t))) < 0 ||
+            H5Tinsert(st, "a", HOFFSET(src_type_t, a), H5T_NATIVE_INT) < 0 ||
+            H5Tinsert(st, "b", HOFFSET(src_type_t, b), H5T_NATIVE_INT) < 0 ||
+            H5Tinsert(st, "c", HOFFSET(src_type_t, c), array_dt) < 0 ||
+            H5Tinsert(st, "d", HOFFSET(src_type_t, d), H5T_NATIVE_INT) < 0 ||
+            H5Tinsert(st, "e", HOFFSET(src_type_t, e), H5T_NATIVE_INT) < 0)
+        goto error;
+
+    if(H5Tclose(array_dt) < 0)
+        goto error;
+
+    array_dt = H5Tarray_create2(H5T_NATIVE_INT, 1, &four);
+    if((dt = H5Tcreate(H5T_COMPOUND, sizeof(dst_type_t))) < 0 ||
+            H5Tinsert(dt, "a", HOFFSET(dst_type_t, a), H5T_NATIVE_INT) < 0 ||
+            H5Tinsert(dt, "c", HOFFSET(dst_type_t, c), array_dt) < 0 ||
+            H5Tinsert(dt, "e", HOFFSET(dst_type_t, e), H5T_NATIVE_INT) < 0)
+        goto error;
+
+    if(H5Tclose(array_dt) < 0)
+        goto error;
+
+    /*
+     * Create a new dataset within the file using cparms
+     * creation properties.
+     */
+    if((dataset = H5Dcreate2(file, DATASETNAME4, st, dataspace, H5P_DEFAULT,
+			cparms, H5P_DEFAULT)) < 0)
+        goto error;
+
+    if((dxpl = H5Pcreate(H5P_DATASET_XFER)) < 0)
+        goto error;
+
+    /* Initialize data for one chunk */
+    for(i = n = 0; i < CHUNK_NX; i++) {
+        for(j = 0; j < CHUNK_NY; j++) {
+            (direct_buf[i][j]).a    = i*j+0;
+            (direct_buf[i][j]).b    = i*j+1;
+            (direct_buf[i][j]).c[0] = i*j+2;
+            (direct_buf[i][j]).c[1] = i*j+3;
+            (direct_buf[i][j]).c[2] = i*j+4;
+            (direct_buf[i][j]).c[3] = i*j+5;
+            (direct_buf[i][j]).d    = i*j+6;
+            (direct_buf[i][j]).e    = i*j+7;
+        }
+    }
+
+    /* write the chunk data to dataset, using the direct writing function. 
+     * There should be no data conversion involved. */
+    offset[0] = CHUNK_NX;
+    offset[1] = CHUNK_NY;
+
+    if((status = H5DOwrite_chunk(dataset, dxpl, filter_mask, offset, buf_size, direct_buf)) < 0)
+        goto error;
+
+    if(H5Fflush(dataset, H5F_SCOPE_LOCAL) < 0) 
+        goto error;
+
+    if(H5Dclose(dataset) < 0)
+        goto error;
+
+    if((dataset = H5Dopen(file, DATASETNAME4, H5P_DEFAULT)) < 0)
+        goto error;
+
+    /*
+     * Select hyperslab for the chunk just written in the file
+     */
+    start[0]  = CHUNK_NX; start[1]  = CHUNK_NY;
+    stride[0] = 1; stride[1] = 1;
+    count[0]  = 1; count[1]  = 1;
+    block[0]  = CHUNK_NX; block[1]  = CHUNK_NY;
+    if((status = H5Sselect_hyperslab(dataspace, H5S_SELECT_SET, start, stride, count, block)) < 0)
+        goto error;
+
+    /* Read the chunk back. Data should be converted */
+    if((status = H5Dread(dataset, dt, mem_space, dataspace, H5P_DEFAULT, check_chunk)) < 0)
+        goto error;
+
+    /* Check that the values read are the same as the values written */
+    for(i = 0; i < CHUNK_NX; i++) {
+        for(j = 0; j < CHUNK_NY; j++) {
+	    if ((direct_buf[i][j]).a    != (check_chunk[i][j]).a    ||
+	        (direct_buf[i][j]).c[0] != (check_chunk[i][j]).c[0] ||
+	        (direct_buf[i][j]).c[1] != (check_chunk[i][j]).c[1] ||
+	        (direct_buf[i][j]).c[2] != (check_chunk[i][j]).c[2] ||
+	        (direct_buf[i][j]).c[3] != (check_chunk[i][j]).c[3] ||
+	        (direct_buf[i][j]).e    != (check_chunk[i][j]).e) {
+                printf("    1. Read different values than written.");
+                printf("    At index %d,%d\n", i, j);
+	        printf("    src={a=%d, b=%d, c=[%d,%d,%d,%d], d=%d, e=%d\n",
+                   (direct_buf[i][j]).a, (direct_buf[i][j]).b, (direct_buf[i][j]).c[0], (direct_buf[i][j]).c[1], 
+                   (direct_buf[i][j]).c[2], (direct_buf[i][j]).c[3], (direct_buf[i][j]).d, (direct_buf[i][j]).e);
+	        printf("    dst={a=%d, c=[%d,%d,%d,%d], e=%d\n",
+                   (check_chunk[i][j]).a, (check_chunk[i][j]).c[0], (check_chunk[i][j]).c[1], (check_chunk[i][j]).c[2], 
+                   (check_chunk[i][j]).c[3], (check_chunk[i][j]).e);
+
+	    goto error;
+            }
+        }
+    }
+
+    /*
+     * Close/release resources.
+     */
+    H5Dclose(dataset);
+    H5Sclose(mem_space);
+    H5Sclose(dataspace);
+    H5Pclose(cparms);
+    H5Pclose(dxpl);
+    H5Tclose(st);
+    H5Tclose(dt);
+
+
+    PASSED();
+    return 0;
+
+error:
+    H5E_BEGIN_TRY {
+        H5Dclose(dataset);
+        H5Sclose(mem_space);
+        H5Sclose(dataspace);
+        H5Pclose(cparms);
+        H5Pclose(dxpl);
+        H5Tclose(st);
+        H5Tclose(dt);
+    } H5E_END_TRY;
+
+    return 1;
+}
+
+/*-------------------------------------------------------------------------
+ * Function:	test_invalid_parameters
+ *
+ * Purpose:	Test invalid parameters for H5DOwrite_chunk
+ *
+ * Return:	Success:	0
+ *
+ *		Failure:	1
+ *
+ * Programmer:  Raymond Lu	
+ *              30 November 2012
+ *
+ *-------------------------------------------------------------------------
+ */
+static int
+test_invalid_parameters(hid_t file)
+{
+    hid_t       dataspace = -1, dataset = -1;
+    hid_t       mem_space = -1;
+    hid_t       cparms = -1, dxpl = -1;
+    hsize_t     dims[2]  = {NX, NY};        
+    hsize_t     chunk_dims[2] ={CHUNK_NX, CHUNK_NY};
+    herr_t      status;
+    int         i, j, n;
+
+    unsigned    filter_mask = 0;
+    int         direct_buf[CHUNK_NX][CHUNK_NY];
+    int         check_chunk[CHUNK_NX][CHUNK_NY];
+    hsize_t     offset[2] = {0, 0};
+    size_t      buf_size = CHUNK_NX*CHUNK_NY*sizeof(int);
+    int         aggression = 9;     /* Compression aggression setting */
+
+    TESTING("invalid parameters for H5DOwrite_chunk");
+
+    /*
+     * Create the data space with unlimited dimensions.
+     */
+    if((dataspace = H5Screate_simple(RANK, dims, NULL)) < 0)
+        goto error;
+
+    if((mem_space = H5Screate_simple(RANK, chunk_dims, NULL)) < 0)
+        goto error;
+
+    /*
+     * Modify dataset creation properties
+     */
+    if((cparms = H5Pcreate(H5P_DATASET_CREATE)) < 0)
+        goto error;
+
+    /*
+     * Create a new contiguous dataset to verify H5DOwrite_chunk doesn't work
+     */
+    if((dataset = H5Dcreate2(file, DATASETNAME5, H5T_NATIVE_INT, dataspace, H5P_DEFAULT,
+			cparms, H5P_DEFAULT)) < 0)
+        goto error;
+
+    if((dxpl = H5Pcreate(H5P_DATASET_XFER)) < 0)
+        goto error;
+
+    /* Initialize data for one chunk */
+    for(i = n = 0; i < CHUNK_NX; i++)
+        for(j = 0; j < CHUNK_NY; j++) {
+	    direct_buf[i][j] = n++;
+    }
+
+    /* Try to write the chunk data to contiguous dataset.  It should fail */
+    offset[0] = CHUNK_NX;
+    offset[1] = CHUNK_NY;
+
+    H5E_BEGIN_TRY {
+        if((status = H5DOwrite_chunk(dataset, dxpl, filter_mask, offset, buf_size, direct_buf)) != FAIL)
+            goto error;
+    } H5E_END_TRY;
+
+    if(H5Dclose(dataset) < 0)
+        goto error;
+
+    /* Create a chunked dataset with compression filter */
+    if((status = H5Pset_chunk( cparms, RANK, chunk_dims)) < 0)
+        goto error;
+
+    if((status = H5Pset_deflate( cparms, (unsigned ) aggression)) < 0)
+        goto error;
+
+    /*
+     * Create a new dataset within the file using cparms
+     * creation properties.
+     */
+    if((dataset = H5Dcreate2(file, DATASETNAME6, H5T_NATIVE_INT, dataspace, H5P_DEFAULT,
+			cparms, H5P_DEFAULT)) < 0)
+        goto error;
+
+    /* Check invalid dataset ID */ 
+    H5E_BEGIN_TRY {
+        if((status = H5DOwrite_chunk(-1, dxpl, filter_mask, offset, buf_size, direct_buf)) != FAIL)
+            goto error;
+    } H5E_END_TRY;
+
+    /* Check invalid DXPL ID */
+    H5E_BEGIN_TRY {
+        if((status = H5DOwrite_chunk(dataset, -1, filter_mask, offset, buf_size, direct_buf)) != FAIL)
+            goto error;
+    } H5E_END_TRY;
+
+    /* Check invalid OFFSET */
+    H5E_BEGIN_TRY {
+        if((status = H5DOwrite_chunk(dataset, dxpl, filter_mask, NULL, buf_size, direct_buf)) != FAIL)
+            goto error;
+    } H5E_END_TRY;
+
+    /* Check when OFFSET is out of dataset range */
+    offset[0] = NX + 1;
+    offset[1] = NY;
+    H5E_BEGIN_TRY {
+        if((status = H5DOwrite_chunk(dataset, dxpl, filter_mask, offset, buf_size, direct_buf)) != FAIL)
+            goto error;
+    } H5E_END_TRY;
+
+    /* Check when OFFSET is not on chunk boundary */
+    offset[0] = CHUNK_NX;
+    offset[1] = CHUNK_NY + 1;
+    H5E_BEGIN_TRY {
+        if((status = H5DOwrite_chunk(dataset, dxpl, filter_mask, offset, buf_size, direct_buf)) != FAIL)
+            goto error;
+    } H5E_END_TRY;
+
+    /* Check invalid buffer size */
+    offset[0] = CHUNK_NX;
+    offset[1] = CHUNK_NY;
+    buf_size = 0; 
+    H5E_BEGIN_TRY {
+        if((status = H5DOwrite_chunk(dataset, dxpl, filter_mask, offset, buf_size, direct_buf)) != FAIL)
+            goto error;
+    } H5E_END_TRY;
+
+    /* Check invalid data buffer */
+    buf_size = CHUNK_NX*CHUNK_NY*sizeof(int);
+    H5E_BEGIN_TRY {
+        if((status = H5DOwrite_chunk(dataset, dxpl, filter_mask, offset, buf_size, NULL)) != FAIL)
+            goto error;
+    } H5E_END_TRY;
+
+    if(H5Dclose(dataset) < 0)
+        goto error;
+
+    /*
+     * Close/release resources.
+     */
+    H5Sclose(mem_space);
+    H5Sclose(dataspace);
+    H5Pclose(cparms);
+    H5Pclose(dxpl);
+    
+    PASSED();
+    return 0;
+
+error:
+    H5E_BEGIN_TRY {
+        H5Dclose(dataset);
+        H5Sclose(mem_space);
+        H5Sclose(dataspace);
+        H5Pclose(cparms);
+        H5Pclose(dxpl);
+    } H5E_END_TRY;
+
+    return 1;
+}
+
+/*-------------------------------------------------------------------------
+ * Function:	Main function
+ *
+ * Purpose:	Test direct chunk write function H5DOwrite_chunk
+ *
+ * Return:	Success:	0
+ *
+ *		Failure:	1
+ *
+ * Programmer:  Raymond Lu	
+ *              30 November 2012
+ *
+ *-------------------------------------------------------------------------
+ */
 int main( void )
 {
-    int  nerrors=0;
+    hid_t file_id;
+    int   nerrors=0;
+
+    /*
+     * Create a new file. If file exists its contents will be overwritten.
+     */
+    if((file_id = H5Fcreate(FILE_NAME, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT)) < 0)
+        goto error;
 
     /* Test direct chunk write */
-    nerrors += test_direct_chunk_write();
+    nerrors += test_direct_chunk_write(file_id);
+    nerrors += test_skip_compress_write1(file_id);
+    nerrors += test_skip_compress_write2(file_id);
+    nerrors += test_data_conv(file_id);
+    nerrors += test_invalid_parameters(file_id);
+
+    if(H5Fclose(file_id) < 0)
+        goto error;
 
     /* check for errors */
     if (nerrors)
diff --git a/perform/dectris_perf.c b/perform/dectris_perf.c
index abaa92f..4d2284d 100644
--- a/perform/dectris_perf.c
+++ b/perform/dectris_perf.c
@@ -53,11 +53,11 @@ const char *FILENAME[] = {
 #define REG_NO_COMPRESS_DSET   "reg_no_compress_dset"
 #define RANK         3
 #define NX     100
-#define NY     1000
-#define NZ     250
+#define NY     2000
+#define NZ     3000
 #define CHUNK_NX     1 
-#define CHUNK_NY     1000
-#define CHUNK_NZ     250
+#define CHUNK_NY     2000
+#define CHUNK_NZ     3000
 
 #define DEFLATE_SIZE_ADJUST(s) (ceil(((double)(s))*1.001)+12)
 char        filename[1024];
diff --git a/src/H5Dchunk.c b/src/H5Dchunk.c
index 3b96fa0..c307b8c 100644
--- a/src/H5Dchunk.c
+++ b/src/H5Dchunk.c
@@ -283,7 +283,7 @@ H5FL_BLK_DEFINE_STATIC(chunk);
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5D__direct_write
+ * Function:	H5D__chunk_direct_write
  *
  * Purpose:	Internal routine for H5PSIdirect_write to write a chunk 
  *              directly into the file.
@@ -310,7 +310,6 @@ H5D__chunk_direct_write(const H5D_t *dset, hid_t dxpl_id, uint32_t filters, hsiz
     H5FD_t *lf; 
     herr_t ret_value = SUCCEED; /* Return value */
 
-    /*FUNC_ENTER_PACKAGE*/
     FUNC_ENTER_STATIC_TAG(dxpl_id, dset->oloc.addr, FAIL)
 
     /* Allocate data space and initialize it if it hasn't been. */
@@ -382,7 +381,6 @@ H5D__chunk_direct_write(const H5D_t *dset, hid_t dxpl_id, uint32_t filters, hsiz
 
 
 done:
-    /*FUNC_LEAVE_NOAPI(ret_value)*/
     FUNC_LEAVE_NOAPI_TAG(ret_value, FAIL)
 }
 
diff --git a/src/H5Dio.c b/src/H5Dio.c
index e5a9ccc..095c8a5 100644
--- a/src/H5Dio.c
+++ b/src/H5Dio.c
@@ -140,6 +140,10 @@ H5Dread(hid_t dset_id, hid_t mem_type_id, hid_t mem_space_id,
 	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a dataset")
     if(NULL == dset->oloc.file)
 	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a dataset")
+
+    if(mem_space_id < 0 || file_space_id < 0)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data space")
+
     if(H5S_ALL != mem_space_id) {
 	if(NULL == (mem_space = (const H5S_t *)H5I_object_verify(mem_space_id, H5I_DATASPACE)))
 	    HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data space")
@@ -252,10 +256,10 @@ H5D__pre_write(hid_t dset_id, hid_t mem_type_id, hid_t mem_space_id,
 {
     H5D_t		   *dset = NULL;
     H5P_genplist_t 	   *plist;      /* Property list pointer */
-    htri_t		    direct_write = FALSE;
+    hbool_t		    direct_write = FALSE;
     herr_t                  ret_value = SUCCEED;  /* Return value */
 
-    FUNC_ENTER_NOAPI(FAIL)
+    FUNC_ENTER_STATIC
 
     /* check arguments */
     if(NULL == (dset = (H5D_t *)H5I_object_verify(dset_id, H5I_DATASET)))
@@ -283,14 +287,13 @@ H5D__pre_write(hid_t dset_id, hid_t mem_type_id, hid_t mem_space_id,
         hsize_t *direct_offset;
         size_t   direct_datasize = 0;
 	int      ndims = 0;
-	hsize_t *dims = NULL;
-	hsize_t *internal_offset = NULL;
+	hsize_t  dims[H5O_LAYOUT_NDIMS];
+	hsize_t  internal_offset[H5O_LAYOUT_NDIMS];
 	int      i;
 
         if(H5D_CHUNKED != dset->shared->layout.type)
 	    HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a chunked dataset")
 
-
         if(H5P_get(plist, H5D_XFER_DIRECT_CHUNK_WRITE_FILTERS_NAME, &direct_filters) < 0)
             HGOTO_ERROR(H5E_PLIST, H5E_CANTGET, FAIL, "error getting filter info for direct chunk write")
 
@@ -302,14 +305,7 @@ H5D__pre_write(hid_t dset_id, hid_t mem_type_id, hid_t mem_space_id,
 
 	/* The library's chunking code requires the offset terminates with a zero. So transfer the 
          * offset array to an internal offset array */ 
-	ndims = (int)H5S_GET_EXTENT_NDIMS(dset->shared->space);
-	if(NULL == (dims = (hsize_t *)H5MM_malloc(ndims*sizeof(hsize_t))))
-	    HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for dimensions")
-
-	if(NULL == (internal_offset = (hsize_t *)H5MM_malloc((ndims+1)*sizeof(hsize_t))))
-	    HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for offset")
-
-	if(H5S_get_simple_extent_dims(dset->shared->space, dims, NULL) < 0)
+	if((ndims = H5S_get_simple_extent_dims(dset->shared->space, dims, NULL)) < 0)
 	    HGOTO_ERROR(H5E_DATASPACE, H5E_CANTGET, FAIL, "can't retrieve dataspace extent dims")
 
 	for(i=0; i<ndims; i++) {
@@ -335,6 +331,9 @@ H5D__pre_write(hid_t dset_id, hid_t mem_type_id, hid_t mem_space_id,
 	const H5S_t *file_space = NULL;
 	char        fake_char;
 
+        if(mem_space_id < 0 || file_space_id < 0)
+	    HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data space")
+
 	if(H5S_ALL != mem_space_id) {
 	    if(NULL == (mem_space = (const H5S_t *)H5I_object_verify(mem_space_id, H5I_DATASPACE)))
 	        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data space")
diff --git a/src/H5Pdxpl.c b/src/H5Pdxpl.c
index d8f0c6f..552ea63 100644
--- a/src/H5Pdxpl.c
+++ b/src/H5Pdxpl.c
@@ -159,7 +159,7 @@
 #define H5D_XFER_XFORM_CMP          H5P__dxfr_xform_cmp
 #define H5D_XFER_XFORM_CLOSE        H5P__dxfr_xform_close
 /* Definitions for properties of direct chunk write */
-#define H5D_XFER_DIRECT_CHUNK_WRITE_FLAG_SIZE		sizeof(htri_t)
+#define H5D_XFER_DIRECT_CHUNK_WRITE_FLAG_SIZE		sizeof(hbool_t)
 #define H5D_XFER_DIRECT_CHUNK_WRITE_FLAG_DEF		FALSE
 #define H5D_XFER_DIRECT_CHUNK_WRITE_FILTERS_SIZE	sizeof(uint32_t)
 #define H5D_XFER_DIRECT_CHUNK_WRITE_FILTERS_DEF		0
@@ -264,7 +264,7 @@ static const H5Z_EDC_t H5D_def_enable_edc_g = H5D_XFER_EDC_DEF;            /* De
 static const H5Z_cb_t H5D_def_filter_cb_g = H5D_XFER_FILTER_CB_DEF;        /* Default value for filter callback */
 static const H5T_conv_cb_t H5D_def_conv_cb_g = H5D_XFER_CONV_CB_DEF;       /* Default value for datatype conversion callback */
 static const void *H5D_def_xfer_xform_g = H5D_XFER_XFORM_DEF;          /* Default value for data transform */
-static const htri_t H5D_def_direct_chunk_flag_g = H5D_XFER_DIRECT_CHUNK_WRITE_FLAG_DEF; 	/* Default value for the flag of direct chunk write */
+static const hbool_t H5D_def_direct_chunk_flag_g = H5D_XFER_DIRECT_CHUNK_WRITE_FLAG_DEF; 	/* Default value for the flag of direct chunk write */
 static const uint32_t H5D_def_direct_chunk_filters_g = H5D_XFER_DIRECT_CHUNK_WRITE_FILTERS_DEF;	/* Default value for the filters of direct chunk write */
 static const hsize_t *H5D_def_direct_chunk_offset_g = H5D_XFER_DIRECT_CHUNK_WRITE_OFFSET_DEF; 	/* Default value for the offset of direct chunk write */
 static const size_t H5D_def_direct_chunk_datasize_g = H5D_XFER_DIRECT_CHUNK_WRITE_DATASIZE_DEF; /* Default value for the datasize of direct chunk write */
@@ -439,21 +439,25 @@ H5P__dxfr_reg_prop(H5P_genclass_t *pclass)
         HGOTO_ERROR(H5E_PLIST, H5E_CANTINSERT, FAIL, "can't insert property into class")
 
     /* Register the property of flag for direct chunk write */
+    /* (Note: this property should not have an encode/decode callback -QAK) */
     if(H5P_register_real(pclass, H5D_XFER_DIRECT_CHUNK_WRITE_FLAG_NAME, H5D_XFER_DIRECT_CHUNK_WRITE_FLAG_SIZE, &H5D_def_direct_chunk_flag_g,
             NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL) < 0)
         HGOTO_ERROR(H5E_PLIST, H5E_CANTINSERT, FAIL, "can't insert property into class")
 
     /* Register the property of filter for direct chunk write */
+    /* (Note: this property should not have an encode/decode callback -QAK) */
     if(H5P_register_real(pclass, H5D_XFER_DIRECT_CHUNK_WRITE_FILTERS_NAME, H5D_XFER_DIRECT_CHUNK_WRITE_FILTERS_SIZE, &H5D_def_direct_chunk_filters_g,
             NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL) < 0)
         HGOTO_ERROR(H5E_PLIST, H5E_CANTINSERT, FAIL, "can't insert property into class")
 
     /* Register the property of offset for direct chunk write */
+    /* (Note: this property should not have an encode/decode callback -QAK) */
     if(H5P_register_real(pclass, H5D_XFER_DIRECT_CHUNK_WRITE_OFFSET_NAME, H5D_XFER_DIRECT_CHUNK_WRITE_OFFSET_SIZE, &H5D_def_direct_chunk_offset_g,
             NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL) < 0)
         HGOTO_ERROR(H5E_PLIST, H5E_CANTINSERT, FAIL, "can't insert property into class")
 
     /* Register the property of datasize for direct chunk write */
+    /* (Note: this property should not have an encode/decode callback -QAK) */
     if(H5P_register_real(pclass, H5D_XFER_DIRECT_CHUNK_WRITE_DATASIZE_NAME, H5D_XFER_DIRECT_CHUNK_WRITE_DATASIZE_SIZE, &H5D_def_direct_chunk_datasize_g,
             NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL) < 0)
         HGOTO_ERROR(H5E_PLIST, H5E_CANTINSERT, FAIL, "can't insert property into class")