[svn-r8259] *** empty log message ***

4 files changed, 407 insertions, 14 deletions

diff --git a/src/H5T.c b/src/H5T.c
index f614d32..fa73518 100644
--- a/src/H5T.c
+++ b/src/H5T.c
@@ -954,6 +954,7 @@ H5T_init_interface(void)
     status = 0;
 
     status |= H5T_register(H5T_PERS_SOFT, "i_i", fixedpt, fixedpt, H5T_conv_i_i, H5AC_dxpl_id);
+    status |= H5T_register(H5T_PERS_SOFT, "i_f", fixedpt, floatpt, H5T_conv_i_f, H5AC_dxpl_id);
     status |= H5T_register(H5T_PERS_SOFT, "f_f", floatpt, floatpt, H5T_conv_f_f, H5AC_dxpl_id);
     status |= H5T_register(H5T_PERS_SOFT, "f_i", floatpt, fixedpt, H5T_conv_f_i, H5AC_dxpl_id);
     status |= H5T_register(H5T_PERS_SOFT, "s_s", string, string, H5T_conv_s_s, H5AC_dxpl_id);
diff --git a/src/H5Tbit.c b/src/H5Tbit.c
index ef62f31..f3fbc3d 100644
--- a/src/H5Tbit.c
+++ b/src/H5Tbit.c
@@ -166,7 +166,8 @@ H5T_bit_copy (uint8_t *dst, size_t dst_offset, const uint8_t *src,
  *
  * Purpose:	Simulation of hardware shifting.  Shifts a bit vector
  *              in a way similar to shifting a variable value, like
- *              value <<= 3, or value >>= 16.
+ *              value <<= 3, or value >>= 16.  SHIFT_DIST is positive for 
+ *              left shift, negative for right shift.
  *
  * Return:	void
  *
@@ -175,6 +176,9 @@ H5T_bit_copy (uint8_t *dst, size_t dst_offset, const uint8_t *src,
  *
  * Modifications:
  *
+ * 		Can generalize it to handle a bit vector of any START 
+ * 		position and any SIZE.
+ *
  *-------------------------------------------------------------------------
  */
 void
@@ -219,7 +223,8 @@ done:
 /*-------------------------------------------------------------------------
  * Function:	H5T_bit_get_d
  *
- * Purpose:	Return a small bit sequence as a number.
+ * Purpose:	Return a small bit sequence as a number.  Bit vector starts
+ *              at OFFSET and is SIZE bits long.
  *
  * Return:	Success:	The bit sequence interpretted as an unsigned
  *				integer.
@@ -369,7 +374,9 @@ H5T_bit_set (uint8_t *buf, size_t offset, size_t size, hbool_t value)
  * Purpose:	Finds the first bit with the specified VALUE within a region
  *		of a bit vector.  The region begins at OFFSET and continues
  *		for SIZE bits, but the region can be searched from the least
- *		significat end toward the most significant end with 
+ *		significat end toward the most significant end(H5T_BIT_MSB
+ *		as DIRECTION), or from the most significant end to the least 
+ *		significant end(H5T_BIT_LSB as DIRECTION).
  *
  * Return:	Success:	The position of the bit found, relative to
  *				the offset.
@@ -473,7 +480,8 @@ done:
 /*-------------------------------------------------------------------------
  * Function:	H5T_bit_inc
  *
- * Purpose:	Increment part of a bit field by adding 1.
+ * Purpose:	Increment part of a bit field by adding 1.  The bit field 
+ *              starts with bit position START and is SIZE bits long.
  *
  * Return:	Success:        The carry-out value, one if overflow zero
  *				otherwise.
@@ -542,8 +550,8 @@ H5T_bit_inc(uint8_t *buf, size_t start, size_t size)
  * Function:	H5T_bit_dec
  *
  * Purpose:	decrement part of a bit field by 1.
- *              At this moment, START is always 0 and the algorithm only 
- *              works from the end to the front for the buffer.
+ *              At this moment, START is always 0 and SIZE is a multiply 
+ *              of 8(in bit).  This is different from H5T_bit_inc.
  *
  * Return:	void
  *
@@ -553,6 +561,9 @@ H5T_bit_inc(uint8_t *buf, size_t start, size_t size)
  *
  * Modifications:
  *
+ * 		Need to generalize it to handle random START and SIZE like
+ *              H5T_bit_inc. 
+ *
  *-------------------------------------------------------------------------
  */
 void
@@ -579,7 +590,8 @@ H5T_bit_dec(uint8_t *buf, size_t start, size_t size)
  * Function:	H5T_bit_neg
  *
  * Purpose:	Bit-negate buffer.
- *              At this moment, START is always 0. 
+ *              At this moment, START is always 0 and SIZE is always a
+ *              multiply of 8 (in bit). 
  *
  * Return:	void
  *
@@ -588,6 +600,9 @@ H5T_bit_dec(uint8_t *buf, size_t start, size_t size)
  *
  * Modifications:
  *
+ * 		Need to generalize it to handle rand START and SIZE like
+ * 		H5T_bit_inc.
+ *
  *-------------------------------------------------------------------------
  */
 void
diff --git a/src/H5Tconv.c b/src/H5Tconv.c
index f6a51f1..e686faa 100644
--- a/src/H5Tconv.c
+++ b/src/H5Tconv.c
@@ -8472,7 +8472,7 @@ H5T_conv_f_i (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata, hsize_t nelmts,
             /* Allocate enough space for the buffer holding temporary 
              * converted value
              */ 
-            buf_size = (int)HDpow((double)2.0, (double)src.u.f.esize) / 8 + 1;          
+            buf_size = (size_t)HDpow((double)2.0, (double)src.u.f.esize) / 8 + 1;          
             int_buf = (uint8_t*)H5MM_calloc(buf_size);
 
             /* The conversion loop */
@@ -8564,7 +8564,6 @@ H5T_conv_f_i (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata, hsize_t nelmts,
                  * the source exponent bias.
                  */
                 if (0==expo || H5T_NORM_NONE==src.u.f.norm) {
-                    /*Don't get this part*/
                     bitno = H5T_bit_find(s, src.u.f.mpos, src.u.f.msize,
                                          H5T_BIT_MSB, TRUE);
                     assert(bitno>=0);
@@ -8607,11 +8606,7 @@ H5T_conv_f_i (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata, hsize_t nelmts,
                  * Shift mantissa part by exponent minus mantissa size(right shift), 
                  * or by mantissa size minus exponent(left shift).
                  */
-                if( H5T_NORM_IMPLIED==src.u.f.norm) {
-                    H5T_bit_shift(int_buf, expo - src.u.f.msize, buf_size);
-                } else if(H5T_NORM_NONE==src.u.f.norm) {
-                    /* How to do this? */
-                }
+                H5T_bit_shift(int_buf, expo - src.u.f.msize, buf_size);
 
                 /*fprintf(stderr, "int_buf=");
                 for(i=0; i<buf_size; i++)
@@ -8749,3 +8744,381 @@ H5T_conv_f_i (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata, hsize_t nelmts,
 done:
     FUNC_LEAVE_NOAPI(ret_value);
 }
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5T_conv_i_f
+ *
+ * Purpose:	Convert one integer type to a floating-point type.  This is 
+ *              the catch-all function for integer-float conversions and 
+ *              is probably not particularly fast.
+ *
+ * Return:	Non-negative on success/Negative on failure
+ *
+ * Programmer:	Raymond Lu
+ *		Friday, Feb 6, 2004
+ *
+ * Modifications:
+ *		
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5T_conv_i_f (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata, hsize_t nelmts,
+    size_t buf_stride, size_t UNUSED bkg_stride, void *buf, void UNUSED *bkg,
+    hid_t UNUSED dxpl_id)
+{
+    /* Traversal-related variables */
+    H5T_t	*src_p;			/*source data type		*/
+    H5T_t	*dst_p;			/*destination data type		*/
+    H5T_atomic_t src;			/*atomic source info		*/
+    H5T_atomic_t dst;			/*atomic destination info	*/
+    int	direction;		/*forward or backward traversal	*/
+    hsize_t	elmtno;			/*element number		*/
+    size_t	half_size;		/*half the type size		*/
+    hsize_t	olap;			/*num overlapping elements	*/
+    ssize_t	bitno;			/*bit number			*/
+    uint8_t	*s, *sp, *d, *dp;	/*source and dest traversal ptrs*/
+    uint8_t	dbuf[64];		/*temp destination buffer	*/
+
+    /* Conversion-related variables */
+    hsize_t	expo;			/*destiny exponent		*/
+    hsize_t	expo_max;		/*maximal possible exponent value       */
+    /*hsize_t     sign = 0;*/               /*source sign bit value         */
+    /*hsize_t     is_max_neg = 0;*/         /*source is maximal negative value*/
+    /*hsize_t     do_round = 0;*/           /*whether there is roundup      */
+    /*hsize_t     trailing = 0;*/           /*whether there is trailing after 1st roundup bit*/
+    uint8_t     *int_buf;               /*buffer for temporary value    */ 
+    size_t      buf_size;               /*buffer size for temporary value */
+    size_t      msize;                  /*mantissa size after restored implied 1  */
+    size_t	i;			/*miscellaneous counters	*/
+    size_t	first;                  /*first bit(MSB) in an integer  */
+    ssize_t	sfirst;			/*a signed version of `first'	*/
+    herr_t      ret_value=SUCCEED;       /* Return value */
+    
+    FUNC_ENTER_NOAPI(H5T_conv_i_f, FAIL);
+
+    switch (cdata->command) {
+        case H5T_CONV_INIT:
+            if (NULL==(src_p=H5I_object(src_id)) ||
+                    NULL==(dst_p=H5I_object(dst_id)))
+                HGOTO_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
+            src = src_p->u.atomic;
+            dst = dst_p->u.atomic;
+            if (H5T_ORDER_LE!=dst.order && H5T_ORDER_BE!=dst.order)
+                HGOTO_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "unsupported byte order");
+            if (dst_p->size>sizeof(dbuf))
+                HGOTO_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "destination size is too large");
+            if (8*sizeof(expo)-1<src.u.f.esize)
+                HGOTO_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "exponent field is too large");
+            cdata->need_bkg = H5T_BKG_NO;
+            break;
+
+        case H5T_CONV_FREE:
+            break;
+
+        case H5T_CONV_CONV:
+            /* Get the data types */
+            if (NULL==(src_p=H5I_object(src_id)) ||
+                    NULL==(dst_p=H5I_object(dst_id)))
+                HGOTO_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
+            src = src_p->u.atomic;
+            dst = dst_p->u.atomic;
+
+            /*
+             * Do we process the values from beginning to end or vice versa? Also,
+             * how many of the elements have the source and destination areas
+             * overlapping?
+             */
+            if (src_p->size==dst_p->size || buf_stride) {
+                sp = dp = (uint8_t*)buf;
+                direction = 1;
+                olap = nelmts;
+            } else if (src_p->size>=dst_p->size) {
+                double olap_d = HDceil((double)(dst_p->size)/
+                                       (double)(src_p->size-dst_p->size));
+                olap = (size_t)olap_d;
+                sp = dp = (uint8_t*)buf;
+                direction = 1;
+            } else {
+                double olap_d = HDceil((double)(src_p->size)/
+                                       (double)(dst_p->size-src_p->size));
+                olap = (size_t)olap_d;
+                sp = (uint8_t*)buf + (nelmts-1) * src_p->size;
+                dp = (uint8_t*)buf + (nelmts-1) * dst_p->size;
+                direction = -1;
+            }
+
+            /* Allocate enough space for the buffer holding temporary 
+             * converted value
+             */ 
+            buf_size = (src.prec > dst.u.f.msize ? src.prec : dst.u.f.msize)/8 + 1;
+            int_buf = (uint8_t*)H5MM_calloc(buf_size);
+
+            /* The conversion loop */
+            for (elmtno=0; elmtno<nelmts; elmtno++) {
+                hsize_t     sign = 0;               /*source sign bit value         */
+                hsize_t     is_max_neg = 0;         /*source is maximal negative value*/
+                hsize_t     do_round = 0;           /*whether there is roundup      */
+                hsize_t     trailing = 0;           /*whether there is trailing after 1st roundup bit*/
+
+                /*
+                 * If the source and destination buffers overlap then use a
+                 * temporary buffer for the destination.
+                 */
+                if (direction>0) {
+                    s = sp;
+                    d = elmtno<olap ? dbuf : dp;
+                } else {
+                    s = sp;
+                    d = elmtno+olap >= nelmts ? dbuf : dp;
+                }
+#ifndef NDEBUG
+                /* I don't quite trust the overlap calculations yet --rpm */
+                if (d==dbuf) {
+                    assert ((dp>=sp && dp<sp+src_p->size) ||
+                            (sp>=dp && sp<dp+dst_p->size));
+                } else {
+                    assert ((dp<sp && dp+dst_p->size<=sp) ||
+                            (sp<dp && sp+src_p->size<=dp));
+                }
+#endif
+
+                /*
+                 * Put the data in little endian order so our loops aren't so
+                 * complicated.  We'll do all the conversion stuff assuming
+                 * little endian and then we'll fix the order at the end.
+                 */
+                if (H5T_ORDER_BE==src.order) {
+                    half_size = src_p->size/2;
+                    for (i=0; i<half_size; i++) {
+                        uint8_t tmp = s[src_p->size-(i+1)];
+                        s[src_p->size-(i+1)] = s[i];
+                        s[i] = tmp;
+                    }
+                }
+                
+                /*zero-set all destination bits*/ 
+                H5T_bit_set (d, dst.offset, dst.prec, FALSE);
+                
+                /* Copy source into a temporary buffer */
+                H5T_bit_copy(int_buf, 0, s, src.offset, src.prec);
+
+
+/* For debug */
+/*HDmemset(int_buf, 0, buf_size);
+H5T_bit_set(int_buf, 0, src.prec, 1);*/
+
+/*fprintf(stderr, "\n no. %d int_buf=0x ", elmtno);
+for(i=0; i<buf_size; i++)
+    	fprintf(stderr, "%02x ", int_buf[i]);*/
+/*fprintf(stderr, "\n     s=0x ");
+for(i=0; i<buf_size-1; i++)
+    	fprintf(stderr, "%02x ", s[i]);*/
+
+                /*
+                 * Find the sign bit value of the source.
+                 */
+                if (H5T_SGN_2 == src.u.i.sign)
+                    sign = H5T_bit_get_d(int_buf, src.prec-1, 1);
+
+                /*
+                 * What is the bit position(starting from 0 as first one) for the most significant 
+		 * bit(MSB) of S which is set?
+                 */
+                if(H5T_SGN_2 == src.u.i.sign) {
+                    sfirst = H5T_bit_find(int_buf, 0, src.prec-1, H5T_BIT_MSB, TRUE);
+                    if(sign && sfirst < 0)
+			/* The case 0x80...00, which is negative with maximal value */
+                        is_max_neg = 1;    
+                } else if(H5T_SGN_NONE == src.u.i.sign)
+                    sfirst = H5T_bit_find(int_buf, 0, src.prec, H5T_BIT_MSB, TRUE);
+/*fprintf(stderr, "\n     is_max_neg=%d", is_max_neg);*/
+
+                /* Handle special cases here.  Integer is zero */
+                if(!sign && sfirst < 0)
+                    goto padding;
+                
+                /*
+                 * Convert source integer if it's negative
+                 */
+                if (H5T_SGN_2 == src.u.i.sign && sign) {
+                    if(!is_max_neg) {
+                        /* Equivalent to ~(i - 1) */
+                        H5T_bit_dec(int_buf, 0, buf_size*8);
+                        H5T_bit_neg(int_buf, 0, buf_size*8);
+                        sfirst = H5T_bit_find(int_buf, 0, src.prec-1, H5T_BIT_MSB, TRUE);
+                    } else {
+			/* If it's maximal negative number 0x80...000, treat it as if it overflows
+			 * (create a carry) to help conversion.  i.e. a character type number 0x80
+			 * is treated as 0x100.
+			 */
+                        sfirst = src.prec-1;
+                        is_max_neg = 0;
+                    }
+/*fprintf(stderr, "\n     after negate int_buf=0x ");
+for(i=0; i<buf_size; i++)
+    fprintf(stderr, "%02x ", int_buf[i]);*/
+
+                    /* Sign bit has been negated if bit vector isn't 0x80...00.  Set all bits in front of 
+                     * sign bit to 0 in the temporary buffer because they're all negated from the previous
+		     * step. */
+                    H5T_bit_set(int_buf, src.prec, buf_size*8-src.prec, 0);
+/*fprintf(stderr, "\n     after bits in front of sign off int_buf=0x ");
+for(i=0; i<buf_size; i++)
+    fprintf(stderr, "%02x ", int_buf[i]);*/
+
+                    /* Set sign bit in destiny */
+                    H5T_bit_set_d(d, dst.u.f.sign, 1, sign);
+                }
+
+                first = (size_t)sfirst;
+/*fprintf(stderr, "\n     first=%d", first);*/
+
+                
+                /*
+                 * Calculate the true destination exponent by adjusting according to
+                 * the destination exponent bias.
+                 */
+                if (H5T_NORM_NONE==src.u.f.norm) {
+                    expo = first + 1 + dst.u.f.ebias;
+                } else if (H5T_NORM_IMPLIED==src.u.f.norm) {
+                    expo = first + dst.u.f.ebias;
+                } else {
+                    assert("normalization method not implemented yet" && 0);
+                    HDabort();
+                }
+
+/*fprintf(stderr, "\n     expo=%d,", expo); 
+fprintf(stderr, "\n     expo_max=%d,", expo_max);*/
+
+                /* Handle mantissa part here */
+                if (H5T_NORM_IMPLIED==src.u.f.norm) {
+                    /* Imply first bit */
+                    H5T_bit_set(int_buf, first, 1, 0);
+/*fprintf(stderr, "\n     after 1st bit implied int_buf=0x ");
+for(i=0; i<buf_size; i++)
+    fprintf(stderr, "%02x ", int_buf[i]);*/
+       		} else if (H5T_NORM_NONE==src.u.f.norm) {
+		    first++;
+		}
+
+                /* Roundup for mantissa */ 
+                if(first > dst.u.f.msize) {
+		    /* If the bit sequence is bigger than the mantissa part, we need to drop off the 
+		     * extra bits at the end and do rounding.  If we have .50...0(decimal) after radix 
+		     * point, we do roundup when the least significant digit before radix is odd, we do 
+		     * rounddown if it's even.
+		     */
+			
+                    /* Check 1st dropoff bit, see if it's set. */
+                    if(H5T_bit_get_d(int_buf, (first-dst.u.f.msize-1), 1)) {
+                    	/* Check all bits after 1st dropoff bit, see if any of them is set. */
+                        if((first-dst.u.f.msize-1) > 0 && H5T_bit_get_d(int_buf, 0, (first-dst.u.f.msize-1)))
+                            do_round = 1;
+                        else {  /* The .50...0 case */
+                            /* Check if the least significant bit is odd. */
+                            if(H5T_bit_get_d(int_buf, (first-dst.u.f.msize), 1))
+                               do_round = 1;
+                        }
+		    } 
+
+                    /* Right shift to drop off extra bits */
+                    H5T_bit_shift(int_buf, (ssize_t)(dst.u.f.msize-first), buf_size);
+
+                    if(do_round) {
+                        H5T_bit_inc(int_buf, 0, buf_size*8);
+                        do_round = 0;
+
+			/* If integer is like 0x0ff...fff and we need to round up the 
+			 * last f, we get 0x100...000.  Treat this special case here.
+			 */  
+                    	if(H5T_bit_get_d(int_buf, dst.u.f.msize, 1)) {
+                	    if (H5T_NORM_IMPLIED==src.u.f.norm) {
+			        /* The bit at this 1's position was impled already, so this 
+			         * number should be 0x200...000.  We need to increment the 
+			         * exponent in this case.  
+			         */ 
+			    	expo++;
+       			    } else if (H5T_NORM_NONE==src.u.f.norm) {
+				/* Right shift 1 bit to let the carried 1 fit in the mantissa,
+				 * and increment exponent by 1.
+				 */
+                    		H5T_bit_shift(int_buf, -1, buf_size);
+			 	expo++;    
+			    }
+			}
+                    }
+                } else {
+                    /* The bit sequence can fit mantissa part.  Left shift to fit in from high-order of
+		     * bit position. */
+                    H5T_bit_shift(int_buf, (ssize_t)(dst.u.f.msize-first), buf_size);
+                } 
+                    
+
+                /* Check if the exponent is too big */
+                expo_max = (hsize_t)HDpow((double)2.0, (double)dst.u.f.esize) - 1;          
+                if(expo > expo_max)
+                    expo = expo_max;
+
+                /* Set exponent in destiny */
+                H5T_bit_set_d(d, dst.u.f.epos, dst.u.f.esize, expo);
+
+                /* Copy mantissa into destiny */
+                H5T_bit_copy(d, dst.u.f.mpos, int_buf, 0, buf_size*8 > dst.u.f.msize ? dst.u.f.msize : buf_size*8);
+
+            padding:
+                /*
+                 * Set padding areas in destination.
+                 */
+                if (dst.offset>0) {
+                    assert (H5T_PAD_ZERO==dst.lsb_pad || H5T_PAD_ONE==dst.lsb_pad);
+                    H5T_bit_set (d, 0, dst.offset, (hbool_t)(H5T_PAD_ONE==dst.lsb_pad));
+                }
+                if (dst.offset+dst.prec!=8*dst_p->size) {
+                    assert (H5T_PAD_ZERO==dst.msb_pad || H5T_PAD_ONE==dst.msb_pad);
+                    H5T_bit_set (d, dst.offset+dst.prec,
+                                 8*dst_p->size - (dst.offset+ dst.prec),
+                                 (hbool_t)(H5T_PAD_ONE==dst.msb_pad));
+                }
+
+                /*
+                 * Put the destination in the correct byte order.  See note at
+                 * beginning of loop.
+                 */
+                if (H5T_ORDER_BE==dst.order) {
+                    half_size = dst_p->size/2;
+                    for (i=0; i<half_size; i++) {
+                        uint8_t tmp = d[dst_p->size-(i+1)];
+                        d[dst_p->size-(i+1)] = d[i];
+                        d[i] = tmp;
+                    }
+                }
+                
+                /*
+                 * If we had used a temporary buffer for the destination then we
+                 * should copy the value to the true destination buffer.
+                 */
+                if (d==dbuf)
+                    HDmemcpy (dp, d, dst_p->size);
+                if (buf_stride) {
+                    sp += direction * buf_stride;
+                    dp += direction * buf_stride;
+                } else {
+                    sp += direction * src_p->size;
+                    dp += direction * dst_p->size;
+                }
+
+                HDmemset(int_buf, 0, buf_size);
+            }
+           
+            H5MM_xfree(int_buf);
+
+            break;
+                
+        default:
+            HGOTO_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "unknown conversion command");
+    }
+
+done:
+    FUNC_LEAVE_NOAPI(ret_value);
+}
diff --git a/src/H5Tpkg.h b/src/H5Tpkg.h
index 147b639..ad817f3 100644
--- a/src/H5Tpkg.h
+++ b/src/H5Tpkg.h
@@ -383,6 +383,10 @@ H5_DLL herr_t H5T_conv_f_i(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
 			    hsize_t nelmts, size_t buf_stride,
                             size_t bkg_stride, void *_buf, void *bkg,
                             hid_t dset_xfer_plist);
+H5_DLL herr_t H5T_conv_i_f(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
+			    hsize_t nelmts, size_t buf_stride,
+                            size_t bkg_stride, void *_buf, void *bkg,
+                            hid_t dset_xfer_plist);
 H5_DLL herr_t H5T_conv_s_s(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
 			    hsize_t nelmts, size_t buf_stride,
                             size_t bkg_stride, void *_buf, void *bkg,